Improve coverage for Set and Dict with mixed types

Author: José Valim

lib/elixir/lib/dict.ex

@@ -482,8 +482,8 @@ defmodule Dict do
         target1.equal?(dict1, dict2)
 
       target1.size(dict1) == target2.size(dict2) ->
-        target1.reduce(dict1, { :cont, true }, fn({ k, v }, _acc) ->
-          case target2.fetch(dict2, k) do
+        target2.reduce(dict2, { :cont, true }, fn({ k, v }, _acc) ->
+          case target1.fetch(dict1, k) do
             { :ok, ^v } -> { :cont, true }
             _           -> { :halt, false }
           end

lib/elixir/lib/set.ex

@@ -104,9 +104,9 @@ defmodule Set do
     if target1 == target2 do
       target1.difference(set1, set2)
     else
-      target2.reduce set2, { :cont, set1 }, fn v, acc ->
+      target2.reduce(set2, { :cont, set1 }, fn v, acc ->
         { :cont, target1.delete(acc, v) }
-      end |> elem(1)
+      end) |> elem(1)
     end
   end
 
@@ -207,9 +207,9 @@ defmodule Set do
     if target1 == target2 do
       target1.intersection(set1, set2)
     else
-      target1.reduce set1, { :cont, target1.empty(set1) }, fn v, acc ->
+      target1.reduce(set1, { :cont, target1.empty(set1) }, fn v, acc ->
         { :cont, if(target2.member?(set2, v), do: target1.put(acc, v), else: acc) }
-      end |> elem(1)
+      end) |> elem(1)
     end
   end
 
@@ -322,9 +322,9 @@ defmodule Set do
     if target1 == target2 do
       target1.union(set1, set2)
     else
-      target2.reduce set2, { :cont, set1 }, fn v, acc ->
+      target2.reduce(set2, { :cont, set1 }, fn v, acc ->
         { :cont, target1.put(acc, v) }
-      end |> elem(1)
+      end) |> elem(1)
     end
   end
 

lib/elixir/test/elixir/dict_test.exs

@@ -1,5 +1,20 @@
 Code.require_file "test_helper.exs", __DIR__
 
+# A TestDict implementation used only for testing.
+defmodule TestDict do
+  def new(list // []) when is_list(list) do
+    { TestDict, list }
+  end
+
+  def reduce({ TestDict, list }, acc, fun) do
+    Enumerable.reduce(list, acc, fun)
+  end
+
+  def size({ TestDict, list }) do
+    length(list)
+  end
+end
+
 defmodule DictTest.Common do
   defmacro __using__(_) do
     quote location: :keep do
@@ -140,9 +155,9 @@ defmodule DictTest.Common do
                [{"a", 3}, {"b", 2}, {"c", :a}, {"d", 0}]
       end
 
-      test "merge/2 with enum" do
+      test "merge/2 with other dict" do
         dict1 = new_dict [{"a", 1}, {"b", 2}, {"c", 3}]
-        dict2 = Enum.zip ["a", "c", "d"], [3, :a, 0]
+        dict2 = TestDict.new [{"a",3}, {"c",:a}, {"d",0}]
         actual = Dict.merge(dict1, dict2)
         assert Dict.merge(dict1, dict2) |> Enum.sort ==
                [{"a", 3}, {"b", 2}, {"c", :a}, {"d", 0}]
@@ -329,15 +344,19 @@ defmodule DictTest.Common do
         refute Dict.equal?(dict3, dict1)
       end
 
-      test "equal?/2 with_match" do
+      test "equal?/2 with match" do
         dict1 = new_dict([{1,1}])
         dict2 = new_dict([{1.0,1}])
-        assert dict_impl.equal?(dict1, dict1)
-        refute dict_impl.equal?(dict1, dict2)
         assert Dict.equal?(dict1, dict1)
         refute Dict.equal?(dict1, dict2)
       end
 
+      test "equal?/2 with other dict" do
+        dict = new_dict([{1,1}])
+        assert Dict.equal?(dict, TestDict.new([{1,1}]))
+        refute Dict.equal?(dict, TestDict.new([{1.0,1}]))
+      end
+
       test "implements Enumerable" do
         dict = new_dict()
         assert Enum.empty?(new_dict([]))

lib/elixir/test/elixir/set_test.exs

@@ -1,5 +1,24 @@
 Code.require_file "test_helper.exs", __DIR__
 
+# A TestSet implementation used only for testing.
+defmodule TestSet do
+  def new(list // []) when is_list(list) do
+    { TestSet, list }
+  end
+
+  def reduce({ TestSet, list }, acc, fun) do
+    Enumerable.reduce(list, acc, fun)
+  end
+
+  def member?({ TestSet, list }, v) do
+    v in list
+  end
+
+  def size({ TestSet, list }) do
+    length(list)
+  end
+end
+
 defmodule SetTest.Common do
   defmacro __using__(module) do
     quote location: :keep do
@@ -37,17 +56,27 @@ defmodule SetTest.Common do
 
       test "difference/2" do
         result = Set.difference(new_set([1, 2, 3]), new_set([3]))
-        assert Set.equal?(result, HashSet.new([1, 2]))
+        assert Set.equal?(result, new_set([1, 2]))
       end
 
       test "difference/2 with match" do
         refute Set.member?(Set.difference(int_set, new_set([1])), 1)
         assert Set.member?(Set.difference(int_set, new_set([1.0])), 1)
       end
 
+      test "difference/2 with other set" do
+        result = Set.difference(new_set([1, 2, 3]), TestSet.new([3]))
+        assert Set.equal?(result, new_set([1, 2]))
+      end
+
       test "disjoint?/2" do
-        assert Set.disjoint?(new_set([1, 2, 3]), new_set([4, 5 ,6])) == true
-        assert Set.disjoint?(new_set([1, 2, 3]), new_set([3, 4 ,5])) == false
+        assert Set.disjoint?(new_set([1, 2, 3]), new_set([4, 5 ,6]))
+        refute Set.disjoint?(new_set([1, 2, 3]), new_set([3, 4 ,5]))
+      end
+
+      test "disjoint/2 with other set" do
+        assert Set.disjoint?(new_set([1, 2, 3]), TestSet.new([4, 5 ,6]))
+        refute Set.disjoint?(new_set([1, 2, 3]), TestSet.new([3, 4 ,5]))
       end
 
       test "empty/1" do
@@ -60,6 +89,11 @@ defmodule SetTest.Common do
         refute Set.equal?(new_set([1, 2, 3]), new_set([3.0, 2.0, 1.0]))
       end
 
+      test "equal?/2 with other set" do
+        assert Set.equal?(new_set([1, 2, 3]), TestSet.new([3, 2, 1]))
+        refute Set.equal?(new_set([1, 2, 3]), TestSet.new([3.0, 2.0, 1.0]))
+      end
+
       test "intersection/2" do
         result = Set.intersection(new_set([1, 2, 3]), new_set([2, 3, 4]))
         assert Set.equal?(result, new_set([2, 3]))
@@ -70,6 +104,11 @@ defmodule SetTest.Common do
         refute Set.member?(Set.intersection(int_set, new_set([1.0])), 1)
       end
 
+      test "intersection/2 with other set" do
+        result = Set.intersection(new_set([1, 2, 3]), TestSet.new([2, 3, 4]))
+        assert Set.equal?(result, new_set([2, 3]))
+      end
+
       test "member?/2" do
         assert Set.member?(new_set([1, 2, 3]), 2)
         refute Set.member?(new_set([1, 2, 3]), 4)
@@ -100,6 +139,11 @@ defmodule SetTest.Common do
         refute Set.subset?(new_set([1.0]), int_set)
       end
 
+      test "subset?/2 with other set" do
+        assert Set.subset?(new_set([1, 2]), TestSet.new([1, 2, 3]))
+        refute Set.subset?(new_set([1, 2, 3]), TestSet.new([1, 2]))
+      end
+
       test "to_list/1" do
         assert Set.to_list(new_set([1, 2, 3])) |> Enum.sort == [1, 2, 3]
       end
@@ -114,6 +158,11 @@ defmodule SetTest.Common do
         assert Set.size(Set.union(int_set, new_set([1.0]))) == 4
       end
 
+      test "union/2 with other set" do
+        result = Set.union(new_set([1, 2, 3]), TestSet.new([2, 3, 4]))
+        assert Set.equal?(result, new_set([1, 2, 3, 4]))
+      end
+
       test "implements Enum" do
         assert Enum.member?(int_set, 1)
         refute Enum.member?(int_set, 1.0)