rubymail 0.11

data/lib/multimap/spec/multiset_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Multiset do
+  it_should_behave_like "Set"
+
+  it "should return the multiplicity of the element" do
+    set = Multiset.new([:a, :a, :b, :b, :b, :c])
+    expect(set.multiplicity(:a)).to eql(2)
+    expect(set.multiplicity(:b)).to eql(3)
+    expect(set.multiplicity(:c)).to eql(1)
+  end
+
+  it "should return the cardinality of the set" do
+    set = Multiset.new([:a, :a, :b, :b, :b, :c])
+    expect(set.cardinality).to eql(6)
+  end
+
+  it "should be eql" do
+    s1 = Multiset.new([:a, :b])
+    s2 = Multiset.new([:b, :a])
+    expect(s1).to eql(s2)
+
+    s1 = Multiset.new([:a, :a])
+    s2 = Multiset.new([:a])
+    expect(s1).to_not eql(s2)
+  end
+
+  it "should replace the contents of the set" do
+    set = Multiset[:a, :b, :b, :c]
+    ret = set.replace(Multiset[:a, :a, :b, :b, :b, :c])
+
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[:a, :a, :b, :b, :b, :c])
+
+    set = Multiset[:a, :b, :b, :c]
+    ret = set.replace([:a, :a, :b, :b, :b, :c])
+
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[:a, :a, :b, :b, :b, :c])
+  end
+
+  it "should return true if the set is a superset of the given set" do
+    set = Multiset[1, 2, 2, 3]
+
+    expect(set.superset?(Multiset[])).to be_true
+    expect(set.superset?(Multiset[1, 2])).to be_true
+    expect(set.superset?(Multiset[1, 2, 3])).to be_true
+    expect(set.superset?(Multiset[1, 2, 2, 3])).to be_true
+    expect(set.superset?(Multiset[1, 2, 2, 2])).to be_false
+    expect(set.superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.superset?(Multiset[1, 4])).to be_false
+  end
+
+  it "should return true if the set is a proper superset of the given set" do
+    set = Multiset[1, 2, 2, 3, 3]
+
+    expect(set.proper_superset?(Multiset[])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2, 3])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2, 2, 3, 3])).to be_false
+    expect(set.proper_superset?(Multiset[1, 2, 2, 2])).to be_false
+    expect(set.proper_superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.proper_superset?(Multiset[1, 4])).to be_false
+  end
+
+  it "should return true if the set is a subset of the given set" do
+    set = Multiset[1, 2, 2, 3]
+
+    expect(set.subset?(Multiset[1, 2, 2, 3, 4])).to be_true
+    expect(set.subset?(Multiset[1, 2, 2, 3, 3])).to be_true
+    expect(set.subset?(Multiset[1, 2, 2, 3])).to be_true
+    expect(set.subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.subset?(Multiset[1, 2, 2])).to be_false
+    expect(set.subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.subset?(Multiset[])).to be_false
+  end
+
+  it "should return true if the set is a proper subset of the given set" do
+    set = Multiset[1, 2, 2, 3, 3]
+
+    expect(set.proper_subset?(Multiset[1, 2, 2, 3, 3, 4])).to be_true
+    expect(set.proper_subset?(Multiset[1, 2, 2, 3, 3])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2, 2])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_subset?(Multiset[])).to be_false
+  end
+
+  it "should delete the objects from the set and return self" do
+    set = Multiset[1, 2, 2, 3]
+
+    ret = set.delete(4)
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3])
+
+    ret = set.delete(2)
+    expect(set).to eql(ret)
+    expect(set).to eql(Multiset[1, 3])
+  end
+
+  it "should delete the number objects from the set and return self" do
+    set = Multiset[1, 2, 2, 3]
+
+    ret = set.delete(2, 1)
+    expect(set).to eql(ret)
+    expect(set).to eql(Multiset[1, 2, 3])
+  end
+
+  it "should merge the elements of the given enumerable object to the set and return self" do
+    set = Multiset[1, 2, 3]
+    ret = set.merge([2, 4, 5])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4, 5])
+
+    set = Multiset[1, 2, 3]
+    ret = set.merge(Multiset[2, 4, 5])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4, 5])
+  end
+
+  it "should delete every element that appears in the given enumerable object and return self" do
+    set = Multiset[1, 2, 2, 3]
+    ret = set.subtract([2, 4, 6])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 3])
+  end
+
+  it "should return a new set containing elements common to the set and the given enumerable object" do
+    set = Multiset[1, 2, 2, 3, 4]
+
+    ret = set & [2, 2, 4, 5]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[2, 2, 4])
+
+    set = Multiset[1, 2, 3]
+
+    ret = set & [1, 2, 2, 2]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 2])
+  end
+
+  it "should return a new set containing elements exclusive between the set and the given enumerable object" do
+    set = Multiset[1, 2, 3, 4, 5]
+    ret = set ^ [2, 4, 5, 5]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3, 5])
+
+    set = Multiset[1, 2, 4, 5, 5]
+    ret = set ^ [2, 3, 4, 5]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3, 5])
+  end
+
+  it "should marshal set" do
+    set = Multiset[1, 2, 3, 4, 5]
+    data = Marshal.dump(set)
+    expect(Marshal.load(data)).to eql(set)
+  end
+
+  it "should dump yaml" do
+    require 'yaml'
+
+    set = Multiset[1, 2, 3, 4, 5]
+    data = YAML.dump(set)
+    expect(YAML.load(data)).to eql(set)
+  end
+end
+
+describe Multiset, "with inital values" do
+  it_should_behave_like "Set with inital values [1, 2]"
+
+  before do
+    @set = Multiset.new([1, 2])
+  end
+
+  it "should return the multiplicity of the element" do
+    expect(@set.multiplicity(1)).to eql(1)
+    expect(@set.multiplicity(2)).to eql(1)
+  end
+
+  it "should return the cardinality of the set" do
+    expect(@set.cardinality).to eql(2)
+  end
+end

