              |> message == "no function clause matching in Foo.bar/1"
     end
 
-    test "FunctionClauseError with blame" do
-      {exception, _} =
-        Exception.blame(:error, :function_clause, [{Access, :fetch, [:foo, :bar], [line: 13]}])
-
-      assert message(exception) =~ """
-             no function clause matching in Access.fetch/2
-
-             The following arguments were given to Access.fetch/2:
-
-                 # 1
-                 :foo
-
-                 # 2
-                 :bar
-
-             Attempted function clauses (showing 5 out of 5):
-
-                 def fetch(-%module{} = container-, key)
-             """
-    end
-
-    test "FunctionClauseError with blame and more than 10 clauses" do
-      {exception, _} =
-        Exception.blame(:error, :function_clause, [
-          {Macro, :to_string, [:invalid, :invalid], []}
-        ])
-
-      assert message(exception) =~ """
-             no function clause matching in Macro.to_string/2
-
-             The following arguments were given to Macro.to_string/2:
-
-                 # 1
-                 :invalid
-
-                 # 2
-                 :invalid
-
-             Attempted function clauses (showing 10 out of 25):
-
-                 def to_string(-{var, _, context} = ast-, fun) when -is_atom(var)- and -is_atom(context)-
-                 def to_string(-{:__aliases__, _, refs} = ast-, fun)
-                 def to_string(-{:__block__, _, [expr]} = ast-, fun)
-                 def to_string(-{:__block__, _, _} = ast-, fun)
-                 def to_string(-{:<<>>, _, parts} = ast-, fun)
-                 def to_string(-{:{}, _, args} = ast-, fun)
-                 def to_string(-{:%{}, _, args} = ast-, fun)
-                 def to_string(-{:%, _, [struct_name, map]} = ast-, fun)
-                 def to_string(-{:fn, _, [{:->, _, [_, tuple]}] = arrow} = ast-, fun) when -not(is_tuple(tuple))- or -elem(tuple, 0) != :__block__-
-                 def to_string(-{:fn, _, [{:->, _, _}] = block} = ast-, fun)
-                 ...
-                 (15 clauses not shown)
-             """
-    end
-
     test "ErlangError" do
       assert %ErlangError{original: :sample} |> message == "Erlang error: :sample"
     end

      assert blame_message(123, &apply(Kernel, :+, &1)) ==
               "you attempted to apply :+ on module Kernel with arguments 123. " <>
                 "Arguments (the third argument of apply) must always be a list"
    end

    test "annotates undefined function error with suggestions" do

      assert message =~ "* :scheme"
    end

    test "annotates +/1 arithmetic errors" do
      assert blame_message(:foo, &(+&1)) == "bad argument in arithmetic expression: +(:foo)"
    end

    test "annotates -/1 arithmetic errors" do
      assert blame_message(:foo, &(-&1)) == "bad argument in arithmetic expression: -(:foo)"
    end

    test "annotates div arithmetic errors" do
      assert blame_message(0, &div(10, &1)) ==
               "bad argument in arithmetic expression: div(10, 0)"
    end

    test "annotates rem arithmetic errors" do
      assert blame_message(0, &rem(10, &1)) ==
               "bad argument in arithmetic expression: rem(10, 0)"
    end

    test "annotates band arithmetic errors" do
      use Bitwise

      assert blame_message(:foo, &band(&1, 10)) ==
               "bad argument in arithmetic expression: Bitwise.band(:foo, 10)"

      assert blame_message(:foo, &(&1 &&& 10)) ==
               "bad argument in arithmetic expression: Bitwise.band(:foo, 10)"
    end

    test "annotates bor arithmetic errors" do
      use Bitwise

      assert blame_message(:foo, &bor(&1, 10)) ==
               "bad argument in arithmetic expression: Bitwise.bor(:foo, 10)"

      assert blame_message(:foo, &(&1 ||| 10)) ==
               "bad argument in arithmetic expression: Bitwise.bor(:foo, 10)"
    end

    test "annotates bxor arithmetic errors" do
      use Bitwise

      assert blame_message(:foo, &bxor(&1, 10)) ==
               "bad argument in arithmetic expression: Bitwise.bxor(:foo, 10)"
    end

    test "annotates bsl arithmetic errors" do
      use Bitwise

      assert blame_message(:foo, &bsl(10, &1)) ==
               "bad argument in arithmetic expression: Bitwise.bsl(10, :foo)"

      assert blame_message(:foo, &(10 <<< &1)) ==
               "bad argument in arithmetic expression: Bitwise.bsl(10, :foo)"
    end

    test "annotates bsr arithmetic errors" do
      use Bitwise

      assert blame_message(:foo, &bsr(10, &1)) ==
               "bad argument in arithmetic expression: Bitwise.bsr(10, :foo)"

      assert blame_message(:foo, &(10 >>> &1)) ==
               "bad argument in arithmetic expression: Bitwise.bsr(10, :foo)"
    end

    test "annotates bnot arithmetic errors" do
      use Bitwise

      assert blame_message(:foo, &bnot(&1)) ==
               "bad argument in arithmetic expression: Bitwise.bnot(:foo)"

      assert blame_message(:foo, &(~~~&1)) ==
               "bad argument in arithmetic expression: Bitwise.bnot(:foo)"
    end

    defp blame_message(arg, fun) do
