From 9924f3edcf7ac2fd59beecf5a2593fa0f75b86cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonatan=20M=C3=A4nnchen?= <jonatan@maennchen.ch>
Date: Tue, 1 Apr 2025 14:24:15 +0200
Subject: [PATCH 1/2] Use Test Modules in tests instead of Elixir built-in
 modules

Prep for Coverage Reporting in tests
---
 lib/elixir/scripts/path_helpers.exs           |  78 +++++++++++++
 lib/elixir/test/elixir/exception_test.exs     |  48 ++++++--
 lib/elixir/test/elixir/module_test.exs        |  16 ++-
 .../elixir/protocol/consolidation_test.exs    |  12 +-
 lib/elixir/test/elixir/test_helper.exs        |  75 +-----------
 lib/iex/test/iex/helpers_test.exs             |  91 ++++++++-------
 lib/iex/test/iex/interaction_test.exs         |  30 ++++-
 lib/iex/test/iex/pry_test.exs                 | 108 +++++++++---------
 lib/iex/test/test_helper.exs                  |  31 +++++
 9 files changed, 304 insertions(+), 185 deletions(-)
 create mode 100644 lib/elixir/scripts/path_helpers.exs

diff --git a/lib/elixir/scripts/path_helpers.exs b/lib/elixir/scripts/path_helpers.exs
new file mode 100644
index 0000000000..543fc448e1
--- /dev/null
+++ b/lib/elixir/scripts/path_helpers.exs
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Beam files compiled on demand
+path = Path.expand("../tmp/beams", __DIR__)
+File.rm_rf!(path)
+File.mkdir_p!(path)
+Code.prepend_path(path)
+
+defmodule PathHelpers do
+  def fixture_path() do
+    Path.expand("../test/elixir/fixtures", __DIR__)
+  end
+
+  def tmp_path() do
+    Path.expand("../tmp", __DIR__)
+  end
+
+  def fixture_path(extra) do
+    Path.join(fixture_path(), extra)
+  end
+
+  def tmp_path(extra) do
+    Path.join(tmp_path(), extra)
+  end
+
+  def elixir(args, executable_extension \\ "") do
+    run_cmd(elixir_executable(executable_extension), args)
+  end
+
+  def elixir_executable(extension \\ "") do
+    executable_path("elixir", extension)
+  end
+
+  def elixirc(args, executable_extension \\ "") do
+    run_cmd(elixirc_executable(executable_extension), args)
+  end
+
+  def elixirc_executable(extension \\ "") do
+    executable_path("elixirc", extension)
+  end
+
+  def iex(args, executable_extension \\ "") do
+    run_cmd(iex_executable(executable_extension), args)
+  end
+
+  def iex_executable(extension \\ "") do
+    executable_path("iex", extension)
+  end
+
+  def write_beam({:module, name, bin, _} = res) do
+    File.mkdir_p!(unquote(path))
+    beam_path = Path.join(unquote(path), Atom.to_string(name) <> ".beam")
+    File.write!(beam_path, bin)
+    res
+  end
+
+  defp run_cmd(executable, args) do
+    ~c"#{executable} #{IO.chardata_to_string(args)}#{redirect_std_err_on_win()}"
+    |> :os.cmd()
+    |> :unicode.characters_to_binary()
+  end
+
+  defp executable_path(name, extension) do
+    Path.expand("../../../bin/#{name}#{extension}", __DIR__)
+  end
+
+  if match?({:win32, _}, :os.type()) do
+    def windows?, do: true
+    def executable_extension, do: ".bat"
+    def redirect_std_err_on_win, do: " 2>&1"
+  else
+    def windows?, do: false
+    def executable_extension, do: ""
+    def redirect_std_err_on_win, do: ""
+  end
+end
diff --git a/lib/elixir/test/elixir/exception_test.exs b/lib/elixir/test/elixir/exception_test.exs
index 36d6377f0c..2f19f39515 100644
--- a/lib/elixir/test/elixir/exception_test.exs
+++ b/lib/elixir/test/elixir/exception_test.exs
@@ -556,20 +556,36 @@ defmodule ExceptionTest do
     end
 
     test "annotates function clause errors" do
-      assert blame_message(Access, & &1.fetch(:foo, :bar)) =~ """
-             no function clause matching in Access.fetch/2
+      import PathHelpers
+
+      write_beam(
+        defmodule ExampleModule do
+          def fun(arg1, arg2)
+          def fun(:one, :one), do: :ok
+          def fun(:two, :two), do: :ok
+        end
+      )
+
+      :code.purge(ExampleModule)
+      :code.delete(ExampleModule)
+
+      message = blame_message(ExceptionTest.ExampleModule, & &1.fun(:three, :four))
+
+      assert message =~ """
+             no function clause matching in ExceptionTest.ExampleModule.fun/2
 
-             The following arguments were given to Access.fetch/2:
+             The following arguments were given to ExceptionTest.ExampleModule.fun/2:
 
                  # 1
-                 :foo
+                 :three
 
                  # 2
-                 :bar
+                 :four
 
-             Attempted function clauses (showing 5 out of 5):
+             Attempted function clauses (showing 2 out of 2):
 
