Properly normalize ExUnit filters, closes #7390

Author: José Valim

lib/ex_unit/lib/ex_unit/filters.ex

@@ -37,12 +37,36 @@ defmodule ExUnit.Filters do
       iex> ExUnit.Filters.normalize([:foo, :bar, :bar], [:foo, :baz])
       {[:foo, :bar], [:baz]}
 
+      iex> ExUnit.Filters.normalize([foo: "true"], [:foo])
+      {[foo: "true"], [:foo]}
+
+      iex> ExUnit.Filters.normalize([:foo], [foo: "true"])
+      {[:foo], []}
+
+      iex> ExUnit.Filters.normalize([foo: "true"], [foo: true])
+      {[foo: "true"], []}
+
+      iex> ExUnit.Filters.normalize([foo: true], [foo: "true"])
+      {[foo: true], []}
+
   """
   @spec normalize(t | nil, t | nil) :: {t, t}
   def normalize(include, exclude) do
-    include = include |> List.wrap() |> Enum.uniq()
-    exclude = exclude |> List.wrap() |> Enum.uniq() |> Kernel.--(include)
-    {include, exclude}
+    {include_atoms, include_tags} =
+      include |> List.wrap() |> Enum.uniq() |> Enum.split_with(&is_atom/1)
+
+    {exclude_atoms, exclude_tags} =
+      exclude |> List.wrap() |> Enum.uniq() |> Enum.split_with(&is_atom/1)
+
+    exclude_tags = Map.new(exclude_tags)
+
+    exclude_included =
+      for include_tag <- include_tags, key = has_tag(include_tag, exclude_tags), do: key
+
+    exclude_tags =
+      exclude_tags |> Map.drop(include_atoms) |> Map.drop(exclude_included) |> Map.to_list()
+
+    {include_atoms ++ include_tags, (exclude_atoms -- include_atoms) ++ exclude_tags}
   end
 
   @doc """
@@ -121,22 +145,26 @@ defmodule ExUnit.Filters do
     end
   end
 
-  defp has_tag({key, %Regex{} = value}, tags, _collection) when is_atom(key) do
+  defp has_tag(pair, tags, _collection) do
+    has_tag(pair, tags)
+  end
+
+  defp has_tag({key, %Regex{} = value}, tags) when is_atom(key) do
     case Map.fetch(tags, key) do
       {:ok, tag} -> to_string(tag) =~ value and key
       _ -> false
     end
   end
 
-  defp has_tag({key, value}, tags, _collection) when is_atom(key) do
+  defp has_tag({key, value}, tags) when is_atom(key) do
     case Map.fetch(tags, key) do
       {:ok, ^value} -> key
       {:ok, tag} -> compare(to_string(tag), to_string(value)) and key
       _ -> false
     end
   end
 
-  defp has_tag(key, tags, _collection) when is_atom(key), do: Map.has_key?(tags, key) and key
+  defp has_tag(key, tags) when is_atom(key), do: Map.has_key?(tags, key) and key
 
   defp to_integer(integer) when is_integer(integer), do: integer
   defp to_integer(integer) when is_binary(integer), do: String.to_integer(integer)