add eunit task, still work to be done

5 files changed, 810 insertions, 2 deletions

diff --git a/src/rebar.app.src b/src/rebar.app.src
index 894ca7b..dc3e689 100644
--- a/src/rebar.app.src
+++ b/src/rebar.app.src
@@ -25,6 +25,7 @@
         {providers, [rebar_prv_clean,
                      rebar_prv_deps,
                      rebar_prv_do,
+                     rebar_prv_eunit,
                      rebar_prv_lock,
                      rebar_prv_install_deps,
                      rebar_prv_packages,
diff --git a/src/rebar_cover_utils.erl b/src/rebar_cover_utils.erl
new file mode 100644
index 0000000..24c769a
--- /dev/null
+++ b/src/rebar_cover_utils.erl
@@ -0,0 +1,261 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+%% -------------------------------------------------------------------
+%%
+%% rebar: Erlang Build Tools
+%%
+%% Copyright (c) 2009, 2010 Dave Smith (dizzyd@dizzyd.com)
+%% Copyright (c) 2013 Andras Horvath (andras.horvath@erlang-solutions.com)
+%%
+%% Permission is hereby granted, free of charge, to any person obtaining a copy
+%% of this software and associated documentation files (the "Software"), to deal
+%% in the Software without restriction, including without limitation the rights
+%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+%% copies of the Software, and to permit persons to whom the Software is
+%% furnished to do so, subject to the following conditions:
+%%
+%% The above copyright notice and this permission notice shall be included in
+%% all copies or substantial portions of the Software.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+%% THE SOFTWARE.
+%% -------------------------------------------------------------------
+-module(rebar_cover_utils).
+
+%% for internal use only
+-export([init/3,
+         perform_cover/4,
+         close/1,
+         exit/0]).
+
+-include("rebar.hrl").
+
+%% ====================================================================
+%% Internal functions
+%% ====================================================================
+
+perform_cover(Config, BeamFiles, SrcModules, TargetDir) ->
+    perform_cover(rebar_state:get(Config, cover_enabled, false),
+                  Config, BeamFiles, SrcModules, TargetDir).
+
+perform_cover(false, _Config, _BeamFiles, _SrcModules, _TargetDir) ->
+    ok;
+perform_cover(true, Config, BeamFiles, SrcModules, TargetDir) ->
+    analyze(Config, BeamFiles, SrcModules, TargetDir).
+
+close(not_enabled) ->
+    ok;
+close(F) ->
+    ok = file:close(F).
+
+exit() ->
+   cover:stop().
+
+init(false, _BeamFiles, _TargetDir) ->
+    {ok, not_enabled};
+init(true, BeamFiles, TargetDir) ->
+    %% Attempt to start the cover server, then set its group leader to
+    %% TargetDir/cover.log, so all cover log messages will go there instead of
+    %% to stdout. If the cover server is already started, we'll kill that
+    %% server and start a new one in order not to inherit a polluted
+    %% cover_server state.
+    {ok, CoverPid} = case whereis(cover_server) of
+                         undefined ->
+                             cover:start();
+                         _         ->
+                             cover:stop(),
+                             cover:start()
+                     end,
+
+    {ok, F} = OkOpen = file:open(
+                         filename:join([TargetDir, "cover.log"]),
+                         [write]),
+
+    group_leader(F, CoverPid),
+
+    ?INFO("Cover compiling ~s\n", [rebar_utils:get_cwd()]),
+
+    Compiled = [{Beam, cover:compile_beam(Beam)} || Beam <- BeamFiles],
+    case [Module || {_, {ok, Module}} <- Compiled] of
+        [] ->
+            %% No modules compiled successfully...fail
+            ?ERROR("Cover failed to compile any modules; aborting.~n", []),
+            ?FAIL;
+        _ ->
+            %% At least one module compiled successfully
+
+            %% It's not an error for cover compilation to fail partially,
+            %% but we do want to warn about them
+            PrintWarning =
+                fun(Beam, Desc) ->
+                        ?CONSOLE("Cover compilation warning for ~p: ~p",
+                                 [Beam, Desc])
+                end,
+            _ = [PrintWarning(Beam, Desc) || {Beam, {error, Desc}} <- Compiled],
+            OkOpen
+    end;
+init(Config, BeamFiles, TargetDir) ->
+    init(rebar_state:get(Config, cover_enabled, false), BeamFiles, TargetDir).
+
+analyze(_Config, [], _SrcModules, _TargetDir) ->
+    ok;
+analyze(Config, FilteredModules, SrcModules, TargetDir) ->
+    %% Generate coverage info for all the cover-compiled modules
+    Coverage = lists:flatten([analyze_mod(M)
+                              || M <- FilteredModules,
+                                 cover:is_compiled(M) =/= false]),
+
+    %% Write index of coverage info
+    write_index(lists:sort(Coverage), SrcModules, TargetDir),
+
+    %% Write coverage details for each file
+    lists:foreach(
+      fun({M, _, _}) ->
+              {ok, _} = cover:analyze_to_file(M,
+                                              cover_file(M, TargetDir),
+                                              [html])
+      end, Coverage),
+
+    Index = filename:join([rebar_utils:get_cwd(), TargetDir, "index.html"]),
+    ?CONSOLE("Cover analysis: ~s\n", [Index]),
+
+    %% Export coverage data, if configured
+    case rebar_state:get(Config, cover_export_enabled, false) of
+        true ->
+            export_coverdata(TargetDir);
+        false ->
+            ok
+    end,
+
+    %% Print coverage report, if configured
+    case rebar_state:get(Config, cover_print_enabled, false) of
+        true ->
+            print_coverage(lists:sort(Coverage));
+        false ->
+            ok
+    end.
+
+analyze_mod(Module) ->
+    case cover:analyze(Module, coverage, module) of
+        {ok, {Module, {Covered, NotCovered}}} ->
+            %% Modules that include the eunit header get an implicit
+            %% test/0 fun, which cover considers a runnable line, but
+            %% eunit:test(TestRepresentation) never calls.  Decrement
+            %% NotCovered in this case.
+            [align_notcovered_count(Module, Covered, NotCovered,
+                                    is_eunitized(Module))];
+        {error, Reason} ->
+            ?ERROR("Cover analyze failed for ~p: ~p ~p\n",
+                   [Module, Reason, code:which(Module)]),
+            []
+    end.
+
+is_eunitized(Mod) ->
+    has_eunit_test_fun(Mod) andalso
+        has_header(Mod, "include/eunit.hrl").
+
+has_eunit_test_fun(Mod) ->
+    [F || {exports, Funs} <- Mod:module_info(),
+          {F, 0} <- Funs, F =:= test] =/= [].
+
+has_header(Mod, Header) ->
+    Mod1 = case code:which(Mod) of
+               cover_compiled ->
+                   {file, File} = cover:is_compiled(Mod),
+                   File;
+               non_existing -> Mod;
+               preloaded -> Mod;
+               L -> L
+           end,
+    {ok, {_, [{abstract_code, {_, AC}}]}} =
+        beam_lib:chunks(Mod1, [abstract_code]),
+    [F || {attribute, 1, file, {F, 1}} <- AC,
+          string:str(F, Header) =/= 0] =/= [].
+
+align_notcovered_count(Module, Covered, NotCovered, false) ->
+    {Module, Covered, NotCovered};
+align_notcovered_count(Module, Covered, NotCovered, true) ->
+    {Module, Covered, NotCovered - 1}.
+
+write_index(Coverage, SrcModules, TargetDir) ->
+    {ok, F} = file:open(filename:join([TargetDir, "index.html"]), [write]),
+    ok = file:write(F, "<!DOCTYPE HTML><html>\n"
+                    "<head><meta charset=\"utf-8\">"
+                    "<title>Coverage Summary</title></head>\n"
+                    "<body>\n"),
+    IsSrcCoverage = fun({Mod,_C,_N}) -> lists:member(Mod, SrcModules) end,
+    {SrcCoverage, TestCoverage} = lists:partition(IsSrcCoverage, Coverage),
+    write_index_section(F, "Source", SrcCoverage),
+    write_index_section(F, "Test", TestCoverage),
+    ok = file:write(F, "</body></html>"),
+    ok = file:close(F).
+
+write_index_section(_F, _SectionName, []) ->
+    ok;
+write_index_section(F, SectionName, Coverage) ->
+    %% Calculate total coverage
+    {Covered, NotCovered} = lists:foldl(fun({_Mod, C, N}, {CAcc, NAcc}) ->
+                                                {CAcc + C, NAcc + N}
+                                        end, {0, 0}, Coverage),
+    TotalCoverage = percentage(Covered, NotCovered),
+
+    %% Write the report
+    ok = file:write(F, ?FMT("<h1>~s Summary</h1>\n", [SectionName])),
+    ok = file:write(F, ?FMT("<h3>Total: ~s</h3>\n", [TotalCoverage])),
+    ok = file:write(F, "<table><tr><th>Module</th><th>Coverage %</th></tr>\n"),
+
+    FmtLink =
+        fun(Module, Cov, NotCov) ->
+                ?FMT("<tr><td><a href='~s.COVER.html'>~s</a></td><td>~s</td>\n",
+                     [Module, Module, percentage(Cov, NotCov)])
+        end,
+    lists:foreach(fun({Module, Cov, NotCov}) ->
+                          ok = file:write(F, FmtLink(Module, Cov, NotCov))
+                  end, Coverage),
+    ok = file:write(F, "</table>\n").
+
+print_coverage(Coverage) ->
+    {Covered, NotCovered} = lists:foldl(fun({_Mod, C, N}, {CAcc, NAcc}) ->
+                                                {CAcc + C, NAcc + N}
+                                        end, {0, 0}, Coverage),
+    TotalCoverage = percentage(Covered, NotCovered),
+
+    %% Determine the longest module name for right-padding
+    Width = lists:foldl(fun({Mod, _, _}, Acc) ->
+                                case length(atom_to_list(Mod)) of
+                                    N when N > Acc ->
+                                        N;
+                                    _ ->
+                                        Acc
+                                end
+                        end, 0, Coverage) * -1,
+
+    %% Print the output the console
+    ?CONSOLE("~nCode Coverage:~n", []),
+    lists:foreach(fun({Mod, C, N}) ->
+                          ?CONSOLE("~*s : ~4s~n",
+                                   [Width, Mod, percentage(C, N)])
+                  end, Coverage),
+    ?CONSOLE("~n~*s : ~s~n", [Width, "Total", TotalCoverage]).
+
+cover_file(Module, TargetDir) ->
+    filename:join([TargetDir, atom_to_list(Module) ++ ".COVER.html"]).
+
+export_coverdata(TargetDir) ->
+    ExportFile = filename:join(TargetDir, "cover.coverdata"),
+    case cover:export(ExportFile) of
+        ok ->
+            ?CONSOLE("Coverdata export: ~s~n", [ExportFile]);
+        {error, Reason} ->
+            ?ERROR("Coverdata export failed: ~p~n", [Reason])
+    end.
+
+percentage(0, 0) ->
+    "not executed";
+percentage(Cov, NotCov) ->
+    integer_to_list(trunc((Cov / (Cov + NotCov)) * 100)) ++ "%".
diff --git a/src/rebar_erlc_compiler.erl b/src/rebar_erlc_compiler.erl
index 33983e4..9a82e3d 100644
--- a/src/rebar_erlc_compiler.erl
+++ b/src/rebar_erlc_compiler.erl
@@ -142,7 +142,7 @@ clean(Config, AppDir) ->
 
 test_compile(Config, Cmd, OutDir) ->
     %% Obtain all the test modules for inclusion in the compile stage.
-    TestErls = rebar_utils:find_files("test", ?RE_PREFIX".*\\.erl\$"),
+    TestErls = rebar_utils:find_files(filename:absname("test"), ?RE_PREFIX".*\\.erl\$"),
 
     ErlOpts = rebar_utils:erl_opts(Config),
     {Config1, ErlOpts1} = test_compile_config_and_opts(Config, ErlOpts, Cmd),
@@ -154,7 +154,7 @@ test_compile(Config, Cmd, OutDir) ->
     SrcErls = lists:foldl(
                 fun(Dir, Acc) ->
                         Files = rebar_utils:find_files(
-                                  Dir, ?RE_PREFIX".*\\.erl\$"),
+                                  filename:absname(Dir), ?RE_PREFIX".*\\.erl\$"),
                         lists:append(Acc, Files)
                 end, [], SrcDirs),
 
diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl
new file mode 100644
index 0000000..1607d08
--- /dev/null
+++ b/src/rebar_prv_eunit.erl
@@ -0,0 +1,528 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+
+-module(rebar_prv_eunit).
+
+-behaviour(provider).
+
+-export([init/1,
+         do/1,
+         format_error/2]).
+
+-include("rebar.hrl").
+
+-define(PROVIDER, eunit).
+
+-define(DEPS, [compile]).
+-define(EUNIT_DIR, ".eunit").
+
+%% ===================================================================
+%% Public API
+%% ===================================================================
+
+-spec init(rebar_state:t()) -> {ok, rebar_state:t()}.
+init(State) ->
+    State1 = rebar_state:add_provider(State, providers:create([{name, ?PROVIDER},
+                                                               {module, ?MODULE},
+                                                               {bare, false},
+                                                               {deps, ?DEPS},
+                                                               {example, "rebar eunit"},
+                                                               {short_desc, "Run eunit tests on project apps."},
+                                                               {desc, ""},
+                                                               {opts, []}])),
+
+    {ok, State1}.
+
+-spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
+do(State) ->
+    ok = ensure_dirs(),
+    %% Save code path
+    CodePath = setup_code_path(),
+    CompileOnly = rebar_state:get(State, compile_only, false),
+    {ok, SrcErls} = rebar_erlc_compiler:test_compile(State, "eunit",
+                                                     ?EUNIT_DIR),
+    case CompileOnly of
+        "true" ->
+            true = rebar_utils:cleanup_code_path(CodePath),
+            ?CONSOLE("Compiled modules for eunit~n", []);
+        false ->
+            run_eunit(State, CodePath, SrcErls)
+    end,
+    {ok, State}.
+
+-spec format_error(any(), rebar_state:t()) ->  {iolist(), rebar_state:t()}.
+format_error(Reason, State) ->
+    {io_lib:format("~p", [Reason]), State}.
+
+run_eunit(Config, CodePath, SrcErls) ->
+    %% Build a list of all the .beams in ?EUNIT_DIR -- use this for
+    %% cover and eunit testing. Normally you can just tell cover
+    %% and/or eunit to scan the directory for you, but eunit does a
+    %% code:purge in conjunction with that scan and causes any cover
+    %% compilation info to be lost.
+    AllBeamFiles = rebar_utils:beams(?EUNIT_DIR),
+    {BeamFiles, TestBeamFiles} =
+        lists:partition(fun(N) -> string:str(N, "_tests.beam") =:= 0 end,
+                        AllBeamFiles),
+    OtherBeamFiles = TestBeamFiles --
+        [filename:rootname(N) ++ "_tests.beam" || N <- AllBeamFiles],
+    ModuleBeamFiles = randomize_suites(Config, BeamFiles ++ OtherBeamFiles),
+    %% Get matching tests and modules
+    AllModules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- AllBeamFiles],
+    {Tests, FilteredModules} =
+        get_tests_and_modules(Config, ModuleBeamFiles, AllModules),
+    SrcModules = [rebar_utils:erl_to_mod(M) || M <- SrcErls],
+    {ok, CoverLog} = rebar_cover_utils:init(Config, ModuleBeamFiles,
+                                            eunit_dir()),
+    StatusBefore = status_before_eunit(),
+    EunitResult = perform_eunit(Config, Tests),
+    rebar_cover_utils:perform_cover(Config, FilteredModules, SrcModules,
+                                    eunit_dir()),
+    rebar_cover_utils:close(CoverLog),
+    case proplists:get_value(reset_after_eunit, get_eunit_opts(Config),
+                             true) of
+        true ->
+            reset_after_eunit(StatusBefore);
+        false ->
+            ok
+    end,
+    %% Stop cover to clean the cover_server state. This is important if we want
+    %% eunit+cover to not slow down when analyzing many Erlang modules.
+    ok = rebar_cover_utils:exit(),
+    case EunitResult of
+        ok ->
+            ok;
+        _ ->
+            ?ABORT("One or more eunit tests failed.~n", [])
+    end,
+    %% Restore code path
+    true = rebar_utils:cleanup_code_path(CodePath),
+    ok.
+ensure_dirs() ->
+    %% Make sure ?EUNIT_DIR/ and ebin/ directory exists (append dummy module)
+    ok = filelib:ensure_dir(filename:join(eunit_dir(), "dummy")),
+    ok = filelib:ensure_dir(filename:join(rebar_utils:ebin_dir(), "dummy")).
+eunit_dir() ->
+    filename:join(rebar_utils:get_cwd(), ?EUNIT_DIR).
+setup_code_path() ->
+    %% Setup code path prior to compilation so that parse_transforms
+    %% and the like work properly. Also, be sure to add ebin_dir()
+    %% to the END of the code path so that we don't have to jump
+    %% through hoops to access the .app file
+    CodePath = code:get_path(),
+    true = code:add_patha(eunit_dir()),
+    true = code:add_pathz(rebar_utils:ebin_dir()),
+    CodePath.
+%%
+%% == get matching tests ==
+%%
+get_tests_and_modules(Config, ModuleBeamFiles, AllModules) ->
+    SelectedSuites = get_selected_suites(Config, AllModules),
+    {Tests, QualifiedTests} = get_qualified_and_unqualified_tests(Config),
+    Modules = get_test_modules(SelectedSuites, Tests,
+                               QualifiedTests, ModuleBeamFiles),
+    FilteredModules = get_matching_modules(AllModules, Modules, QualifiedTests),
+    MatchedTests = get_matching_tests(Modules, Tests, QualifiedTests),
+    {MatchedTests, FilteredModules}.
+%%
+%% == get suites specified via 'suites' option ==
+%%
+get_selected_suites(Config, Modules) ->
+    RawSuites = get_suites(Config),
+    Suites = [list_to_atom(Suite) || Suite <- string:tokens(RawSuites, ",")],
+    [M || M <- Suites, lists:member(M, Modules)].
+get_suites(Config) ->
+    case rebar_state:get(Config, suites, "") of
+        "" ->
+            rebar_state:get(Config, suite, "");
+        Suites ->
+            Suites
+    end.
+get_qualified_and_unqualified_tests(Config) ->
+    RawFunctions = rebar_state:get(Config, tests, ""),
+    FunctionNames = [FunctionName ||
+                        FunctionName <- string:tokens(RawFunctions, ",")],
+    get_qualified_and_unqualified_tests1(FunctionNames, [], []).
+get_qualified_and_unqualified_tests1([], Functions, QualifiedFunctions) ->
+    {Functions, QualifiedFunctions};
+get_qualified_and_unqualified_tests1([TestName|TestNames], Functions,
+                                     QualifiedFunctions) ->
+    case string:tokens(TestName, ":") of
+        [TestName] ->
+            Function = list_to_atom(TestName),
+            get_qualified_and_unqualified_tests1(
+              TestNames, [Function|Functions], QualifiedFunctions);
+        [ModuleName, FunctionName] ->
+            M = list_to_atom(ModuleName),
+            F = list_to_atom(FunctionName),
+            get_qualified_and_unqualified_tests1(TestNames, Functions,
+                                                 [{M, F}|QualifiedFunctions]);
+        _ ->
+            ?ABORT("Unsupported test function specification: ~s~n", [TestName])
+    end.
+%% Provide modules which are to be searched for tests.
+%% Several scenarios are possible:
+%%
+%% == randomize suites ==
+%%
+randomize_suites(Config, Modules) ->
+    case rebar_state:get(Config, random_suite_order, undefined) of
+        undefined ->
+            Modules;
+        "true" ->
+            Seed = crypto:rand_uniform(1, 65535),
+            randomize_suites1(Modules, Seed);
+        String ->
+            try list_to_integer(String) of
+                Seed ->
+                    randomize_suites1(Modules, Seed)
+            catch
+                error:badarg ->
+                    ?ERROR("Bad random seed provided: ~p~n", [String]),
+                    ?FAIL
+            end
+    end.
+randomize_suites1(Modules, Seed) ->
+    _ = random:seed(35, Seed, 1337),
+    ?CONSOLE("Randomizing suite order with seed ~b~n", [Seed]),
+    [X||{_,X} <- lists:sort([{random:uniform(), M} || M <- Modules])].
+%%
+%% == get matching tests ==
+%% 1) Specific tests have been provided and/or
+%% no unqualified tests have been specified and
+%% there were some qualified tests, then we can search for
+%% functions in specified suites (or in empty set of suites).
+%%
+%% 2) Neither specific suites nor qualified test names have been
+%% provided use ModuleBeamFiles which filters out "*_tests"
+%% modules so EUnit won't doubly run them and cover only
+%% calculates coverage on production code. However,
+%% keep "*_tests" modules that are not automatically
+%% included by EUnit.
+%%
+%% From 'Primitives' in the EUnit User's Guide
+%% http://www.erlang.org/doc/apps/eunit/chapter.html
+%% "In addition, EUnit will also look for another
+%% module whose name is ModuleName plus the suffix
+%% _tests, and if it exists, all the tests from that
+%% module will also be added. (If ModuleName already
+%% contains the suffix _tests, this is not done.) E.g.,
+%% the specification {module, mymodule} will run all
+%% tests in the modules mymodule and mymodule_tests.
+%% Typically, the _tests module should only contain
+%% test cases that use the public interface of the main
+%% module (and no other code)."
+get_test_modules(SelectedSuites, Tests, QualifiedTests, ModuleBeamFiles) ->
+    SuitesProvided = SelectedSuites =/= [],
+    OnlyQualifiedTestsProvided = QualifiedTests =/= [] andalso Tests =:= [],
+    if
+        SuitesProvided orelse OnlyQualifiedTestsProvided ->
+            SelectedSuites;
+        true ->
+            [rebar_utils:beam_to_mod(?EUNIT_DIR, N) ||
+                N <- ModuleBeamFiles]
+    end.
+get_matching_modules(AllModules, Modules, QualifiedTests) ->
+    ModuleFilterMapper =
+        fun({M, _}) ->
+                case lists:member(M, AllModules) of
+                    true -> {true, M};
+                    _-> false
+                end
+        end,
+    ModulesFromQualifiedTests = lists:zf(ModuleFilterMapper, QualifiedTests),
+    lists:usort(Modules ++ ModulesFromQualifiedTests).
+get_matching_tests(Modules, [], []) ->
+    Modules;
+get_matching_tests(Modules, [], QualifiedTests) ->
+    FilteredQualifiedTests = filter_qualified_tests(Modules, QualifiedTests),
+    lists:merge(Modules, make_test_primitives(FilteredQualifiedTests));
+get_matching_tests(Modules, Tests, QualifiedTests) ->
+    AllTests = lists:merge(QualifiedTests,
+                           get_matching_tests1(Modules, Tests, [])),
+    make_test_primitives(AllTests).
+filter_qualified_tests(Modules, QualifiedTests) ->
+    TestsFilter = fun({Module, _Function}) ->
+                          lists:all(fun(M) -> M =/= Module end, Modules) end,
+    lists:filter(TestsFilter, QualifiedTests).
+get_matching_tests1([], _Functions, TestFunctions) ->
+    TestFunctions;
+get_matching_tests1([Module|TModules], Functions, TestFunctions) ->
+    %% Get module exports
+    ModuleStr = atom_to_list(Module),
+    ModuleExports = get_beam_test_exports(ModuleStr),
+    %% Get module _tests exports
+    TestModuleStr = string:concat(ModuleStr, "_tests"),
+    TestModuleExports = get_beam_test_exports(TestModuleStr),
+    %% Build tests {M, F} list
+    Tests = get_matching_tests2(Functions, {Module, ModuleExports},
+                                {list_to_atom(TestModuleStr),
+                                 TestModuleExports}),
+    get_matching_tests1(TModules, Functions,
+                        lists:merge([TestFunctions, Tests])).
+get_matching_tests2(Functions, {Mod, ModExports}, {TestMod, TestModExports}) ->
+    %% Look for matching functions into ModExports
+    ModExportsStr = [atom_to_list(E1) || E1 <- ModExports],
+    TestModExportsStr = [atom_to_list(E2) || E2 <- TestModExports],
+    get_matching_exports(Functions, {Mod, ModExportsStr},
+                         {TestMod, TestModExportsStr}, []).
+get_matching_exports([], _, _, Matched) ->
+    Matched;
+get_matching_exports([Function|TFunctions], {Mod, ModExportsStr},
+                     {TestMod, TestModExportsStr}, Matched) ->
+    FunctionStr = atom_to_list(Function),
+    %% Get matching Function in module, otherwise look in _tests module
+    NewMatch = case get_matching_export(FunctionStr, ModExportsStr) of
+                   [] ->
+                       {TestMod, get_matching_export(FunctionStr,
+                                                     TestModExportsStr)};
+                   MatchingExport ->
+                       {Mod, MatchingExport}
+               end,
+    case NewMatch of
+        {_, []} ->
+            get_matching_exports(TFunctions, {Mod, ModExportsStr},
+                                 {TestMod, TestModExportsStr}, Matched);
+        _ ->
+            get_matching_exports(TFunctions, {Mod, ModExportsStr},
+                                 {TestMod, TestModExportsStr},
+                                 [NewMatch|Matched])
+    end.
+get_matching_export(_FunctionStr, []) ->
+    [];
+get_matching_export(FunctionStr, [ExportStr|TExportsStr]) ->
+    case string:str(ExportStr, FunctionStr) of
+        1 ->
+            list_to_atom(ExportStr);
+        _ ->
+            get_matching_export(FunctionStr, TExportsStr)
+    end.
+get_beam_test_exports(ModuleStr) ->
+    FilePath = filename:join(eunit_dir(),
+                             string:concat(ModuleStr, ".beam")),
+    case filelib:is_regular(FilePath) of
+        true ->
+            {beam_file, _, Exports0, _, _, _} = beam_disasm:file(FilePath),
+            Exports1 = [FunName || {FunName, FunArity, _} <- Exports0,
+                                   FunArity =:= 0],
+            F = fun(FName) ->
+                        FNameStr = atom_to_list(FName),
+                        re:run(FNameStr, "_test(_)?") =/= nomatch
+                end,
+            lists:filter(F, Exports1);
+        _ ->
+            []
+    end.
+make_test_primitives(RawTests) ->
+    %% Use {test,M,F} and {generator,M,F} if at least R15B02. Otherwise,
+    %% use eunit_test:function_wrapper/2 fallback.
+    %% eunit_test:function_wrapper/2 was renamed to eunit_test:mf_wrapper/2
+    %% in R15B02; use that as >= R15B02 check.
+    %% TODO: remove fallback and use only {test,M,F} and {generator,M,F}
+    %% primitives once at least R15B02 is required.
+    {module, eunit_test} = code:ensure_loaded(eunit_test),
+    MakePrimitive = case erlang:function_exported(eunit_test, mf_wrapper, 2) of
+                        true -> fun eunit_primitive/3;
+                        false -> fun pre15b02_eunit_primitive/3
+                    end,
+    ?CONSOLE(" Running test function(s):~n", []),
+    F = fun({M, F2}, Acc) ->
+                ?CONSOLE(" ~p:~p/0~n", [M, F2]),
+                FNameStr = atom_to_list(F2),
+                NewFunction =
+                    case re:run(FNameStr, "_test_") of
+                        nomatch ->
+                            %% Normal test
+                            MakePrimitive(test, M, F2);
+                        _ ->
+                            %% Generator
+                            MakePrimitive(generator, M, F2)
+                    end,
+                [NewFunction|Acc]
+        end,
+    lists:foldl(F, [], RawTests).
+eunit_primitive(Type, M, F) ->
+    {Type, M, F}.
+pre15b02_eunit_primitive(test, M, F) ->
+    eunit_test:function_wrapper(M, F);
+pre15b02_eunit_primitive(generator, M, F) ->
+    {generator, eunit_test:function_wrapper(M, F)}.
+%%
+%% == run tests ==
+%%
+perform_eunit(Config, Tests) ->
+    EunitOpts = get_eunit_opts(Config),
+    %% Move down into ?EUNIT_DIR while we run tests so any generated files
+    %% are created there (versus in the source dir)
+    Cwd = rebar_utils:get_cwd(),
+    ok = file:set_cwd(?EUNIT_DIR),
+    EunitResult = (catch eunit:test(Tests, EunitOpts)),
+    %% Return to original working dir
+    ok = file:set_cwd(Cwd),
+    EunitResult.
+get_eunit_opts(Config) ->
+    %% Enable verbose in eunit if so requested..
+    BaseOpts = case rebar_log:is_verbose(Config) of
+                   true ->
+                       [verbose];
+                   false ->
+                       []
+               end,
+    BaseOpts ++ rebar_state:get(Config, eunit_opts, []).
+%%
+%% == reset_after_eunit ==
+%%
+status_before_eunit() ->
+    Apps = get_app_names(),
+    AppEnvs = [{App, application:get_all_env(App)} || App <- Apps],
+    {erlang:processes(), erlang:is_alive(), AppEnvs, ets:tab2list(ac_tab)}.
+get_app_names() ->
+    [AppName || {AppName, _, _} <- application:loaded_applications()].
+reset_after_eunit({OldProcesses, WasAlive, OldAppEnvs, _OldACs}) ->
+    IsAlive = erlang:is_alive(),
+    if not WasAlive andalso IsAlive ->
+            ?DEBUG("Stopping net kernel....\n", []),
+            erl_epmd:stop(),
+            _ = net_kernel:stop(),
+            pause_until_net_kernel_stopped();
+       true ->
+            ok
+    end,
+    OldApps = [App || {App, _} <- OldAppEnvs],
+    Apps = get_app_names(),
+    _ = [begin
+             _ = case lists:member(App, OldApps) of
+                     true -> ok;
+                     false -> application:stop(App)
+                 end,
+             ok = application:unset_env(App, K)
+         end || App <- Apps, App /= rebar,
+                {K, _V} <- application:get_all_env(App),
+                K =/= included_applications],
+    reconstruct_app_env_vars(Apps),
+    Processes = erlang:processes(),
+    _ = kill_extras(Processes -- OldProcesses),
+    ok.
+kill_extras(Pids) ->
+    %% Killing any of the procs below will either:
+    %% 1. Interfere with stuff that we don't want interfered with, or
+    %% 2. May/will force the 'kernel' app to shutdown, which *will*
+    %% interfere with rebar's ability To Do Useful Stuff(tm).
+    %% This list may require changes as OTP versions and/or
+    %% rebar use cases change.
+    KeepProcs = [cover_server, eunit_server,
+                 eqc, eqc_license, eqc_locked,
+                 %% inet_gethost_native is started on demand, when
+                 %% doing name lookups. It is under kernel_sup, under
+                 %% a supervisor_bridge.
+                 inet_gethost_native],
+    Killed = [begin
+                  Info = case erlang:process_info(Pid) of
+                             undefined -> [];
+                             Else -> Else
+                         end,
+                  Keep1 = case proplists:get_value(registered_name, Info) of
+                              undefined ->
+                                  false;
+                              Name ->
+                                  lists:member(Name, KeepProcs)
+                          end,
+                  Keep2 = case proplists:get_value(dictionary, Info) of
+                              undefined ->
+                                  false;
+                              Ds ->
+                                  case proplists:get_value('$ancestors', Ds) of
+                                      undefined ->
+                                          false;
+                                      As ->
+                                          lists:member(kernel_sup, As)
+                                  end
+                          end,
+                  if Keep1 orelse Keep2 ->
+                          ok;
+                     true ->
+                          ?DEBUG("Kill ~p ~p\n", [Pid, Info]),
+                          exit(Pid, kill),
+                          Pid
+                  end
+              end || Pid <- Pids],
+    case lists:usort(Killed) -- [ok] of
+        [] ->
+            ?DEBUG("No processes to kill\n", []),
+            [];
+        Else ->
+            lists:foreach(fun(Pid) -> wait_until_dead(Pid) end, Else),
+            Else
+    end.
+reconstruct_app_env_vars([App|Apps]) ->
+    CmdLine0 = proplists:get_value(App, init:get_arguments(), []),
+    CmdVars = [{list_to_atom(K), list_to_atom(V)} || {K, V} <- CmdLine0],
+    AppFile = (catch filename:join([code:lib_dir(App),
+                                    "ebin",
+                                    atom_to_list(App) ++ ".app"])),
+    AppVars = case file:consult(AppFile) of
+                  {ok, [{application, App, Ps}]} ->
+                      proplists:get_value(env, Ps, []);
+                  _ ->
+                      []
+              end,
+    %% App vars specified in config files override those in the .app file.
+    %% Config files later in the args list override earlier ones.
+    AppVars1 = case init:get_argument(config) of
+                   {ok, ConfigFiles} ->
+                       {App, MergedAppVars} = lists:foldl(fun merge_app_vars/2,
+                                                          {App, AppVars},
+                                                          ConfigFiles),
+                       MergedAppVars;
+                   error ->
+                       AppVars
+               end,
+    AllVars = CmdVars ++ AppVars1,
+    ?DEBUG("Reconstruct ~p ~p\n", [App, AllVars]),
+    lists:foreach(fun({K, V}) -> application:set_env(App, K, V) end, AllVars),
+    reconstruct_app_env_vars(Apps);
+reconstruct_app_env_vars([]) ->
+    ok.
+merge_app_vars(ConfigFile, {App, AppVars}) ->
+    File = ensure_config_extension(ConfigFile),
+    FileAppVars = app_vars_from_config_file(File, App),
+    Dict1 = dict:from_list(AppVars),
+    Dict2 = dict:from_list(FileAppVars),
+    Dict3 = dict:merge(fun(_Key, _Value1, Value2) -> Value2 end, Dict1, Dict2),
+    {App, dict:to_list(Dict3)}.
+ensure_config_extension(File) ->
+    %% config files must end with .config on disk but when specifying them
+    %% via the -config option the extension is optional
+    BaseFileName = filename:basename(File, ".config"),
+    DirName = filename:dirname(File),
+    filename:join(DirName, BaseFileName ++ ".config").
+app_vars_from_config_file(File, App) ->
+    case file:consult(File) of
+        {ok, [Env]} ->
+            proplists:get_value(App, Env, []);
+        _ ->
+            []
+    end.
+wait_until_dead(Pid) when is_pid(Pid) ->
+    Ref = erlang:monitor(process, Pid),
+    receive
+        {'DOWN', Ref, process, _Obj, Info} ->
+            Info
+    after 10*1000 ->
+            exit({timeout_waiting_for, Pid})
+    end;
+wait_until_dead(_) ->
+    ok.
+pause_until_net_kernel_stopped() ->
+    pause_until_net_kernel_stopped(10).
+pause_until_net_kernel_stopped(0) ->
+    exit(net_kernel_stop_failed);
+pause_until_net_kernel_stopped(N) ->
+    case node() of
+        'nonode@nohost' ->
+            ?DEBUG("Stopped net kernel.\n", []),
+            ok;
+        _ ->
+            timer:sleep(100),
+            pause_until_net_kernel_stopped(N - 1)
+    end.
diff --git a/src/rebar_utils.erl b/src/rebar_utils.erl
index c39bbfa..6dfbbed 100644
--- a/src/rebar_utils.erl
+++ b/src/rebar_utils.erl
@@ -39,6 +39,8 @@
          find_files/3,
          ensure_dir/1,
          beam_to_mod/1,
