mailgun 0.7 → 0.8

data/lib/multimap/spec/multimap_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Multimap, "with inital values {'a' => [100], 'b' => [200, 300]}" 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 = Multimap["a" => 100, "b" => [200, 300]]
+  end
+end
+
+describe Multimap, "with inital values {'a' => [100], 'b' => [200, 300]}" 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 = Multimap["a", 100, "b", [200, 300]]
+  end
+end
+
+describe Multimap, "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 = Multimap.new(@container.new)
+    @map["a"] = 100
+    @map["b"] = 200
+    @map["b"] = 300
+  end
+end
+
+describe Multimap, "with", MiniArray 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 = MiniArray
+    @map = Multimap.new(@container.new)
+    @map["a"] = 100
+    @map["b"] = 200
+    @map["b"] = 300
+  end
+end

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])
+    set.multiplicity(:a).should eql(2)
+    set.multiplicity(:b).should eql(3)
+    set.multiplicity(:c).should eql(1)
+  end
+
+  it "should return the cardinality of the set" do
+    set = Multiset.new([:a, :a, :b, :b, :b, :c])
+    set.cardinality.should eql(6)
+  end
+
+  it "should be eql" do
+    s1 = Multiset.new([:a, :b])
+    s2 = Multiset.new([:b, :a])
+    s1.should eql(s2)
+
+    s1 = Multiset.new([:a, :a])
+    s2 = Multiset.new([:a])
+    s1.should_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])
+
+    set.should equal(ret)
+    set.should eql(Multiset[:a, :a, :b, :b, :b, :c])
+
+    set = Multiset[:a, :b, :b, :c]
+    ret = set.replace([:a, :a, :b, :b, :b, :c])
+
+    set.should equal(ret)
+    set.should 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]
+
+    set.superset?(Multiset[]).should be_true
+    set.superset?(Multiset[1, 2]).should be_true
+    set.superset?(Multiset[1, 2, 3]).should be_true
+    set.superset?(Multiset[1, 2, 2, 3]).should be_true
+    set.superset?(Multiset[1, 2, 2, 2]).should be_false
+    set.superset?(Multiset[1, 2, 3, 4]).should be_false
+    set.superset?(Multiset[1, 4]).should 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]
+
+    set.proper_superset?(Multiset[]).should be_true
+    set.proper_superset?(Multiset[1, 2]).should be_true
+    set.proper_superset?(Multiset[1, 2, 3]).should be_true
+    set.proper_superset?(Multiset[1, 2, 2, 3, 3]).should be_false
+    set.proper_superset?(Multiset[1, 2, 2, 2]).should be_false
+    set.proper_superset?(Multiset[1, 2, 3, 4]).should be_false
+    set.proper_superset?(Multiset[1, 4]).should be_false
+  end
+
+  it "should return true if the set is a subset of the given set" do
+    set = Multiset[1, 2, 2, 3]
+
+    set.subset?(Multiset[1, 2, 2, 3, 4]).should be_true
+    set.subset?(Multiset[1, 2, 2, 3, 3]).should be_true
+    set.subset?(Multiset[1, 2, 2, 3]).should be_true
+    set.subset?(Multiset[1, 2, 3]).should be_false
+    set.subset?(Multiset[1, 2, 2]).should be_false
+    set.subset?(Multiset[1, 2, 3]).should be_false
+    set.subset?(Multiset[]).should 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]
+
+    set.proper_subset?(Multiset[1, 2, 2, 3, 3, 4]).should be_true
+    set.proper_subset?(Multiset[1, 2, 2, 3, 3]).should be_false
+    set.proper_subset?(Multiset[1, 2, 3]).should be_false
+    set.proper_subset?(Multiset[1, 2, 2]).should be_false
+    set.proper_subset?(Multiset[1, 2, 3]).should be_false
+    set.proper_subset?(Multiset[]).should 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)
+    set.should equal(ret)
+    set.should eql(Multiset[1, 2, 2, 3])
+
+    ret = set.delete(2)
+    set.should eql(ret)
+    set.should 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)
+    set.should eql(ret)
+    set.should 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])
+    set.should equal(ret)
+    set.should eql(Multiset[1, 2, 2, 3, 4, 5])
+
+    set = Multiset[1, 2, 3]
+    ret = set.merge(Multiset[2, 4, 5])
+    set.should equal(ret)
+    set.should 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])
+    set.should equal(ret)
+    set.should 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]
+    set.should_not equal(ret)
+    ret.should eql(Multiset[2, 2, 4])
+
+    set = Multiset[1, 2, 3]
+
+    ret = set & [1, 2, 2, 2]
+    set.should_not equal(ret)
+    ret.should 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]
+    set.should_not equal(ret)
+    ret.should eql(Multiset[1, 3, 5])
+
+    set = Multiset[1, 2, 4, 5, 5]
+    ret = set ^ [2, 3, 4, 5]
+    set.should_not equal(ret)
+    ret.should eql(Multiset[1, 3, 5])
+  end
+
+  it "should marshal set" do
+    set = Multiset[1, 2, 3, 4, 5]
+    data = Marshal.dump(set)
+    Marshal.load(data).should eql(set)
+  end
+
+  it "should dump yaml" do
+    require 'yaml'
+
+    set = Multiset[1, 2, 3, 4, 5]
+    data = YAML.dump(set)
+    YAML.load(data).should 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
+    @set.multiplicity(1).should eql(1)
+    @set.multiplicity(2).should eql(1)
+  end
+
+  it "should return the cardinality of the set" do
+    @set.cardinality.should 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
+    @map["foo", "bar", "baz"].should eql([100])
+  end
+
+  it "should allow nil keys to be set" do
+    @map["b", nil] = 400
+    @map["b", "c"] = 500
+
+    @map["a"].should eql([100])
+    @map["b"].should eql([200, 300])
+    @map["b", nil].should eql([200, 300, 400])
+    @map["b", "c"].should eql([200, 300, 500])
+  end
+
+  it "should treat missing keys as append to all" do
+    @map[] = 400
+    @map["a"].should eql([100, 400])
+    @map["b"].should eql([200, 300, 400])
+    @map["c"].should eql([400])
+    @map[nil].should eql([400])
+  end
+
+  it "should append the value to default containers" do
+    @map << 400
+    @map["a"].should eql([100, 400])
+    @map["b"].should eql([200, 300, 400])
+    @map["c"].should eql([400])
+    @map[nil].should eql([400])
+  end
+
+  it "should append the value to all containers" do
+    @map << 500
+    @map["a"].should eql([100, 500])
+    @map["b"].should eql([200, 300, 500])
+    @map[nil].should eql([500])
+  end
+
+  it "default values should be copied to new containers" do
+    @map << 300
+    @map["x"] = 100
+    @map["x"].should eql([300, 100])
+  end
+
+  it "should list all containers" do
+    @map.containers.should sorted_eql([[100], [200, 300]])
+  end
+
+  it "should list all values" do
+    @map.values.should 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
+    @map["a"].should eql([100])
+    @map["b"].should eql([200])
+    @map["c"].should eql([500])
+    @map["a", "b"].should eql([100])
+    @map["b", "c"].should eql([200, 300])
+    @map["c", "e"].should eql([400, 500])
+  end
+
+  it "should append the value to default containers" do
+    @map << 600
+    @map["a"].should eql([100, 600])
+    @map["b"].should eql([200, 600])
+    @map["c"].should eql([500, 600])
+    @map["a", "b"].should eql([100, 600])
+    @map["b", "c"].should eql([200, 300, 600])
+    @map["c", "e"].should eql([400, 500, 600])
+    @map[nil].should eql([600])
+  end
+
+  it "should duplicate the containers" do
+    map2 = @map.dup
+    map2.should_not equal(@map)
+    map2.should eql(@map)
+
+    map2["a"].should eql([100])
+    map2["b"].should eql([200])
+    map2["c"].should eql([500])
+    map2["a", "b"].should eql([100])
+    map2["b", "c"].should eql([200, 300])
+    map2["c", "e"].should eql([400, 500])
+
+    map2["a"].should_not equal(@map["a"])
+    map2["b"].should_not equal(@map["b"])
+    map2["c"].should_not equal(@map["c"])
+    map2["a", "b"].should_not equal(@map["a", "b"])
+    map2["b", "c"].should_not equal(@map["b", "c"])
+    map2["c", "e"].should_not equal(@map["c", "e"])
+
+    map2.default.should_not equal(@map.default)
+    map2.default.should eql(@map.default)
+  end
+
+  it "should iterate over each key/value pair and yield an array" do
+    a = []
+    @map.each { |pair| a << pair }
+    a.should 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] }
+    a.should 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 }
+    a.should sorted_eql([
+      [100],
+      [200, 300],
+      [200],
+      [400, 500],
+      [500],
+      []
+    ])
+  end
+
+  it "should iterate over each key" do
+    a = []
+    @map.each_key { |key| a << key }
+    a.should 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 }
+    h.should 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 }
+    a.should sorted_eql([100, 200, 300, 400, 500])
+  end
+
+  it "should list all containers" do
+    @map.containers.should sorted_eql([[100], [200, 300], [400, 500]])
+  end
+
+  it "should list all containers plus the default" do
+    @map.containers_with_default.should sorted_eql([[100], [200, 300], [200], [400, 500], [500], []])
+  end
+
+  it "should return array of keys" do
+    @map.keys.should eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
+  end
+
+  it "should list all values" do
+    @map.values.should 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]
+
+    Multiset[].size.should eql(0)
+    Multiset[nil].size.should eql(1)
+    Multiset[[]].size.should eql(1)
+    Multiset[[nil]].size.should eql(1)
+
+    set = Multiset[2, 4, 6, 4]
+    Multiset.new([2, 4, 6]).should_not eql(set)
+
+    set = Multiset[2, 4, 6, 4]
+    Multiset.new([2, 4, 6, 4]).should 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')
+
+    lambda { Multiset.new(false) }.should raise_error
+    lambda { Multiset.new(1) }.should raise_error
+    lambda { Multiset.new(1, 2) }.should raise_error
+
+    Multiset.new().size.should eql(0)
+    Multiset.new(nil).size.should eql(0)
+    Multiset.new([]).size.should eql(0)
+    Multiset.new([nil]).size.should eql(1)
+
+    ary = [2, 4, 6, 4]
+    set = Multiset.new(ary)
+    ary.clear
+    set.should_not be_empty
+    set.size.should eql(4)
+
+    ary = [1, 2, 3]
+
+    s = Multiset.new(ary) { |o| o * 2 }
+    [2, 4, 6].should eql(s.sort)
+  end
+
+  it "should duplicate set" do
+    set1 = Multiset[1, 2]
+    set2 = set1.dup
+
+    set1.should_not equal(set2)
+
+    set1.should eql(set2)
+
+    set1.add(3)
+
+    set1.should_not eql(set2)
+  end
+
+  it "should return the number of elements" do
+    Multiset[].size.should eql(0)
+    Multiset[1, 2].size.should eql(2)
+    Multiset[1, 2, 1].size.should eql(3)
+  end
+
+  it "should return true if the set contains no elements" do
+    Multiset[].should be_empty
+    Multiset[1, 2].should_not be_empty
+  end
+
+  it "should remove all elements and returns self" do
+    set = Multiset[1, 2]
+    ret = set.clear
+
+    set.should equal(ret)
+    set.should 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')
+
+    set.should equal(ret)
+    set.should 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
+
+    ary.sort.should eql([1, 2, 2, 3])
+  end
+
+  it "should return true if the set contains the given object" do
+    set = Multiset[1, 2, 3]
+
+    set.include?(1).should be_true
+    set.include?(2).should be_true
+    set.include?(3).should be_true
+    set.include?(0).should be_false
+    set.include?(nil).should be_false
+
+    set = Multiset["1", nil, "2", nil, "0", "1", false]
+    set.include?(nil).should be_true
+    set.include?(false).should be_true
+    set.include?("1").should be_true
+    set.include?(0).should be_false
+    set.include?(true).should be_false
+  end
+
+  it "should return true if the set is a superset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    lambda { set.superset?() }.should raise_error
+    lambda { set.superset?(2) }.should raise_error
+    lambda { set.superset?([2]) }.should raise_error
+
+    set.superset?(Multiset[]).should be_true
+    set.superset?(Multiset[1, 2]).should be_true
+    set.superset?(Multiset[1, 2, 3]).should be_true
+    set.superset?(Multiset[1, 2, 3, 4]).should be_false
+    set.superset?(Multiset[1, 4]).should be_false
+
+    Multiset[].superset?(Multiset[]).should be_true
+  end
+
+  it "should return true if the set is a proper superset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    lambda { set.proper_superset?() }.should raise_error
+    lambda { set.proper_superset?(2) }.should raise_error
+    lambda { set.proper_superset?([2]) }.should raise_error
+
+    set.proper_superset?(Multiset[]).should be_true
+    set.proper_superset?(Multiset[1, 2]).should be_true
+    set.proper_superset?(Multiset[1, 2, 3]).should be_false
+    set.proper_superset?(Multiset[1, 2, 3, 4]).should be_false
+    set.proper_superset?(Multiset[1, 4]).should be_false
+
+    Multiset[].proper_superset?(Multiset[]).should be_false
+  end
+
+  it "should return true if the set is a subset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    lambda { set.subset?() }.should raise_error
+    lambda { set.subset?(2) }.should raise_error
+    lambda { set.subset?([2]) }.should raise_error
+
+    set.subset?(Multiset[1, 2, 3, 4]).should be_true
+    set.subset?(Multiset[1, 2, 3]).should be_true
+    set.subset?(Multiset[1, 2]).should be_false
+    set.subset?(Multiset[]).should be_false
+
+    Multiset[].subset?(Multiset[1]).should be_true
+    Multiset[].subset?(Multiset[]).should be_true
+  end
+
+  it "should return true if the set is a proper subset of the given set" do
+    set = Multiset[1, 2, 3]
+
+    lambda { set.proper_subset?() }.should raise_error
+    lambda { set.proper_subset?(2) }.should raise_error
+    lambda { set.proper_subset?([2]) }.should raise_error
+
+    set.proper_subset?(Multiset[1, 2, 3, 4]).should be_true
+    set.proper_subset?(Multiset[1, 2, 3]).should be_false
+    set.proper_subset?(Multiset[1, 2]).should be_false
+    set.proper_subset?(Multiset[]).should be_false
+
+    Multiset[].proper_subset?(Multiset[]).should 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)
+    set.should equal(ret)
+    set.should eql(Multiset[1, 2, 2, 3])
+
+    ret = set.add(4)
+    set.should equal(ret)
+    set.should 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)
+    set.should equal(ret)
+    set.should eql(Multiset[1, 2, 3])
+
+    ret = set.delete(2)
+    set.should eql(ret)
+    set.should 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 }
+    set.should equal(ret)
+    set.should eql(Multiset.new(1..10))
+
+    set = Multiset.new(1..10)
+    ret = set.delete_if { |i| i % 3 == 0 }
+    set.should equal(ret)
+    set.should 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 }
+    ret.should be_nil
+    set.should eql(Multiset.new(1..10))
+
+    ret = set.reject! { |i| i % 3 == 0 }
+    set.should equal(ret)
+    set.should 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])
+    set.should equal(ret)
+    set.should 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])
+    set.should equal(ret)
+    set.should 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]
+    set.should_not equal(ret)
+    ret.should 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]
+    set.should_not equal(ret)
+    ret.should 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]
+    set.should_not equal(ret)
+    ret.should 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]
+    set.should_not equal(ret)
+    ret.should 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")
+
+    @set.include?(1).should be_true
+    @set.include?(2).should be_true
+    @set.include?("foo").should be_true
+  end
+
+  it "should merge elements into the set" do
+    @set.merge([2, 6])
+
+    @set.include?(1).should be_true
+    @set.include?(2).should be_true
+    @set.include?(2).should be_true
+    @set.include?(6).should be_true
+  end
+
+  it "should iterate over all the values in the set" do
+    a = []
+    @set.each { |o| a << o }
+    a.should eql([1, 2])
+  end
+
+  it "should convert to an array" do
+    @set.to_a.should eql([1, 2])
+  end
+
+  it "should convert to a set" do
+    @set.to_set.to_a.should eql([1, 2])
+  end
+end