Convert ExUnit.Test and ExUnit.TestCase to structs

Author: José Valim

lib/elixir/lib/kernel/cli.ex

@@ -88,7 +88,7 @@ defmodule Kernel.CLI do
     IO.puts :stderr, Exception.format(kind, reason, prune_stacktrace(trace))
   end
 
-  @elixir_internals [:elixir_compiler, :elixir_module]
+  @elixir_internals [:elixir_compiler, :elixir_module, :elixir_translator, :elixir_expand]
 
   defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
     prune_stacktrace(t)

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -201,14 +201,28 @@ defmodule Kernel.ParallelCompiler do
 
   defp print_failure(file, {:failure, kind, reason, stacktrace}) do
     IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
-    IO.puts Exception.format(kind, reason, stacktrace)
+    IO.puts Exception.format(kind, reason, prune_stacktrace(stacktrace))
   end
 
   defp print_failure(file, reason) do
     IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
     IO.puts Exception.format(:exit, reason, [])
   end
 
+  @elixir_internals [:elixir_compiler, :elixir_module, :elixir_translator, :elixir_expand]
+
+  defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
+    prune_stacktrace(t)
+  end
+
+  defp prune_stacktrace([h|t]) do
+    [h|prune_stacktrace(t)]
+  end
+
+  defp prune_stacktrace([]) do
+    []
+  end
+
   defp all_missing?(entries, waiting, queued) do
     entries == [] and waiting != [] and
       length(waiting) == length(queued)

lib/elixir/src/elixir_map.erl

@@ -89,33 +89,42 @@ translate_struct(Meta, Name, {'%{}', MapMeta, Args}, S) ->
 
 %% Helpers
 
-load_struct(Meta, Name, S) ->
+load_struct(Meta, Module, S) ->
   Local =
-    elixir_module:is_open(Name) andalso
+    elixir_module:is_open(Module) andalso
     (case lists:keyfind(struct, 1, Meta) of
       {struct, context} -> true;
-      _ -> wait_for_struct(Name)
+      _ -> wait_for_struct(Module)
     end),
 
-  try
-    case Local of
-      true ->
-        try
-          (elixir_locals:local_for(Name, '__struct__', 0, def))()
-        catch
-          error:undef  -> Name:'__struct__'();
-          error:badarg -> Name:'__struct__'()
-        end;
-      false ->
-        Name:'__struct__'()
-    end
-  catch
-    error:undef ->
-      Inspected = elixir_aliases:inspect(Name),
-      compile_error(Meta, S#elixir_scope.file, "~ts.__struct__/0 is undefined, "
-        "cannot expand struct ~ts", [Inspected, Inspected])
+  case Local of
+    true ->
+      try
+        (elixir_locals:local_for(Module, '__struct__', 0, def))()
+      catch
+        error:undef  -> get_struct(Meta, Module, S);
+        error:badarg -> get_struct(Meta, Module, S)
+      end;
+    false ->
+      get_struct(Meta, Module, S)
+  end.
+
+get_struct(Meta, Module, S) ->
+  case code:ensure_loaded(Module) of
+    {module, Module} ->
+      case erlang:function_exported(Module, '__struct__', 0) of
+        true -> Module:'__struct__'();
+        false -> raise_struct(Meta, Module, S)
+      end;
+    {error, _} ->
+      raise_struct(Meta, Module, S)
   end.
 
+raise_struct(Meta, Module, S) ->
+  Inspected = elixir_aliases:inspect(Module),
+  compile_error(Meta, S#elixir_scope.file, "~ts.__struct__/0 is undefined, "
+    "cannot expand struct ~ts", [Inspected, Inspected]).
+
 wait_for_struct(Module) ->
   case erlang:get(elixir_compiler_pid) of
     undefined ->

lib/ex_unit/lib/ex_unit.ex