+         beam_to_mod/2,
+         erl_to_mod/1,
          beams/1,
          find_executable/1,
          expand_code_path/0,
@@ -356,6 +358,9 @@ expand_sh_flag(return_on_error) ->
      fun(_Command, Err) ->
              {error, Err}
      end};
+expand_sh_flag(abort_on_error) ->
+    {error_handler,
+     fun log_and_abort/2};
 expand_sh_flag({abort_on_error, Message}) ->
     {error_handler,
      log_msg_and_abort(Message)};
@@ -385,6 +390,12 @@ log_msg_and_abort(Message) ->
             ?ABORT(Message, [])
     end.
 
+-spec log_and_abort(string(), {integer(), string()}) -> no_return().
+log_and_abort(Command, {Rc, Output}) ->
+    ?ABORT("sh(~s)~n"
+          "failed with return code ~w and the following output:~n"
+          "~s~n", [Command, Rc, Output]).
+
 -spec debug_and_abort(string(), {integer(), string()}) -> no_return().
 debug_and_abort(Command, {Rc, Output}) ->
     ?DEBUG("sh(~s)~n"
@@ -404,9 +415,16 @@ sh_loop(Port, Fun, Acc) ->
             {error, {Rc, lists:flatten(lists:reverse(Acc))}}
     end.
 
+beam_to_mod(Dir, Filename) ->
+    [Dir | Rest] = filename:split(Filename),
+    list_to_atom(filename:basename(string:join(Rest, "."), ".beam")).
+
 beam_to_mod(Filename) ->
     list_to_atom(filename:basename(Filename, ".beam")).
 
+erl_to_mod(Filename) ->
+    list_to_atom(filename:rootname(filename:basename(Filename))).
+
 beams(Dir) ->
     filelib:fold_files(Dir, ".*\.beam\$", true,
                        fun(F, Acc) -> [F | Acc] end, []).