-                 def fetch(-%module{} = container-, key)
+                 def fun(-:one-, -:one-)
+                 def fun(-:two-, -:two-)
              """
     end
 
@@ -858,13 +874,25 @@ defmodule ExceptionTest do
 
   describe "blaming unit tests" do
     test "annotates clauses errors" do
-      args = [%{}, :key, nil]
+      import PathHelpers
+
+      write_beam(
+        defmodule ExampleModule do
+          def fun(arg), do: arg
+        end
+      )
+
+      :code.purge(ExampleModule)
+      :code.delete(ExampleModule)
+
+      args = [nil]
 
       {exception, stack} =
-        Exception.blame(:error, :function_clause, [{Keyword, :pop, args, [line: 13]}])
+        Exception.blame(:error, :function_clause, [{ExampleModule, :fun, args, [line: 13]}])
 
       assert %FunctionClauseError{kind: :def, args: ^args, clauses: [_]} = exception
-      assert stack == [{Keyword, :pop, 3, [line: 13]}]
+
+      assert stack == [{ExampleModule, :fun, 1, [line: 13]}]
     end
 
     test "annotates args and clauses from mfa" do
diff --git a/lib/elixir/test/elixir/module_test.exs b/lib/elixir/test/elixir/module_test.exs
index 8065ed2472..4784185692 100644
--- a/lib/elixir/test/elixir/module_test.exs
+++ b/lib/elixir/test/elixir/module_test.exs
@@ -432,9 +432,21 @@ defmodule ModuleTest do
   end
 
   test "compiles to core" do
-    {:ok, {Atom, [{~c"Dbgi", dbgi}]}} = Atom |> :code.which() |> :beam_lib.chunks([~c"Dbgi"])
+    import PathHelpers
+
+    write_beam(
+      defmodule ExampleModule do
+      end
+    )
+
+    :code.purge(ExampleModule)
+    :code.delete(ExampleModule)
+
+    {:ok, {ExampleModule, [{~c"Dbgi", dbgi}]}} =
+      ExampleModule |> :code.which() |> :beam_lib.chunks([~c"Dbgi"])
+
     {:debug_info_v1, backend, data} = :erlang.binary_to_term(dbgi)
-    {:ok, core} = backend.debug_info(:core_v1, Atom, data, [])
+    {:ok, core} = backend.debug_info(:core_v1, ExampleModule, data, [])
     assert is_tuple(core)
   end
 
diff --git a/lib/elixir/test/elixir/protocol/consolidation_test.exs b/lib/elixir/test/elixir/protocol/consolidation_test.exs
index 3b1a08e018..815e0c7a2d 100644
--- a/lib/elixir/test/elixir/protocol/consolidation_test.exs
+++ b/lib/elixir/test/elixir/protocol/consolidation_test.exs
@@ -247,11 +247,21 @@ defmodule Protocol.ConsolidationTest do
   end
 
   test "consolidation errors on missing BEAM files" do
+    import PathHelpers
+
+    write_beam(
+      defmodule ExampleModule do
+      end
+    )
+
+    :code.purge(ExampleModule)
+    :code.delete(ExampleModule)
+
     defprotocol NoBeam do
       def example(arg)
     end
 
-    assert Protocol.consolidate(String, []) == {:error, :not_a_protocol}
+    assert Protocol.consolidate(ExampleModule, []) == {:error, :not_a_protocol}
     assert Protocol.consolidate(NoBeam, []) == {:error, :no_beam_info}
   end
 
diff --git a/lib/elixir/test/elixir/test_helper.exs b/lib/elixir/test/elixir/test_helper.exs
index ebc35dc3b3..b02437a6a7 100644
--- a/lib/elixir/test/elixir/test_helper.exs
+++ b/lib/elixir/test/elixir/test_helper.exs
@@ -2,83 +2,10 @@
 # SPDX-FileCopyrightText: 2021 The Elixir Team
 # SPDX-FileCopyrightText: 2012 Plataformatec
 
-# Beam files compiled on demand
-path = Path.expand("../../tmp/beams", __DIR__)
-File.rm_rf!(path)
-File.mkdir_p!(path)
-Code.prepend_path(path)
-
 Application.put_env(:elixir, :ansi_enabled, true)
 Code.compiler_options(debug_info: true, infer_signatures: [:elixir])
 
-defmodule PathHelpers do
-  def fixture_path() do
-    Path.expand("fixtures", __DIR__)
-  end
-
-  def tmp_path() do
-    Path.expand("../../tmp", __DIR__)
-  end
-
-  def fixture_path(extra) do
-    Path.join(fixture_path(), extra)
-  end
-
-  def tmp_path(extra) do
-    Path.join(tmp_path(), extra)
-  end
-
-  def elixir(args, executable_extension \\ "") do
-    run_cmd(elixir_executable(executable_extension), args)
-  end
-
-  def elixir_executable(extension \\ "") do
-    executable_path("elixir", extension)
-  end
-
-  def elixirc(args, executable_extension \\ "") do
-    run_cmd(elixirc_executable(executable_extension), args)
-  end
-
-  def elixirc_executable(extension \\ "") do
-    executable_path("elixirc", extension)
-  end
-
-  def iex(args, executable_extension \\ "") do
-    run_cmd(iex_executable(executable_extension), args)
-  end
-
-  def iex_executable(extension \\ "") do
-    executable_path("iex", extension)
-  end
-
-  def write_beam({:module, name, bin, _} = res) do
-    File.mkdir_p!(unquote(path))
-    beam_path = Path.join(unquote(path), Atom.to_string(name) <> ".beam")
-    File.write!(beam_path, bin)
-    res
-  end
-
-  defp run_cmd(executable, args) do
-    ~c"#{executable} #{IO.chardata_to_string(args)}#{redirect_std_err_on_win()}"
-    |> :os.cmd()
-    |> :unicode.characters_to_binary()
-  end
-
-  defp executable_path(name, extension) do
-    Path.expand("../../../../bin/#{name}#{extension}", __DIR__)
-  end
-
-  if match?({:win32, _}, :os.type()) do
-    def windows?, do: true
-    def executable_extension, do: ".bat"
-    def redirect_std_err_on_win, do: " 2>&1"
-  else
-    def windows?, do: false
-    def executable_extension, do: ""
-    def redirect_std_err_on_win, do: ""
-  end
-end
+Code.eval_file("../../scripts/path_helpers.exs", __DIR__)
 
 defmodule CodeFormatterHelpers do
   defmacro assert_same(good, opts \\ []) do
diff --git a/lib/iex/test/iex/helpers_test.exs b/lib/iex/test/iex/helpers_test.exs
index 45f4eea29c..11a76f13fc 100644
--- a/lib/iex/test/iex/helpers_test.exs
+++ b/lib/iex/test/iex/helpers_test.exs
@@ -39,45 +39,45 @@ defmodule IEx.HelpersTest do
     end
 
     test "sets up a breakpoint with capture syntax" do
-      assert break!(URI.decode_query() / 2) == 1
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 1}]
+      assert break!(PryExampleModule.two() / 2) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
     end
 
     test "sets up a breakpoint with call syntax" do
-      assert break!(URI.decode_query(_, %{})) == 1
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 1}]
+      assert break!(PryExampleModule.two(_, %{})) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
     end
 
     test "sets up a breakpoint with guards syntax" do
-      assert break!(URI.decode_query(_, map) when is_map(map)) == 1
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 1}]
+      assert break!(PryExampleModule.two(_, map) when is_map(map)) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
     end
 
     test "sets up a breakpoint on the given module" do
-      assert break!(URI, :decode_query, 2) == 1
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 1}]
+      assert break!(PryExampleModule, :two, 2) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
     end
 
     test "resets breaks on the given ID" do
-      assert break!(URI, :decode_query, 2) == 1
+      assert break!(PryExampleModule, :two, 2) == 1
       assert reset_break(1) == :ok
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 0}]
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
     end
 
     test "resets breaks on the given module" do
-      assert break!(URI, :decode_query, 2) == 1
-      assert reset_break(URI, :decode_query, 2) == :ok
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 0}]
+      assert break!(PryExampleModule, :two, 2) == 1
+      assert reset_break(PryExampleModule, :two, 2) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
     end
 
     test "removes breaks in the given module" do
-      assert break!(URI.decode_query() / 2) == 1
-      assert remove_breaks(URI) == :ok
+      assert break!(PryExampleModule.two() / 2) == 1
+      assert remove_breaks(PryExampleModule) == :ok
       assert IEx.Pry.breaks() == []
     end
 
     test "removes breaks on all modules" do
-      assert break!(URI.decode_query() / 2) == 1
+      assert break!(PryExampleModule.two() / 2) == 1
       assert remove_breaks() == :ok
       assert IEx.Pry.breaks() == []
     end
@@ -85,7 +85,7 @@ defmodule IEx.HelpersTest do
     test "errors when setting up a breakpoint with invalid guard" do
       assert capture_io(:stderr, fn ->
                assert_raise CompileError, fn ->
-                 break!(URI.decode_query(_, map) when is_whatever(map))
+                 break!(PryExampleModule.two(_, map) when is_whatever(map))
                end
              end) =~ "cannot find or invoke local is_whatever/1"
     end
@@ -98,44 +98,44 @@ defmodule IEx.HelpersTest do
 
     test "errors when setting up a break for unknown function" do
       assert_raise RuntimeError,
-                   "could not set breakpoint, unknown function/macro URI.unknown/2",
-                   fn -> break!(URI, :unknown, 2) end
+                   "could not set breakpoint, unknown function/macro #{inspect(PryExampleModule)}.unknown/2",
+                   fn -> break!(PryExampleModule, :unknown, 2) end
     end
 
     test "errors for non-Elixir modules" do
       assert_raise RuntimeError,
-                   "could not set breakpoint, module :elixir was not written in Elixir",
-                   fn -> break!(:elixir, :unknown, 2) end
+                   "could not set breakpoint, module :maps was not written in Elixir",
+                   fn -> break!(:maps, :unknown, 2) end
     end
 
     test "prints table with breaks" do
-      break!(URI, :decode_query, 2)
+      break!(PryExampleModule, :two, 2)
 
       assert capture_io(fn -> breaks() end) == """
 
