       test "supports match patterns", %{registry: registry} do
         value = {1, :atom, 1}
         {:ok, _} = Registry.register(registry, "hello", value)
-        assert Registry.match(registry, "hello", {1, :_, :_}) ==
-               [{self(), value}]
-        assert Registry.match(registry, "hello", {1.0, :_, :_}) ==
-               []
-        assert Registry.match(registry, "hello", {:_, :atom, :_}) ==
-               [{self(), value}]
-        assert Registry.match(registry, "hello", {:"$1", :_, :"$1"}) ==
-               [{self(), value}]
-        assert Registry.match(registry, "hello", :_) ==
-               [{self(), value}]
-        assert Registry.match(registry, :_, :_) ==
-               []
+        assert Registry.match(registry, "hello", {1, :_, :_}) == [{self(), value}]
+        assert Registry.match(registry, "hello", {1.0, :_, :_}) == []
+        assert Registry.match(registry, "hello", {:_, :atom, :_}) == [{self(), value}]
+        assert Registry.match(registry, "hello", {:"$1", :_, :"$1"}) == [{self(), value}]
+        assert Registry.match(registry, "hello", :_) == [{self(), value}]
+        assert Registry.match(registry, :_, :_) == []
 
         value2 = %{a: "a", b: "b"}
         {:ok, _} = Registry.register(registry, "world", value2)
-        assert Registry.match(registry, "world", %{b: "b"}) ==
-               [{self(), value2}]
+        assert Registry.match(registry, "world", %{b: "b"}) == [{self(), value2}]
       end
 
       test "supports guard conditions", %{registry: registry} do
         value = {1, :atom, 2}
         {:ok, _} = Registry.register(registry, "hello", value)
+
         assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 1}]) ==
-               [{self(), value}]
-        assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 2}]) ==
-               []
-        assert Registry.match(registry, "hello", {:_, :"$1", :_,}, [{:is_atom, :"$1"}]) ==
-               [{self(), value}]
+                 [{self(), value}]
+
+        assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 2}]) == []
+
+        assert Registry.match(registry, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}]) ==
+                 [{self(), value}]
       end
 
       test "unregister_match supports patterns", %{registry: registry} do


      test "has unique registrations even if partition is delayed", %{registry: registry} do
        {owner, task} = register_task(registry, "hello", :value)
        assert Registry.register(registry, "hello", :other) ==
               {:error, {:already_registered, task}}

        :sys.suspend(owner)
        kill_and_assert_down(task)

        {:ok, _} = Registry.register(registry, "hello", "b")

        Registry.unregister_match(registry, :_, :foo)
        assert Registry.lookup(registry, :_) == []

        assert Registry.keys(registry, self()) |> Enum.sort() == ["hello"]
      end

      test "compares using ===", %{registry: registry} do
