Show hint if comparing different but equivalent strings

Closes #11256.

Author: josevalim

lib/ex_unit/lib/ex_unit/diff.ex

@@ -33,10 +33,10 @@ defmodule ExUnit.Diff do
   end
 
   defp context_to_env({:match, pins}),
-    do: %{pins: Map.new(pins), context: :match, current_vars: %{}}
+    do: %{pins: Map.new(pins), context: :match, current_vars: %{}, hints: []}
 
   defp context_to_env(op) when op in [:==, :===],
-    do: %{pins: %{}, context: op, current_vars: %{}}
+    do: %{pins: %{}, context: op, current_vars: %{}, hints: []}
 
   # Main entry point for recursive diff
 
@@ -725,20 +725,27 @@ defmodule ExUnit.Diff do
     left = IO.iodata_to_binary(escaped_left)
     right = IO.iodata_to_binary(escaped_right)
 
-    diff =
-      cond do
-        diff_string?(left, right) ->
+    cond do
+      left == right ->
+        {string_script_to_diff([eq: left], delimiter, true, [], []), env}
+
+      diff_string?(left, right) ->
+        diff =
           String.myers_difference(left, right)
           |> string_script_to_diff(delimiter, true, [], [])
 
-        left == right ->
-          string_script_to_diff([eq: left], delimiter, true, [], [])
+        env =
+          if String.equivalent?(left, right) do
+            add_hint(env, :equivalent_but_different_strings)
+          else
+            env
+          end
 
-        true ->
-          string_script_to_diff([del: left, ins: right], delimiter, true, [], [])
-      end
+        {diff, env}
 
-    {diff, env}
+      true ->
+        {string_script_to_diff([del: left, ins: right], delimiter, true, [], []), env}
+    end
   end
 
   # Concat all the literals on `left` and split `right` based on the size of
@@ -1031,6 +1038,10 @@ defmodule ExUnit.Diff do
 
   # Diff helpers
 
+  defp add_hint(%{hints: hints} = env, hint) do
+    if hint in hints, do: env, else: %{env | hints: [hint | hints]}
+  end
+
   # The left side is only escaped if it is a value
   defp maybe_escape(other, %{context: :match}), do: other
   defp maybe_escape(other, _env), do: escape(other)

lib/ex_unit/lib/ex_unit/formatter.ex

@@ -388,7 +388,7 @@ defmodule ExUnit.Formatter do
        ) do
     formatted_mailbox =
       for message <- mailbox do
-        {pattern, value} =
+        {pattern, value, _warnings} =
           format_sides(
             left,
             message,
@@ -419,16 +419,16 @@ defmodule ExUnit.Formatter do
          padding_size,
          width
        ) do
-    {left, right} = format_sides(left, right, context, formatter, padding_size, width)
-    [left: left, right: right]
+    {left, right, extras} = format_sides(left, right, context, formatter, padding_size, width)
+    [left: left, right: right] ++ extras
   end
 
   defp format_sides(left, right, context, formatter, padding_size, width) do
     inspect = &inspect_multiline(&1, padding_size, width)
     content_width = if width == :infinity, do: width, else: width - padding_size
 
     case format_diff(left, right, context, formatter) do
-      {result, _env} ->
+      {result, env} ->
         left =
           result.left
           |> Diff.to_algebra(&colorize_diff_delete(&1, formatter))
@@ -441,16 +441,20 @@ defmodule ExUnit.Formatter do
           |> Algebra.nest(padding_size)
           |> Algebra.format(content_width)
 
-        {left, right}
+        {left, right, Enum.map(env.hints, &{:hint, format_hint(&1)})}
 
       nil when is_atom(context) ->
-        {if_value(left, inspect), if_value(right, inspect)}
+        {if_value(left, inspect), if_value(right, inspect), []}
 
       nil ->
-        {if_value(left, &code_multiline(&1, padding_size)), if_value(right, inspect)}
+        {if_value(left, &code_multiline(&1, padding_size)), if_value(right, inspect), []}
     end
   end
 
+  defp format_hint(:equivalent_but_different_strings) do
+    "you are comparing strings that have the same visual representation but are made of different Unicode codepoints"
+  end
+
   defp format_diff(left, right, context, formatter) do
     if has_value?(left) and has_value?(right) and formatter.(:diff_enabled?, false) do
       find_diff(left, right, context)

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -28,9 +28,10 @@ defmodule ExUnit.FormatterTest do
     false
   end
 
-  defp formatter(_kind, message) do
-    message
-  end
+  defp formatter(_key, value), do: value
+
+  defp diff_formatter(:diff_enabled?, _default), do: true
+  defp diff_formatter(_key, value), do: value
 
   test "formats test case filters" do
     filters = [run: true, slow: false]
@@ -274,6 +275,23 @@ defmodule ExUnit.FormatterTest do
            """
   end
 
+  nfc_hello = String.normalize("héllo", :nfc)
+  nfd_hello = String.normalize("héllo", :nfd)
+
+  test "formats assertions with hints" do
+    failure = [{:error, catch_assertion(assert unquote(nfc_hello) == unquote(nfd_hello)), []}]
+
+    assert format_test_failure(test(), failure, 1, 80, &diff_formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                Assertion with == failed
+                code:  assert "#{unquote(nfc_hello)}" == "#{unquote(nfd_hello)}"
+                left:  "#{unquote(nfc_hello)}"
+                right: "#{unquote(nfd_hello)}"
+                hint:  you are comparing strings that have the same visual representation but are made of different Unicode codepoints
+           """
+  end
+
   test "formats multiple assertions" do
     failure = [
       {:error, catch_assertion(assert ExUnit.FormatterTest.falsy()), []},