-              ID   Module.function/arity   Pending stops
-             ---- ----------------------- ---------------
-              1    URI.decode_query/2      1
+              ID   Module.function/arity    Pending stops
+             ---- ------------------------ ---------------
+              1    PryExampleModule.two/2   1
 
              """
 
-      assert capture_io(fn -> URI.decode_query("foo=bar", %{}) end) != ""
+      assert capture_io(fn -> PryExampleModule.two("foo=bar", %{}) end) != ""
 
       assert capture_io(fn -> breaks() end) == """
 
-              ID   Module.function/arity   Pending stops
-             ---- ----------------------- ---------------
-              1    URI.decode_query/2      0
+              ID   Module.function/arity    Pending stops
+             ---- ------------------------ ---------------
+              1    PryExampleModule.two/2   0
 
              """
 
-      assert capture_io(fn -> URI.decode_query("foo=bar", %{}) end) == ""
+      assert capture_io(fn -> PryExampleModule.two("foo=bar", %{}) end) == ""
 
       assert capture_io(fn -> breaks() end) == """
 
-              ID   Module.function/arity   Pending stops
-             ---- ----------------------- ---------------
-              1    URI.decode_query/2      0
+              ID   Module.function/arity    Pending stops
+             ---- ------------------------ ---------------
+              1    PryExampleModule.two/2   0
 
              """
     end
@@ -152,6 +152,7 @@ defmodule IEx.HelpersTest do
     @lists_erl Application.app_dir(:stdlib, "src/lists.erl")
     @httpc_erl "src/http_client/httpc.erl"
     @editor System.get_env("ELIXIR_EDITOR")
+    @example_module_path "lib/iex/test/test_helper.exs"
 
     test "opens __FILE__ and __LINE__" do
       System.put_env("ELIXIR_EDITOR", "echo __LINE__:__FILE__")
@@ -163,7 +164,8 @@ defmodule IEx.HelpersTest do
     end
 
     test "opens Elixir module" do
-      assert capture_iex("open(IEx.Helpers)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:5$/
+      assert capture_iex("open(HelperExampleModule)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
     end
 
     test "opens function" do
@@ -176,16 +178,19 @@ defmodule IEx.HelpersTest do
     end
 
     test "opens module.function" do
-      assert capture_iex("open(IEx.Helpers.b)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
-      assert capture_iex("open(IEx.Helpers.h)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
+      assert capture_iex("open(HelperExampleModule.fun)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
+
+      assert capture_iex("open(HelperExampleModule.macro)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
     end
 
     test "opens module.function/arity" do
-      assert capture_iex("open(IEx.Helpers.b/1)") |> maybe_trim_quotes() =~
-               ~r/#{@iex_helpers}:\d+$/
+      assert capture_iex("open(HelperExampleModule.fun/1)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
 
-      assert capture_iex("open(IEx.Helpers.h/0)") |> maybe_trim_quotes() =~
-               ~r/#{@iex_helpers}:\d+$/
+      assert capture_iex("open(HelperExampleModule.macro/1)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
     end
 
     test "opens Erlang module" do
@@ -1440,11 +1445,13 @@ defmodule IEx.HelpersTest do
     @tag :capture_log
     test "loads a given module on the given nodes" do
       assert nl([node()], :lists) == {:ok, [{:nonode@nohost, :error, :sticky_directory}]}
-      assert nl([node()], Enum) == {:ok, [{:nonode@nohost, :loaded, Enum}]}
+
+      assert nl([node()], HelperExampleModule) ==
+               {:ok, [{:nonode@nohost, :loaded, HelperExampleModule}]}
 
       assert nl(:nonexistent_module) == {:error, :nofile}
 
-      assert nl([:nosuchnode@badhost], Enum) ==
+      assert nl([:nosuchnode@badhost], HelperExampleModule) ==
                {:ok, [{:nosuchnode@badhost, :badrpc, :noconnection}]}
     end
   end
diff --git a/lib/iex/test/iex/interaction_test.exs b/lib/iex/test/iex/interaction_test.exs
index 540884366d..fe1872ecf3 100644
--- a/lib/iex/test/iex/interaction_test.exs
+++ b/lib/iex/test/iex/interaction_test.exs
@@ -232,11 +232,33 @@ defmodule IEx.InteractionTest do
   end
 
   test "blames function clause error" do
+    import PathHelpers
+
+    write_beam(
+      defmodule ExampleModule do
+        def fun(:valid), do: :ok
+      end
+    )
+
+    :code.purge(ExampleModule)
+    :code.delete(ExampleModule)
+
+    content = capture_iex("IEx.InteractionTest.ExampleModule.fun(:invalid)")
+
+    assert content =~
+             "** (FunctionClauseError) no function clause matching in IEx.InteractionTest.ExampleModule.fun/1"
+
+    assert content =~
+             "The following arguments were given to IEx.InteractionTest.ExampleModule.fun/1"
+
+    assert content =~ ":invalid"
+    assert content =~ "def fun(-:valid-)"
+
+    assert content =~
+             ~r"test/iex/interaction_test.exs:\d+: IEx\.InteractionTest\.ExampleModule\.fun/1"
+
     content = capture_iex("Access.fetch(:foo, :bar)")
-    assert content =~ "** (FunctionClauseError) no function clause matching in Access.fetch/2"
-    assert content =~ "The following arguments were given to Access.fetch/2"
-    assert content =~ ":foo"
-    assert content =~ "def fetch(-%module{} = container-, key)"
+
     assert content =~ ~r"\(elixir #{System.version()}\) lib/access\.ex:\d+: Access\.fetch/2"
   end
 
diff --git a/lib/iex/test/iex/pry_test.exs b/lib/iex/test/iex/pry_test.exs
index ea8125db37..d1038da568 100644
--- a/lib/iex/test/iex/pry_test.exs
+++ b/lib/iex/test/iex/pry_test.exs
@@ -47,39 +47,39 @@ defmodule IEx.PryTest do
 
   describe "break" do
     test "sets up a breakpoint on the given module" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert instrumented?(URI)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert instrumented?(PryExampleModule)
       assert [_] = IEx.Pry.breaks()
     end
 
     test "sets up multiple breakpoints in the same module" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert instrumented?(URI)
-      assert IEx.Pry.break(URI, :parse, 1) == {:ok, 2}
-      assert instrumented?(URI)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert instrumented?(PryExampleModule)
+      assert IEx.Pry.break(PryExampleModule, :one, 1) == {:ok, 2}
+      assert instrumented?(PryExampleModule)
       assert [_, _] = IEx.Pry.breaks()
     end
 
     test "reinstruments if module has been reloaded" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert instrumented?(URI)
-      deinstrument!(URI)
-      refute instrumented?(URI)
-      assert IEx.Pry.break(URI, :parse, 1) == {:ok, 2}
-      assert instrumented?(URI)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert instrumented?(PryExampleModule)
+      deinstrument!(PryExampleModule)
+      refute instrumented?(PryExampleModule)
+      assert IEx.Pry.break(PryExampleModule, :one, 1) == {:ok, 2}
+      assert instrumented?(PryExampleModule)
       assert [_, _] = IEx.Pry.breaks()
     end
 
     test "returns ID when breakpoint is already set" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
       assert [_] = IEx.Pry.breaks()
     end
 
     test "returns ID even when breakpoint is already set on deinstrument" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      deinstrument!(URI)
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
       assert [_] = IEx.Pry.breaks()
     end
 
@@ -88,67 +88,71 @@ defmodule IEx.PryTest do
     end
 
     test "errors when setting up a break for unknown function" do
-      assert IEx.Pry.break(URI, :unknown, 2) == {:error, :unknown_function_arity}
+      assert IEx.Pry.break(PryExampleModule, :unknown, 2) == {:error, :unknown_function_arity}
     end
 
     test "errors for non-Elixir modules" do
-      assert IEx.Pry.break(:elixir, :unknown, 2) == {:error, :non_elixir_module}
+      assert IEx.Pry.break(:maps, :unknown, 2) == {:error, :non_elixir_module}
     end
   end
 
   describe "breaks" do
     test "returns all breaks" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 1}]
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
 
-      assert IEx.Pry.break(URI, :decode_query, 2, 10) == {:ok, 1}
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 10}]
+      assert IEx.Pry.break(PryExampleModule, :two, 2, 10) == {:ok, 1}
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 10}]
 
-      assert IEx.Pry.break(URI, :parse, 1, 1) == {:ok, 2}
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 10}, {2, URI, {:parse, 1}, 1}]
+      assert IEx.Pry.break(PryExampleModule, :one, 1, 1) == {:ok, 2}
+
+      assert IEx.Pry.breaks() == [
+               {1, PryExampleModule, {:two, 2}, 10},
+               {2, PryExampleModule, {:one, 1}, 1}
+             ]
     end
 
     test "sets negative break to 0" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      :ets.insert(IEx.Pry, {1, URI, {:decode_query, 2}, {[], true}, -1})
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 0}]
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      :ets.insert(IEx.Pry, {1, PryExampleModule, {:two, 2}, {[], true}, -1})
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
     end
 
     test "do not return break points for deinstrumented modules" do
-      assert IEx.Pry.break(URI, :parse, 1) == {:ok, 1}
-      assert IEx.Pry.breaks() == [{1, URI, {:parse, 1}, 1}]
-      deinstrument!(URI)
+      assert IEx.Pry.break(PryExampleModule, :one, 1) == {:ok, 1}
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:one, 1}, 1}]
+      deinstrument!(PryExampleModule)
       assert IEx.Pry.breaks() == []
     end
   end
 
   describe "reset_break" do
     test "resets break for given ID" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
       assert IEx.Pry.reset_break(1) == :ok
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 0}]
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
     end
 
     test "resets break for given mfa" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert IEx.Pry.reset_break(URI, :decode_query, 2) == :ok
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 0}]
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.reset_break(PryExampleModule, :two, 2) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
     end
 
     test "returns not_found if module is deinstrumented" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      deinstrument!(URI)
-      assert IEx.Pry.reset_break(URI, :decode_query, 2) == :not_found
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.reset_break(PryExampleModule, :two, 2) == :not_found
       assert IEx.Pry.breaks() == []
     end
 
     test "returns not_found if mfa has no break" do
-      assert IEx.Pry.reset_break(URI, :decode_query, 2) == :not_found
+      assert IEx.Pry.reset_break(PryExampleModule, :two, 2) == :not_found
     end
 
     test "returns not_found if ID is deinstrumented" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      deinstrument!(URI)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
       assert IEx.Pry.reset_break(1) == :not_found
       assert IEx.Pry.breaks() == []
     end
@@ -160,29 +164,29 @@ defmodule IEx.PryTest do
 
   describe "remove_breaks" do
     test "removes all breaks" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
       assert IEx.Pry.remove_breaks() == :ok
       assert IEx.Pry.breaks() == []
     end
 
     test "removes all breaks even if module is deinstrumented" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      deinstrument!(URI)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
       assert IEx.Pry.remove_breaks() == :ok
       assert IEx.Pry.breaks() == []
     end
 
     test "remove breaks in a given module" do
-      assert IEx.Pry.remove_breaks(Date.Range) == :ok
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      assert IEx.Pry.break(Date.Range, :__struct__, 1) == {:ok, 2}
-      assert IEx.Pry.remove_breaks(Date.Range) == :ok
-      assert IEx.Pry.breaks() == [{1, URI, {:decode_query, 2}, 1}]
+      assert IEx.Pry.remove_breaks(PryExampleStruct) == :ok
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleStruct, :__struct__, 1) == {:ok, 2}
+      assert IEx.Pry.remove_breaks(PryExampleStruct) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
     end
 
     test "remove breaks in a given module even if deinstrumented" do
-      assert IEx.Pry.break(URI, :decode_query, 2) == {:ok, 1}
-      deinstrument!(URI)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
       assert IEx.Pry.breaks() == []
     end
   end
diff --git a/lib/iex/test/test_helper.exs b/lib/iex/test/test_helper.exs
index 80859e417c..f59c642e93 100644
--- a/lib/iex/test/test_helper.exs
+++ b/lib/iex/test/test_helper.exs
@@ -2,6 +2,8 @@
 # SPDX-FileCopyrightText: 2021 The Elixir Team
 # SPDX-FileCopyrightText: 2012 Plataformatec
 
+Code.eval_file("../../elixir/scripts/path_helpers.exs", __DIR__)
+
 assert_timeout = String.to_integer(System.get_env("ELIXIR_ASSERT_TIMEOUT") || "500")
 System.put_env("ELIXIR_EDITOR", "echo")
 
@@ -103,3 +105,32 @@ defmodule IEx.Case do
     |> String.trim()
   end
 end
+
+PathHelpers.write_beam(
+  defmodule HelperExampleModule do
+    def fun(_arg), do: :ok
+    defmacro macro(_arg), do: :ok
+  end
+)
+
+:code.purge(HelperExampleModule)
+:code.delete(HelperExampleModule)
+
+PathHelpers.write_beam(
+  defmodule PryExampleModule do
+    def one(_arg), do: :ok
+    def two(_arg1, _arg2), do: :ok
+  end
+)
+
+:code.purge(PryExampleModule)
+:code.delete(PryExampleModule)
+
+PathHelpers.write_beam(
+  defmodule PryExampleStruct do
+    defstruct one: nil
+  end
+)
+
+:code.purge(PryExampleStruct)
+:code.delete(PryExampleStruct)

From e190fad14acf0c1d38e8f0379f35536b97169818 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonatan=20M=C3=A4nnchen?= <jonatan@maennchen.ch>
Date: Tue, 18 Mar 2025 14:49:52 +0000
Subject: [PATCH 2/2] Implement Test Coverage Reporting

---
 .github/workflows/ci.yml                      | 16 ++++++-
 .gitignore                                    |  1 +
 Makefile                                      | 22 ++++++++++
 lib/eex/test/test_helper.exs                  |  2 +
 lib/elixir/scripts/cover.exs                  | 42 +++++++++++++++++++
 lib/elixir/scripts/cover_record.exs           | 31 ++++++++++++++
 lib/elixir/test/elixir/exception_test.exs     |  1 +
 .../test/elixir/kernel/dialyzer_test.exs      |  1 +
 .../elixir/module/types/integration_test.exs  |  2 +
 lib/elixir/test/elixir/test_helper.exs        | 13 +++++-
 lib/ex_unit/lib/ex_unit/diff.ex               |  1 +
 lib/ex_unit/test/ex_unit/formatter_test.exs   | 37 +++++++++++-----
 lib/ex_unit/test/test_helper.exs              |  2 +
 lib/iex/test/iex/helpers_test.exs             |  5 +++
 lib/iex/test/test_helper.exs                  | 11 ++++-
 lib/logger/test/test_helper.exs               |  2 +
 lib/mix/lib/mix/tasks/test.coverage.ex        |  3 +-
 lib/mix/test/test_helper.exs                  |  2 +
 18 files changed, 180 insertions(+), 14 deletions(-)
 create mode 100755 lib/elixir/scripts/cover.exs
 create mode 100644 lib/elixir/scripts/cover_record.exs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index be10cf55de..7e21bd11aa 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,13 +21,16 @@ permissions:
 
 jobs:
   test_linux:
-    name: Ubuntu 24.04, Erlang/OTP ${{ matrix.otp_version }}${{ matrix.deterministic && ' (deterministic)' || '' }}
+    name: Ubuntu 24.04, Erlang/OTP ${{ matrix.otp_version }}${{ matrix.deterministic && ' (deterministic)' || '' }}${{ matrix.coverage && ' (coverage)' || '' }}
     strategy:
       fail-fast: false
       matrix:
         include:
           - otp_version: "27.1"
             deterministic: true
+          - otp_version: "27.1"
+            erlc_opts: "warnings_as_errors"
+            coverage: true
           - otp_version: "27.1"
             otp_latest: true
             erlc_opts: "warnings_as_errors"
@@ -65,9 +68,14 @@ jobs:
       - name: Erlang test suite
         run: make test_erlang
         continue-on-error: ${{ matrix.development }}
+        if: "${{ !matrix.coverage }}"
       - name: Elixir test suite
         run: make test_elixir
         continue-on-error: ${{ matrix.development }}
+        if: "${{ !matrix.coverage }}"
+      - name: "Calculate Coverage"
+        run: make cover
+        if: "${{ matrix.coverage }}"
       - name: Build docs (ExDoc main)
         if: ${{ matrix.otp_latest }}
         run: |
@@ -85,6 +93,12 @@ jobs:
           # Recompile System without .git
           cd lib/elixir && ../../bin/elixirc -o ebin lib/system.ex && cd -
           taskset 1 make check_reproducible
+      - name: "Upload Coverage Artifact"
+        if: "${{ matrix.coverage }}"
+        uses: actions/upload-artifact@4cec3d8aa04e39d1a68397de0c4cd6fb9dce8ec1 # v4.6.1
+        with:
+          name: TestCoverage
+          path: cover/*
 
   test_windows:
     name: Windows Server 2019, Erlang/OTP ${{ matrix.otp_version }}
diff --git a/.gitignore b/.gitignore
index 4b40c1790b..5173250d4d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,4 @@
 /.eunit
 .elixir.plt
 erl_crash.dump
+/cover/
diff --git a/Makefile b/Makefile
index f1829b9604..91a8d0469b 100644
--- a/Makefile
+++ b/Makefile
@@ -25,6 +25,7 @@ GIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))
 GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$head 2> /dev/null | grep -v latest | tail -1))
 SOURCE_DATE_EPOCH_PATH = lib/elixir/tmp/ebin_reproducible
 SOURCE_DATE_EPOCH_FILE = $(SOURCE_DATE_EPOCH_PATH)/SOURCE_DATE_EPOCH
+ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
 
 .PHONY: install install_man build_plt clean_plt dialyze test check_reproducible clean clean_elixir clean_man format docs Docs.zip Precompiled.zip zips
 .NOTPARALLEL:
@@ -53,6 +54,11 @@ lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1
 test_$(1): test_formatted $(1)
 	@ echo "==> $(1) (ex_unit)"
 	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/$(TEST_FILES)";
+
+cover/ex_unit_$(1).coverdata:
+	$(Q) mkdir -p "$(ROOT_DIR)/cover"
+	$(Q) COVER_FILE="$(ROOT_DIR)/cover/ex_unit_$(1).coverdata" $(MAKE) test_$(1)
+cover/combined.coverdata: cover/ex_unit_$(1).coverdata
 endef
 
 define WRITE_SOURCE_DATE_EPOCH
@@ -175,6 +181,7 @@ clean: clean_man
 	rm -rf lib/mix/test/fixtures/git_sparse_repo/
 	rm -rf lib/mix/test/fixtures/archive/ebin/
 	rm -f erl_crash.dump
+	rm -rf cover
 
 clean_elixir:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
@@ -287,6 +294,21 @@ test_stdlib: compile
 		cd lib/elixir && ../../bin/elixir --sname primary -r "test/elixir/test_helper.exs" -pr "test/elixir/**/$(TEST_FILES)"; \
 	fi
 
+cover/ex_unit_stdlib.coverdata:
+	$(Q) mkdir -p "$(ROOT_DIR)/cover"
+	$(Q) COVER_FILE="$(ROOT_DIR)/cover/ex_unit_stdlib.coverdata" $(MAKE) test_stdlib
+cover/combined.coverdata: cover/ex_unit_stdlib.coverdata
+
+cover/combined.coverdata:
+	$(Q) if [ -z "$(GITHUB_STEP_SUMMARY)" ]; then\
+		bin/elixir ./lib/elixir/scripts/cover.exs;\
+	else\
+		bin/elixir ./lib/elixir/scripts/cover.exs | tee "$(GITHUB_STEP_SUMMARY)";\
+	fi
+
+.PHONY: cover
+cover: cover/combined.coverdata
+
 #==> Dialyzer tasks
 
 DIALYZER_OPTS = --no_check_plt --fullpath -Werror_handling -Wunmatched_returns -Wunderspecs
diff --git a/lib/eex/test/test_helper.exs b/lib/eex/test/test_helper.exs
index 4956567b9e..34e95fecd3 100644
--- a/lib/eex/test/test_helper.exs
+++ b/lib/eex/test/test_helper.exs
@@ -5,6 +5,8 @@
 {line_exclude, line_include} =
   if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
 
+Code.eval_file("../../elixir/scripts/cover_record.exs", __DIR__)
+
 ExUnit.start(
   trace: !!System.get_env("TRACE"),
   include: line_include,
diff --git a/lib/elixir/scripts/cover.exs b/lib/elixir/scripts/cover.exs
new file mode 100755
index 0000000000..5e323c3218
--- /dev/null
+++ b/lib/elixir/scripts/cover.exs
@@ -0,0 +1,42 @@
+#!bin/elixir
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+root_dir = __ENV__.file |> Path.dirname() |> Path.join("../../..")
+cover_dir = Path.join(root_dir, "cover")
+coverdata_inputs = cover_dir |> Path.join("ex_unit_*.coverdata") |> Path.wildcard()
+coverdata_output = Path.join(cover_dir, "combined.coverdata")
+ebins = root_dir |> Path.join("lib/*/ebin") |> Path.wildcard()
+
+_ = :cover.stop()
+{:ok, cover_pid} = :cover.start()
+
+for ebin <- ebins,
+    result <- :cover.compile_beam_directory(String.to_charlist(ebin)) do
+  case result do
+    {:ok, _module} ->
+      :ok
+
+    {:error, reason} ->
+      raise "Failed to cover compile directory #{ebin} with reason: #{inspect(reason)}"
+  end
+end
+
+for file <- coverdata_inputs do
+  :ok = :cover.import(String.to_charlist(file))
+end
+
+:ok = :cover.export(String.to_charlist(coverdata_output))
+
+{:ok, _} = Application.ensure_all_started(:mix)
+
+# Silence analyse import messages emitted by cover
+{:ok, string_io} = StringIO.open("")
+Process.group_leader(cover_pid, string_io)
+
+:ok =
+  Mix.Tasks.Test.Coverage.generate_cover_results(
+    output: cover_dir,
+    summary: [threshold: 0]
+  )
diff --git a/lib/elixir/scripts/cover_record.exs b/lib/elixir/scripts/cover_record.exs
new file mode 100644
index 0000000000..122cfa88a0
--- /dev/null
+++ b/lib/elixir/scripts/cover_record.exs
@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+root_dir = __ENV__.file |> Path.dirname() |> Path.join("../../..")
+ebins = root_dir |> Path.join("lib/*/ebin") |> Path.wildcard()
+
+case System.fetch_env("COVER_FILE") do
+  {:ok, file} ->
+    _ = :cover.stop()
+    {:ok, _pid} = :cover.start()
+
+    for ebin <- ebins,
+        result <- :cover.compile_beam_directory(String.to_charlist(ebin)) do
+      case result do
+        {:ok, _module} ->
+          :ok
+
+        {:error, reason} ->
+          raise "Failed to cover compile directory #{ebin} with reason: #{inspect(reason)}"
+      end
+    end
+
+    System.at_exit(fn _status ->
+      :ok = :cover.export(String.to_charlist(file))
+    end)
+
+    true
+
+  :error ->
+    false
+end
diff --git a/lib/elixir/test/elixir/exception_test.exs b/lib/elixir/test/elixir/exception_test.exs
index 2f19f39515..dcb5a194c9 100644
--- a/lib/elixir/test/elixir/exception_test.exs
+++ b/lib/elixir/test/elixir/exception_test.exs
@@ -895,6 +895,7 @@ defmodule ExceptionTest do
       assert stack == [{ExampleModule, :fun, 1, [line: 13]}]
     end
 
+    @tag :require_ast
     test "annotates args and clauses from mfa" do
       import PathHelpers
 
diff --git a/lib/elixir/test/elixir/kernel/dialyzer_test.exs b/lib/elixir/test/elixir/kernel/dialyzer_test.exs
index d414b6d8c6..ba5cbfb5bc 100644
--- a/lib/elixir/test/elixir/kernel/dialyzer_test.exs
+++ b/lib/elixir/test/elixir/kernel/dialyzer_test.exs
@@ -8,6 +8,7 @@ defmodule Kernel.DialyzerTest do
   use ExUnit.Case, async: true
 
   @moduletag :dialyzer
+  @moduletag :require_ast
   import PathHelpers
 
   setup_all do
diff --git a/lib/elixir/test/elixir/module/types/integration_test.exs b/lib/elixir/test/elixir/module/types/integration_test.exs
index 8e67051f25..ff39d5cd9f 100644
--- a/lib/elixir/test/elixir/module/types/integration_test.exs
+++ b/lib/elixir/test/elixir/module/types/integration_test.exs
@@ -458,6 +458,7 @@ defmodule Module.Types.IntegrationTest do
       assert_warnings(files, warnings)
     end
 
+    @tag :require_ast
     test "String.Chars protocol dispatch" do
       files = %{
         "a.ex" => """
