 
   """
   def assert_in_delta(value1, value2, delta, message \\ nil)
+
   def assert_in_delta(_, _, delta, _) when delta < 0 do
     raise ArgumentError, "delta must always be a positive number, got: #{inspect(delta)}"
   end
+
   def assert_in_delta(value1, value2, delta, message) do
     diff = abs(value1 - value2)
-    message = message ||
-      "Expected the difference between #{inspect value1} and " <>
-      "#{inspect value2} (#{inspect diff}) to be less than #{inspect delta}"
+
+    message =
+      message ||
+        "Expected the difference between #{inspect(value1)} and " <>
+          "#{inspect(value2)} (#{inspect(diff)}) to be less than #{inspect(delta)}"
+
     assert diff < delta, message
   end
 


  @operator [:==, :<, :>, :<=, :>=, :===, :=~, :!==, :!=, :in]

  defp translate_assertion(:assert, {operator, meta, [_, _]} = expr, caller) when operator in @operator do
    left = Macro.var(:left, __MODULE__)
    right = Macro.var(:right, __MODULE__)
    call = {operator, meta, [left, right]}

    # is not nil nor false. We need to rewrite the if
    # to avoid silly warnings though.
    return =
      suppress_warning(
        quote do
          case right do
            x when x in [nil, false] ->
              raise ExUnit.AssertionError,
                expr: expr,
                message: "Expected truthy, got #{inspect(right)}"

            _ ->
              :ok
          end
        end
      )

    match_expr =
      suppress_warning(
        quote do
          case right do
            unquote(left) ->
              unquote(return)
              unquote(vars)

            _ ->
              raise ExUnit.AssertionError,
                right: right,
                expr: expr,
                message: "match (=) failed" <> ExUnit.Assertions.__pins__(unquote(pins))
          end
        end
      )

    quote do
      right = unquote(right)