data/lib/multimap/spec/nested_multimap_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe NestedMultimap, "with inital values" do
+  it_should_behave_like "Enumerable Multimap with inital values {'a' => [100], 'b' => [200, 300]}"
+  it_should_behave_like "Hash Multimap with inital values {'a' => [100], 'b' => [200, 300]}"
+
+  before do
+    @map = NestedMultimap["a" => [100], "b" => [200, 300]]
+  end
+
+  it "should set value at nested key" do
+    @map["foo", "bar", "baz"] = 100
+    expect(@map["foo", "bar", "baz"]).to eql([100])
+  end
+
+  it "should allow nil keys to be set" do
+    @map["b", nil] = 400
+    @map["b", "c"] = 500
+
+    expect(@map["a"]).to eql([100])
+    expect(@map["b"]).to eql([200, 300])
+    expect(@map["b", nil]).to eql([200, 300, 400])
+    expect(@map["b", "c"]).to eql([200, 300, 500])
+  end
+
+  it "should treat missing keys as append to all" do
+    @map[] = 400
+    expect(@map["a"]).to eql([100, 400])
+    expect(@map["b"]).to eql([200, 300, 400])
+    expect(@map["c"]).to eql([400])
+    expect(@map[nil]).to eql([400])
+  end
+
+  it "should append the value to default containers" do
+    @map << 400
+    expect(@map["a"]).to eql([100, 400])
+    expect(@map["b"]).to eql([200, 300, 400])
+    expect(@map["c"]).to eql([400])
+    expect(@map[nil]).to eql([400])
+  end
+
+  it "should append the value to all containers" do
+    @map << 500
+    expect(@map["a"]).to eql([100, 500])
+    expect(@map["b"]).to eql([200, 300, 500])
+    expect(@map[nil]).to eql([500])
+  end
+
+  it "default values should be copied to new containers" do
+    @map << 300
+    @map["x"] = 100
+    expect(@map["x"]).to eql([300, 100])
+  end
+
+  it "should list all containers" do
+    expect(@map.containers).to sorted_eql([[100], [200, 300]])
+  end
+
+  it "should list all values" do
+    expect(@map.values).to sorted_eql([100, 200, 300])
+  end
+end
+
+describe NestedMultimap, "with nested values" do
+  before do
+    @map = NestedMultimap.new
+    @map["a"] = 100
+    @map["b"] = 200
+    @map["b", "c"] = 300
+    @map["c", "e"] = 400
+    @map["c"] = 500
+  end
+
+  it "should retrieve container of values for key" do
+    expect(@map["a"]).to eql([100])
+    expect(@map["b"]).to eql([200])
+    expect(@map["c"]).to eql([500])
+    expect(@map["a", "b"]).to eql([100])
+    expect(@map["b", "c"]).to eql([200, 300])
+    expect(@map["c", "e"]).to eql([400, 500])
+  end
+
+  it "should append the value to default containers" do
+    @map << 600
+    expect(@map["a"]).to eql([100, 600])
+    expect(@map["b"]).to eql([200, 600])
+    expect(@map["c"]).to eql([500, 600])
+    expect(@map["a", "b"]).to eql([100, 600])
+    expect(@map["b", "c"]).to eql([200, 300, 600])
+    expect(@map["c", "e"]).to eql([400, 500, 600])
+    expect(@map[nil]).to eql([600])
+  end
+
+  it "should duplicate the containers" do
+    map2 = @map.dup
+    expect(map2).to_not equal(@map)
+    expect(map2).to eql(@map)
+
+    expect(map2["a"]).to eql([100])
+    expect(map2["b"]).to eql([200])
+    expect(map2["c"]).to eql([500])
+    expect(map2["a", "b"]).to eql([100])
+    expect(map2["b", "c"]).to eql([200, 300])
+    expect(map2["c", "e"]).to eql([400, 500])
+
+    expect(map2["a"]).to_not equal(@map["a"])
+    expect(map2["b"]).to_not equal(@map["b"])
+    expect(map2["c"]).to_not equal(@map["c"])
+    expect(map2["a", "b"]).to_not equal(@map["a", "b"])
+    expect(map2["b", "c"]).to_not equal(@map["b", "c"])
+    expect(map2["c", "e"]).to_not equal(@map["c", "e"])
+
+    expect(map2.default).to_not equal(@map.default)
+    expect(map2.default).to eql(@map.default)
+  end
+
+  it "should iterate over each key/value pair and yield an array" do
+    a = []
+    @map.each { |pair| a << pair }
+    expect(a).to sorted_eql([
+      ["a", 100],
+      [["b", "c"], 200],
+      [["b", "c"], 300],
+      [["c", "e"], 400],
+      [["c", "e"], 500]
+    ])
+  end
+
+  it "should iterate over each key/container" do
+    a = []
+    @map.each_association { |key, container| a << [key, container] }
+    expect(a).to sorted_eql([
+      ["a", [100]],
+      [["b", "c"], [200, 300]],
+      [["c", "e"], [400, 500]]
+    ])
+  end
+
+  it "should iterate over each container plus the default" do
+    a = []
+    @map.each_container_with_default { |container| a << container }
+    expect(a).to sorted_eql([
+      [100],
+      [200, 300],
+      [200],
+      [400, 500],
+      [500],
+      []
+    ])
+  end
+
+  it "should iterate over each key" do
+    a = []
+    @map.each_key { |key| a << key }
+    expect(a).to sorted_eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
+  end
+
+  it "should iterate over each key/value pair and yield the pair" do
+    h = {}
+    @map.each_pair { |key, value| (h[key] ||= []) << value }
+    expect(h).to eql({
+      "a" => [100],
+      ["c", "e"] => [400, 500],
+      ["b", "c"] => [200, 300]
+    })
+  end
+
+  it "should iterate over each value" do
+    a = []
+    @map.each_value { |value| a << value }
+    expect(a).to sorted_eql([100, 200, 300, 400, 500])
+  end
+
+  it "should list all containers" do
+    expect(@map.containers).to sorted_eql([[100], [200, 300], [400, 500]])
+  end
+
+  it "should list all containers plus the default" do
+    expect(@map.containers_with_default).to sorted_eql([[100], [200, 300], [200], [400, 500], [500], []])
+  end
+
+  it "should return array of keys" do
+    expect(@map.keys).to eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
+  end
+
+  it "should list all values" do
+    expect(@map.values).to sorted_eql([100, 200, 300, 400, 500])
+  end
+end
+
+describe NestedMultimap, "with", Set do
+  it_should_behave_like "Enumerable Multimap with inital values {'a' => [100], 'b' => [200, 300]}"
+  it_should_behave_like "Hash Multimap with inital values {'a' => [100], 'b' => [200, 300]}"
+
+  before do
+    @container = Set
+    @map = NestedMultimap.new(@container.new)
+    @map["a"] = 100
+    @map["b"] = 200
+    @map["b"] = 300
+  end
+end