@@ -520,6 +521,7 @@ defmodule Module.Types.IntegrationTest do
       assert_warnings(files, warnings, consolidate_protocols: true)
     end
 
+    @tag :require_ast
     test "Enumerable protocol dispatch" do
       files = %{
         "a.ex" => """
diff --git a/lib/elixir/test/elixir/test_helper.exs b/lib/elixir/test/elixir/test_helper.exs
index b02437a6a7..87714dcf02 100644
--- a/lib/elixir/test/elixir/test_helper.exs
+++ b/lib/elixir/test/elixir/test_helper.exs
@@ -47,9 +47,20 @@ source_exclude =
     []
   end
 
+cover_enabled? = Code.eval_file("../../scripts/cover_record.exs", __DIR__)
+
+cover_exclude =
+  if cover_enabled? do
+    [:require_ast]
+  else
+    []
+  end
+
 ExUnit.start(
   trace: !!System.get_env("TRACE"),
   assert_receive_timeout: assert_timeout,
-  exclude: epmd_exclude ++ os_exclude ++ line_exclude ++ distributed_exclude ++ source_exclude,
+  exclude:
+    epmd_exclude ++
+      os_exclude ++ line_exclude ++ distributed_exclude ++ source_exclude ++ cover_exclude,
   include: line_include
 )
diff --git a/lib/ex_unit/lib/ex_unit/diff.ex b/lib/ex_unit/lib/ex_unit/diff.ex
index b562b64681..b2c9604f16 100644
--- a/lib/ex_unit/lib/ex_unit/diff.ex
+++ b/lib/ex_unit/lib/ex_unit/diff.ex
@@ -1162,6 +1162,7 @@ defmodule ExUnit.Diff do
     else
       other
       |> Map.to_list()
+      |> Enum.sort()
       |> Enum.map(&escape_pair/1)
       |> build_map_or_struct(struct)
     end
diff --git a/lib/ex_unit/test/ex_unit/formatter_test.exs b/lib/ex_unit/test/ex_unit/formatter_test.exs
index 62ecfc0d2a..923af02c7f 100644
--- a/lib/ex_unit/test/ex_unit/formatter_test.exs
+++ b/lib/ex_unit/test/ex_unit/formatter_test.exs
@@ -86,7 +86,9 @@ defmodule ExUnit.FormatterTest do
 
     failure = [{:exit, {{error, stack}, {:mod, :fun, []}}, []}]
 
-    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+    format = trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2))
+
+    assert format =~
              """
                1) world (Hello)
                   test/ex_unit/formatter_test.exs:1