@@ -57,27 +57,44 @@ defmodule ExUnit do
   files. See `Mix.Tasks.Test` for more information.
   """
 
-  @typedoc "The state returned by ExUnit.Test and ExUnit.TestCase."
+  @typedoc "The state returned by ExUnit.Test and ExUnit.TestCase"
   @type state  :: nil | {:failed, failed} | {:skip, binary} | {:invalid, module}
   @type failed :: {:error | :exit | :throw | :EXIT, reason :: term, stacktrace :: [tuple]}
 
-  defrecord Test, [:name, :case, :state, :time, :tags] do
+  defmodule Test do
     @moduledoc """
-    A record that keeps information about the test.
-    It is received by formatters and also accessible
-    in the metadata under the key `:test`.
+    A struct that keeps information about the test.
+
+    It is received by formatters and contains the following fields:
+
+    * `:name` - the test name
+    * `:case` - the test case
+    * `:state` - the test state (see ExUnit.state)
+    * `:time` - the time to run the test
+    * `:tags` - the test tags
+
     """
-    record_type name: atom, case: module, state: ExUnit.state,
-                time: non_neg_integer, tags: Keyword.t
+    defstruct name: nil :: atom,
+              case: nil :: module,
+              state: nil :: ExUnit.state,
+              time: 0 :: non_neg_integer,
+              tags: %{} :: map
   end
 
-  defrecord TestCase, [:name, :state, :tests] do
+  defmodule TestCase do
     @moduledoc """
-    A record that keeps information about the test case.
-    It is received by formatters and also accessible
-    in the metadata under the key `:case`.
+    A struct that keeps information about the test case.
+
+    It is received by formatters and contains the following fields:
+
+    * `:name` - the test case name
+    * `:state` - the test state (see ExUnit.state)
+    * `:tests` - all tests for this case
+
     """
-    record_type name: module, state: ExUnit.state, tests: [ExUnit.Test.t]
+    defstruct name: nil :: module,
+              state: nil :: ExUnit.state,
+              tests: [] :: [ExUnit.Test.t]
   end
 
   use Application

lib/ex_unit/lib/ex_unit/case.ex

@@ -225,7 +225,7 @@ defmodule ExUnit.Case do
   defmacro __before_compile__(_) do
     quote do
       def __ex_unit__(:case) do
-        ExUnit.TestCase[name: __MODULE__, tests: @ex_unit_tests]
+        %ExUnit.TestCase{name: __MODULE__, tests: @ex_unit_tests}
       end
     end
   end
@@ -237,7 +237,7 @@ defmodule ExUnit.Case do
     tags = [line: env.line, file: env.file] ++ normalize_tags(tags)
 
     Module.put_attribute(mod, :ex_unit_tests,
-      ExUnit.Test[name: name, case: mod, tags: tags])
+      %ExUnit.Test{name: name, case: mod, tags: tags})
 
     Module.delete_attribute(mod, :tag)
   end

lib/ex_unit/lib/ex_unit/cli_formatter.ex

@@ -21,12 +21,12 @@ defmodule ExUnit.CLIFormatter do
     :remove_handler
   end
 
-  def handle_event({:test_started, ExUnit.Test[] = test}, config) do
+  def handle_event({:test_started, %ExUnit.Test{} = test}, config) do
     if config.trace, do: IO.write "  * #{trace_test_name test}"
     {:ok, config}
   end
 
-  def handle_event({:test_finished, ExUnit.Test[state: nil] = test}, config) do
+  def handle_event({:test_finished, %ExUnit.Test{state: nil} = test}, config) do
     if config.trace do
       IO.puts success(trace_test_result(test), config)
     else
@@ -35,12 +35,12 @@ defmodule ExUnit.CLIFormatter do
     {:ok, config.update_tests_counter(&(&1 + 1))}
   end
 
-  def handle_event({:test_finished, ExUnit.Test[state: {:skip, _}] = test}, config) do
+  def handle_event({:test_finished, %ExUnit.Test{state: {:skip, _}} = test}, config) do
     if config.trace, do: IO.puts trace_test_skip(test)
     {:ok, config}
   end
 
-  def handle_event({:test_finished, ExUnit.Test[state: {:invalid, _}] = test}, config) do
+  def handle_event({:test_finished, %ExUnit.Test{state: {:invalid, _}} = test}, config) do
     if config.trace do
       IO.puts invalid(trace_test_result(test), config)
     else
@@ -51,7 +51,7 @@ defmodule ExUnit.CLIFormatter do
                 .update_invalids_counter(&(&1 + 1))}
   end
 
-  def handle_event({:test_finished, ExUnit.Test[state: {:failed, failed}] = test}, config) do
+  def handle_event({:test_finished, %ExUnit.Test{state: {:failed, failed}} = test}, config) do
     if config.trace do
       IO.puts failure(trace_test_result(test), config)
     end
@@ -64,19 +64,19 @@ defmodule ExUnit.CLIFormatter do
                 .update_failures_counter(&(&1 + 1))}
   end
 
-  def handle_event({:case_started, ExUnit.TestCase[] = test_case}, config) do
+  def handle_event({:case_started, %ExUnit.TestCase{name: name}}, config) do
     if config.trace do
-      IO.puts("\n#{inspect test_case.name}")
+      IO.puts("\n#{inspect name}")
     end
 
     {:ok, config}
   end
 
-  def handle_event({:case_finished, ExUnit.TestCase[state: nil]}, config) do
+  def handle_event({:case_finished, %ExUnit.TestCase{state: nil}}, config) do
     {:ok, config}
   end
 
-  def handle_event({:case_finished, ExUnit.TestCase[state: {:failed, failed}] = test_case}, config) do
+  def handle_event({:case_finished, %ExUnit.TestCase{state: {:failed, failed}} = test_case}, config) do
     formatted = format_test_case_failure(test_case, failed, config.failures_counter + 1,
                                          config.width, &formatter(&1, &2, config))
     print_failure(formatted, config)
@@ -89,14 +89,14 @@ defmodule ExUnit.CLIFormatter do
 
   ## Tracing
 
-  defp trace_test_name(ExUnit.Test[name: name]) do
+  defp trace_test_name(%ExUnit.Test{name: name}) do
     case atom_to_binary(name) do
       "test " <> rest -> rest
       rest -> rest
     end
   end
 
-  defp trace_test_time(ExUnit.Test[time: time]) do
+  defp trace_test_time(%ExUnit.Test{time: time}) do
     "#{format_us(time)}ms"
   end
 

lib/ex_unit/lib/ex_unit/formatter.ex

@@ -101,7 +101,7 @@ defmodule ExUnit.Formatter do
   Receives a test and formats its failure.
   """
   def format_test_failure(test, {kind, reason, stack}, counter, width, formatter) do
