 
         case exec_module_setup(test_module) do
           {:ok, test_module, context} ->
-            Enum.each tests, &run_test(config, &1, context)
-            send parent, {self(), :module_finished, test_module, []}
+            Enum.each(tests, &run_test(config, &1, context))
+            send(parent, {self(), :module_finished, test_module, []})
 
           {:error, test_module} ->
-            failed_tests = Enum.map tests, & %{&1 | state: {:invalid, test_module}}
-            send parent, {self(), :module_finished, test_module, failed_tests}
+            failed_tests = Enum.map(tests, &%{&1 | state: {:invalid, test_module}})
+            send(parent, {self(), :module_finished, test_module, failed_tests})
         end
 
         exit(:shutdown)

  end

  defp failed(:error, %ExUnit.MultiError{errors: errors}, _stack) do
    {:failed,
     Enum.map(errors, fn {kind, reason, stack} ->
       {kind, Exception.normalize(kind, reason), prune_stacktrace(stack)}
     end)}
  end

  defp failed(kind, reason, stack) do
    {:failed, [{kind, Exception.normalize(kind, reason), stack}]}
  end

  defp pruned_stacktrace, do: prune_stacktrace(System.stacktrace)

  # Assertions can pop-up in the middle of the stack
  defp prune_stacktrace([{ExUnit.Assertions, _, _, _} | t]), do: prune_stacktrace(t)

  defp configure(opts) do
    opts = normalize_opts(opts)

    {:ok, manager} = EM.start_link()
    {:ok, stats} = EM.add_handler(manager, ExUnit.RunnerStats, opts)
    Enum.each(opts[:formatters], &EM.add_handler(manager, &1, opts))

    config = %{
      capture_log: opts[:capture_log],