@@ -101,11 +103,16 @@ defmodule ExUnit.FormatterTest do
 
                            # 2
                            :bar
+             """
 
-                       Attempted function clauses (showing 5 out of 5):
+    if Access not in :cover.modules() do
+      assert format =~
+               """
+                         Attempted function clauses (showing 5 out of 5):
 
-                           def fetch(%module{} = container, key)
-             """
+                             def fetch(%module{} = container, key)
+               """
+    end
   end
 
   test "formats test exits with assertion mfa" do
@@ -177,11 +184,16 @@ defmodule ExUnit.FormatterTest do
 
                            # 2
                            :bar
+             """
 
-                       Attempted function clauses (showing 5 out of 5):
+    if Access not in :cover.modules() do
+      assert format =~
+               """
+                         Attempted function clauses (showing 5 out of 5):
 
-                           def fetch(%module{} = container, key)
-             """
+                             def fetch(%module{} = container, key)
+               """
+    end
 
     assert format =~ ~r"lib/access.ex:\d+: Access.fetch/2"
   end
@@ -418,11 +430,16 @@ defmodule ExUnit.FormatterTest do
 
                     # 2
                     :bar
+           """
 
-                Attempted function clauses (showing 5 out of 5):
+    if Access not in :cover.modules() do
+      assert failure =~
+               """
+                    Attempted function clauses (showing 5 out of 5):
 
