Use Test Modules in tests instead of Elixir built-in modules

Prep for Coverage Reporting in tests

Author: maennchen

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

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

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
 

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
 

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