data/lib/multimap/spec/set_examples.rb

@@ -0,0 +1,301 @@
+shared_examples_for Set do
+  it "should create a new set containing the given objects" do
+    Multiset[]
+    Multiset[nil]
+    Multiset[1, 2, 3]
+
+    expect(Multiset[].size).to eql(0)
+    expect(Multiset[nil].size).to eql(1)
+    expect(Multiset[[]].size).to eql(1)
+    expect(Multiset[[nil]].size).to eql(1)
+
+    set = Multiset[2, 4, 6, 4]
+    expect(Multiset.new([2, 4, 6])).to_not eql(set)
+
+    set = Multiset[2, 4, 6, 4]
+    expect(Multiset.new([2, 4, 6, 4])).to eql(set)
+  end
+
+  it "should create a new set containing the elements of the given enumerable object" do
+    Multiset.new()
+    Multiset.new(nil)
+    Multiset.new([])
+    Multiset.new([1, 2])
+    Multiset.new('a'..'c')
+
+    expect(lambda { Multiset.new(false) }).to raise_error
+    expect(lambda { Multiset.new(1) }).to raise_error
+    expect(lambda { Multiset.new(1, 2) }).to raise_error
+
+    expect(Multiset.new().size).to eql(0)
+    expect(Multiset.new(nil).size).to eql(0)
+    expect(Multiset.new([]).size).to eql(0)
+    expect(Multiset.new([nil]).size).to eql(1)
+
+    ary = [2, 4, 6, 4]
+    set = Multiset.new(ary)
+    ary.clear
+    expect(set).to_not be_empty
+    expect(set.size).to eql(4)
+
+    ary = [1, 2, 3]
+
+    s = Multiset.new(ary) { |o| o * 2 }
+    expect([2, 4, 6]).to eql(s.sort)
+  end
+
+  it "should duplicate set" do
+    set1 = Multiset[1, 2]
+    set2 = set1.dup
+
+    expect(set1).to_not equal(set2)
+
+    expect(set1).to eql(set2)
+
+    set1.add(3)
+
+    expect(set1).to_not eql(set2)
+  end
+
+  it "should return the number of elements" do
+    expect(Multiset[].size).to eql(0)
+    expect(Multiset[1, 2].size).to eql(2)
+    expect(Multiset[1, 2, 1].size).to eql(3)
+  end
+
+  it "should return true if the set contains no elements" do
+    expect(Multiset[]).to be_empty
+    expect(Multiset[1, 2]).to_not be_empty
+  end
+
+  it "should remove all elements and returns self" do
+    set = Multiset[1, 2]
+    ret = set.clear
+
+    expect(set).to equal(ret)
+    expect(set).to be_empty
+  end
+
+  it "should replaces the contents of the set with the contents of the given enumerable object and returns self" do
+    set = Multiset[1, 2]
+    ret = set.replace('a'..'c')
+
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset['a', 'b', 'c'])
+  end
+
+  it "should convert the set to an array" do
+    set = Multiset[1, 2, 3, 2]
+    ary = set.to_a
+
+    expect(ary.sort).to eql([1, 2, 2, 3])
+  end
+
+  it "should return true if the set contains the given object" do
+    set = Multiset[1, 2, 3]
+
+    expect(set.include?(1)).to be_true
+    expect(set.include?(2)).to be_true
+    expect(set.include?(3)).to be_true
+    expect(set.include?(0)).to be_false
+    expect(set.include?(nil)).to be_false
+
+    set = Multiset["1", nil, "2", nil, "0", "1", false]
+    expect(set.include?(nil)).to be_true
+    expect(set.include?(false)).to be_true
+    expect(set.include?("1")).to be_true
+    expect(set.include?(0)).to be_false
+    expect(set.include?(true)).to be_false
+  end
+
+  it "should return true if the set is a superset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    expect(lambda { set.superset?() }).to raise_error
+    expect(lambda { set.superset?(2) }).to raise_error
+    expect(lambda { set.superset?([2]) }).to raise_error
+
+    expect(set.superset?(Multiset[])).to be_true
+    expect(set.superset?(Multiset[1, 2])).to be_true
+    expect(set.superset?(Multiset[1, 2, 3])).to be_true
+    expect(set.superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.superset?(Multiset[1, 4])).to be_false
+
+    expect(Multiset[].superset?(Multiset[])).to be_true
+  end
+
+  it "should return true if the set is a proper superset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    expect(lambda { set.proper_superset?() }).to raise_error
+    expect(lambda { set.proper_superset?(2) }).to raise_error
+    expect(lambda { set.proper_superset?([2]) }).to raise_error
+
+    expect(set.proper_superset?(Multiset[])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.proper_superset?(Multiset[1, 4])).to be_false
+
+    expect(Multiset[].proper_superset?(Multiset[])).to be_false
+  end
+
+  it "should return true if the set is a subset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    expect(lambda { set.subset?() }).to raise_error
+    expect(lambda { set.subset?(2) }).to raise_error
+    expect(lambda { set.subset?([2]) }).to raise_error
+
+    expect(set.subset?(Multiset[1, 2, 3, 4])).to be_true
+    expect(set.subset?(Multiset[1, 2, 3])).to be_true
+    expect(set.subset?(Multiset[1, 2])).to be_false
+    expect(set.subset?(Multiset[])).to be_false
+
+    expect(Multiset[].subset?(Multiset[1])).to be_true
+    expect(Multiset[].subset?(Multiset[])).to be_true
+  end
+
+  it "should return true if the set is a proper subset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    expect(lambda { set.proper_subset?() }).to raise_error
+    expect(lambda { set.proper_subset?(2) }).to raise_error
+    expect(lambda { set.proper_subset?([2]) }).to raise_error
+
+    expect(set.proper_subset?(Multiset[1, 2, 3, 4])).to be_true
+    expect(set.proper_subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2])).to be_false
+    expect(set.proper_subset?(Multiset[])).to be_false
+
+    expect(Multiset[].proper_subset?(Multiset[])).to be_false
+  end
+
+  it "should add the given object to the set and return self" do
+    set = Multiset[1, 2, 3]
+
+    ret = set.add(2)
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3])
+
+    ret = set.add(4)
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4])
+  end
+
+  it "should delete the given object from the set and return self" do
+    set = Multiset[1, 2, 3]
+
+    ret = set.delete(4)
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 3])
+
+    ret = set.delete(2)
+    expect(set).to eql(ret)
+    expect(set).to eql(Multiset[1, 3])
+  end
+
+  it "should delete every element of the set for which block evaluates to true, and return self" do
+    set = Multiset.new(1..10)
+    ret = set.delete_if { |i| i > 10 }
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset.new(1..10))
+
+    set = Multiset.new(1..10)
+    ret = set.delete_if { |i| i % 3 == 0 }
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 4, 5, 7, 8, 10])
+  end
+
+  it "should deletes every element of the set for which block evaluates to true but return nil if no changes were made" do
+    set = Multiset.new(1..10)
+
+    ret = set.reject! { |i| i > 10 }
+    expect(ret).to be_nil
+    expect(set).to eql(Multiset.new(1..10))
+
+    ret = set.reject! { |i| i % 3 == 0 }
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 4, 5, 7, 8, 10])
+  end
+
+  it "should merge the elements of the given enumerable object to the set and return self" do
+    set = Multiset[1, 2, 3]
+
+    ret = set.merge([2, 4, 6])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4, 6])
+  end
+
+  it "should delete every element that appears in the given enumerable object and return self" do
+    set = Multiset[1, 2, 3]
+
+    ret = set.subtract([2, 4, 6])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 3])
+  end
+
+  it "should return a new set built by merging the set and the elements of the given enumerable object" do
+    set = Multiset[1, 2, 3]
+
+    ret = set + [2, 4, 6]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 2, 2, 3, 4, 6])
+  end
+
+  it "should return a new set built by duplicating the set, removing every element that appears in the given enumerable object" do
+    set = Multiset[1, 2, 3]
+
+    ret = set - [2, 4, 6]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3])
+  end
+
+  it "should return a new set containing elements common to the set and the given enumerable object" do
+    set = Multiset[1, 2, 3, 4]
+
+    ret = set & [2, 4, 6]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[2, 4])
+  end
+
+  it "should return a new set containing elements exclusive between the set and the given enumerable object" do
+    set = Multiset[1, 2, 3, 4]
+    ret = set ^ [2, 4, 5]
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3, 5])
+  end
+end
+
+shared_examples_for Set, "with inital values [1, 2]" do
+  it "should add element to set" do
+    @set.add("foo")
+
+    expect(@set.include?(1)).to be_true
+    expect(@set.include?(2)).to be_true
+    expect(@set.include?("foo")).to be_true
+  end
+
+  it "should merge elements into the set" do
+    @set.merge([2, 6])
+
+    expect(@set.include?(1)).to be_true
+    expect(@set.include?(2)).to be_true
+    expect(@set.include?(2)).to be_true
+    expect(@set.include?(6)).to be_true
+  end
+
+  it "should iterate over all the values in the set" do
+    a = []
+    @set.each { |o| a << o }
+    expect(a).to eql([1, 2])
+  end
+
+  it "should convert to an array" do
+    expect(@set.to_a).to eql([1, 2])
+  end
+
+  it "should convert to a set" do
+    expect(@set.to_set.to_a).to eql([1, 2])
+  end
+end