-                    def fetch(%module{} = container, key)
-           """
+                        def fetch(%module{} = container, key)
+               """
+    end
 
     assert failure =~ ~r"\(elixir #{System.version()}\) lib/access\.ex:\d+: Access\.fetch/2"
   end
diff --git a/lib/ex_unit/test/test_helper.exs b/lib/ex_unit/test/test_helper.exs
index bacef54149..ce87daa746 100644
--- a/lib/ex_unit/test/test_helper.exs
+++ b/lib/ex_unit/test/test_helper.exs
@@ -7,6 +7,8 @@ Logger.configure_backend(:console, colors: [enabled: false])
 {line_exclude, line_include} =
   if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
 
+Code.eval_file("../../elixir/scripts/cover_record.exs", __DIR__)
+
 ExUnit.start(
   trace: !!System.get_env("TRACE"),
   include: line_include,
diff --git a/lib/iex/test/iex/helpers_test.exs b/lib/iex/test/iex/helpers_test.exs
index 11a76f13fc..594e32ccee 100644
--- a/lib/iex/test/iex/helpers_test.exs
+++ b/lib/iex/test/iex/helpers_test.exs
@@ -168,10 +168,12 @@ defmodule IEx.HelpersTest do
                ~r/#{@example_module_path}:\d+$/
     end
 
+    @tag :require_ast
     test "opens function" do
       assert capture_iex("open(h)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
     end
 
+    @tag :require_ast
     test "opens function/arity" do
       assert capture_iex("open(b/1)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
       assert capture_iex("open(h/0)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
@@ -193,14 +195,17 @@ defmodule IEx.HelpersTest do
                ~r/#{@example_module_path}:\d+$/
     end
 
+    @tag :require_ast
     test "opens Erlang module" do
       assert capture_iex("open(:elixir)") |> maybe_trim_quotes() =~ ~r/#{@elixir_erl}:\d+$/
     end
 
+    @tag :require_ast
     test "opens Erlang module.function" do
       assert capture_iex("open(:elixir.start)") |> maybe_trim_quotes() =~ ~r/#{@elixir_erl}:\d+$/
     end
 
+    @tag :require_ast
     test "opens Erlang module.function/arity" do
       assert capture_iex("open(:elixir.start/2)") |> maybe_trim_quotes() =~
                ~r/#{@elixir_erl}:\d+$/
diff --git a/lib/iex/test/test_helper.exs b/lib/iex/test/test_helper.exs
index f59c642e93..c0a5f09170 100644
--- a/lib/iex/test/test_helper.exs
+++ b/lib/iex/test/test_helper.exs
@@ -28,11 +28,20 @@ source_exclude =
     []
   end
 
+cover_enabled? = Code.eval_file("../../elixir/scripts/cover_record.exs", __DIR__)
+
+cover_exclude =
+  if cover_enabled? do
+    [:require_ast]
+  else
+    []
+  end
+
 ExUnit.start(
   assert_receive_timeout: assert_timeout,
   trace: !!System.get_env("TRACE"),
   include: line_include,
-  exclude: line_exclude ++ erlang_doc_exclude ++ source_exclude
+  exclude: line_exclude ++ erlang_doc_exclude ++ source_exclude ++ cover_exclude
 )
 
 defmodule IEx.Case do
diff --git a/lib/logger/test/test_helper.exs b/lib/logger/test/test_helper.exs
index 909d28dda1..a8df0dd8d0 100644
--- a/lib/logger/test/test_helper.exs
+++ b/lib/logger/test/test_helper.exs
@@ -5,6 +5,8 @@
 {line_exclude, line_include} =
   if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
 
+Code.eval_file("../../elixir/scripts/cover_record.exs", __DIR__)
+
 ExUnit.start(
   trace: !!System.get_env("TRACE"),
   include: line_include,
diff --git a/lib/mix/lib/mix/tasks/test.coverage.ex b/lib/mix/lib/mix/tasks/test.coverage.ex
index 143a6bc0df..c85c89adda 100644
--- a/lib/mix/lib/mix/tasks/test.coverage.ex
+++ b/lib/mix/lib/mix/tasks/test.coverage.ex
@@ -268,7 +268,8 @@ defmodule Mix.Tasks.Test.Coverage do
     end
   end
 
-  defp generate_cover_results(opts) do
+  @doc false
+  def generate_cover_results(opts) do
     {:result, ok, _fail} = :cover.analyse(:coverage, :line)
     ignore = opts[:ignore_modules] || []
     modules = Enum.reject(:cover.modules(), &ignored?(&1, ignore))
diff --git a/lib/mix/test/test_helper.exs b/lib/mix/test/test_helper.exs
index 05f21bc2df..6ca0cda4d6 100644
--- a/lib/mix/test/test_helper.exs
+++ b/lib/mix/test/test_helper.exs
@@ -43,6 +43,8 @@ cover_exclude =
     []
   end
 
+Code.eval_file("../../elixir/scripts/cover_record.exs", __DIR__)
+
 ExUnit.start(
   trace: !!System.get_env("TRACE"),
   exclude: epmd_exclude ++ os_exclude ++ git_exclude ++ line_exclude ++ cover_exclude,