       assert message =~ "* :scheme"
     end
 
-    if :erlang.system_info(:otp_release) >= '21' do
-      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
+    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

             |> 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

          Exception.blame(:error, e, __STACKTRACE__) |> elem(0) |> Exception.message()
      end
    end
  end

  describe "blaming unit tests" do
    test "annotates clauses errors" do
      args = [%{}, :key, nil]

      {exception, stack} =