-    ExUnit.Test[name: name, case: case, tags: tags] = test
+    %ExUnit.Test{name: name, case: case, tags: tags} = test
     test_info(with_counter(counter, "#{name} (#{inspect case})"), formatter)
       <> test_location(with_location(tags), formatter)
       <> format_kind_reason(kind, reason, width, formatter)
@@ -112,7 +112,7 @@ defmodule ExUnit.Formatter do
   Receives a test case and formats its failure.
   """
   def format_test_case_failure(test_case, {kind, reason, stacktrace}, counter, width, formatter) do
-    ExUnit.TestCase[name: name] = test_case
+    %ExUnit.TestCase{name: name} = test_case
     test_case_info(with_counter(counter, "#{inspect name}: "), formatter)
       <> format_kind_reason(kind, reason, width, formatter)
       <> format_stacktrace(stacktrace, name, nil, formatter)

lib/ex_unit/lib/ex_unit/runner.ex

@@ -95,7 +95,7 @@ defmodule ExUnit.Runner do
   end
 
   defp run_case(config, pid, case_name) do
-    ExUnit.TestCase[] = test_case = case_name.__ex_unit__(:case)
+    test_case = case_name.__ex_unit__(:case)
     EM.case_started(config.manager, test_case)
 
     # Prepare tests, selecting which ones should
@@ -124,8 +124,8 @@ defmodule ExUnit.Runner do
     for test <- tests do
       tags = Keyword.put(test.tags, :test, test.name)
       case ExUnit.Filters.eval(include, exclude, tags) do
-        :ok           -> test.tags(tags)
-        {:error, tag} -> test.state({:skip, "due to #{tag} filter"})
+        :ok           -> %{test | tags: tags}
+        {:error, tag} -> %{test | state: {:skip, "due to #{tag} filter"}}
       end
     end
   end
@@ -142,7 +142,7 @@ defmodule ExUnit.Runner do
             send self_pid, {self, :case_finished, test_case, []}
 
           {:error, test_case} ->
-            failed_tests = Enum.map(tests, &(&1.state({:invalid, test_case})))
+            failed_tests = Enum.map(tests, & %{&1 | state: {:invalid, test_case}})
             send self_pid, {self, :case_finished, test_case, failed_tests}
         end
       end)
@@ -151,24 +151,26 @@ defmodule ExUnit.Runner do
       {^case_pid, :case_finished, test_case, tests} ->
         {test_case, tests}
       {:DOWN, ^case_ref, :process, ^case_pid, error} ->
-        {test_case.state({:failed, {:EXIT, error, []}}), []}
+        {%{test_case | state: {:failed, {:EXIT, error, []}}}, []}
     end
   end
 
-  defp exec_case_setup(ExUnit.TestCase[name: case_name] = test_case) do
+  defp exec_case_setup(%ExUnit.TestCase{name: case_name} = test_case) do
     {:ok, context} = case_name.__ex_unit__(:setup_all, [case: case_name])
     {:ok, {test_case, context}}
   catch
     kind, error ->
-      {:error, test_case.state({:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}})}
+      failed = {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
+      {:error, %{test_case | state: failed}}
   end
 
-  defp exec_case_teardown(ExUnit.TestCase[name: case_name] = test_case, context) do
+  defp exec_case_teardown(%ExUnit.TestCase{name: case_name} = test_case, context) do
     case_name.__ex_unit__(:teardown_all, context)
     test_case
   catch
     kind, error ->
-      test_case.state {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
+      failed = {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
+      %{test_case | state: failed}
   end
 
   defp run_test(config, test, context) do
@@ -199,40 +201,42 @@ defmodule ExUnit.Runner do
             end
           end)
 
-        send self_pid, {self, :test_finished, test.time(us)}
+        send self_pid, {self, :test_finished, %{test | time: us}}
       end)
 
     receive do
       {^test_pid, :test_finished, test} ->
         test
       {:DOWN, ^test_ref, :process, ^test_pid, error} ->
-        test.state {:failed, {:EXIT, error, []}}
+        %{test | state: {:failed, {:EXIT, error, []}}}
     end
   end
 
-  defp exec_test_setup(ExUnit.Test[] = test, context) do
-    {:ok, context} = test.case.__ex_unit__(:setup, context)
+  defp exec_test_setup(%ExUnit.Test{case: case} = test, context) do
+    {:ok, context} = case.__ex_unit__(:setup, context)
     {:ok, {test, context}}
   catch
     kind2, error2 ->
-      {:error, test.state({:failed, {kind2, Exception.normalize(kind2, error2), pruned_stacktrace}})}
+      failed = {:failed, {kind2, Exception.normalize(kind2, error2), pruned_stacktrace}}
+      {:error, %{test | state: failed}}
   end
 
-  defp exec_test(ExUnit.Test[] = test, context) do
-    apply(test.case, test.name, [context])
+  defp exec_test(%ExUnit.Test{case: case, name: name} = test, context) do
+    apply(case, name, [context])
     test
   catch
     kind, error ->
-      test.state {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
+      failed = {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
+      %{test | state: failed}
   end
 
-  defp exec_test_teardown(ExUnit.Test[] = test, context) do
-    {:ok, _context} = test.case.__ex_unit__(:teardown, context)
+  defp exec_test_teardown(%ExUnit.Test{case: case} = test, context) do
+    {:ok, _context} = case.__ex_unit__(:teardown, context)
     test
   catch
     kind, error ->
       if nil?(test.state) do
-        test.state {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
+        %{test | state: {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}}
       else
         test
       end