anchor.diff:              IsAvail
       end.
   
  -cover_init(_Config) ->
  +perform_cover(Config, BeamFiles) ->
  +    perform_cover(rebar_config:get(Config, cover_enabled, false), Config, BeamFiles).
  +
  +perform_cover(false, _Config, _BeamFiles) ->
  +    ok;
  +perform_cover(true, Config, BeamFiles) ->
  +    perform_cover(Config, BeamFiles, rebar_config:get_global(suite, undefined));
  +perform_cover(Config, BeamFiles, undefined) ->
  +    cover_analyze(Config, BeamFiles);
  +perform_cover(Config, _BeamFiles, Suite) ->
  +    cover_analyze(Config, [filename:join([?EUNIT_DIR | string:tokens(Suite, ".")]) ++ ".beam"]).
  +
  +cover_analyze(_Config, []) ->
  +    ok;
  +cover_analyze(_Config, BeamFiles) ->
  +    Modules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- BeamFiles],
  +    %% Generate coverage info for all the cover-compiled modules
  +    Coverage = [cover_analyze_mod(M) || M <- Modules],
  +
  +    %% Write index of coverage info
  +    cover_write_index(lists:sort(Coverage)),
  +
  +    %% Write coverage details for each file
  +    [{ok, _} = cover:analyze_to_file(M, cover_file(M), [html]) || {M, _, _} <- Coverage],
  +
  +    Index = filename:join([rebar_utils:get_cwd(), ?EUNIT_DIR, "index.html"]),
  +    ?CONSOLE("Cover analysis: ~s\n", [Index]).
  +
  +cover_init(false, _BeamFiles) ->
  +    ok;
  +cover_init(true, BeamFiles) ->
       %% Make sure any previous runs of cover don't unduly influence
       cover:reset(),
   
       ?INFO("Cover compiling ~s\n", [rebar_utils:get_cwd()]),
   
  -    case cover:compile_beam_directory(?EUNIT_DIR) of
  -        {error, Reason2} ->
  -            ?ERROR("Cover compilation failed: ~p\n", [Reason2]),
  +    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;
  -        Modules ->
  +        _ ->
  +            %% 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
  -            [?CONSOLE("Cover compilation warning: ~p", [Desc]) || {error, Desc} <- Modules],
  -
  -            %% Identify the modules that were compiled successfully
  -            case [ M || {ok, M} <- Modules] of
  -                [] ->
  -                    %% No modules compiled successfully...fail
  -                    ?ERROR("Cover failed to compile any modules; aborting.\n", []),
  -                    ?FAIL;
  -                _ ->
  -                    %% At least one module compiled successfully
  -                    ok
  -            end
  -    end.
  -
  -cover_analyze(_Config, []) ->
  -    ok;
  -cover_analyze(_Config, Modules) ->
  -    %% Generate coverage info for all the cover-compiled modules
  -    Coverage = [cover_analyze_mod(M) || M <- Modules],
  -
  -    %% Write index of coverage info
  -    cover_write_index(lists:sort(Coverage)),
  -
  -    %% Write coverage details for each file
  -    [{ok, _} = cover:analyze_to_file(M, cover_file(M), [html]) || {M, _, _} <- Coverage],
  -
  -    Index = filename:join([rebar_utils:get_cwd(), ?EUNIT_DIR, "index.html"]),
  -    ?CONSOLE("Cover analysis: ~s\n", [Index]).
  -
  +            [?CONSOLE("Cover compilation warning for ~p: ~p", [Beam, Desc]) || {Beam, {error, Desc}} <- Compiled]
  +    end,
  +    ok;
  +cover_init(Config, BeamFiles) ->
  +    cover_init(rebar_config:get(Config, cover_enabled, false), BeamFiles).
   
   cover_analyze_mod(Module) ->
       case cover:analyze(Module, coverage, module) of
  
positive.code: cover_file(Module) ->
      filename:join([?EUNIT_DIR, atom_to_list(Module) ++ ".COVER.html"]).
  
  
  percentage(Cov, NotCov) ->
      trunc((Cov / (Cov + NotCov)) * 100).
  
negative.code:     %% 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.
      BeamFiles = rebar_utils:beams(?EUNIT_DIR),
      Modules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- BeamFiles],
  
      cover_init(Config, BeamFiles),
      EunitResult = perform_eunit(Config, Modules),
      perform_cover(Config, BeamFiles),
  
      case EunitResult of
          ok ->
              ok;
          _ ->
              ?CONSOLE("One or more eunit tests failed.~n", []),
              ?FAIL
      end,
      ok.
  
  clean(_Config, _File) ->
      rebar_file_utils:rm_rf(?EUNIT_DIR).
  
  %% ===================================================================
  %% Internal functions
  %% ===================================================================
  
  perform_eunit(Config, Modules) ->
      %% suite defined, so only specify the module that relates to the
      %% suite (if any)
      Suite = rebar_config:get_global(suite, undefined),
      EunitOpts = get_eunit_opts(Config),
  
      OrigEnv = set_proc_env(),
      EunitResult = perform_eunit(EunitOpts, Modules, Suite),
      restore_proc_env(OrigEnv),
      EunitResult.
  
  perform_eunit(EunitOpts, Modules, undefined) ->
      (catch eunit:test(Modules, EunitOpts));
  perform_eunit(EunitOpts, _Modules, Suite) ->
      (catch eunit:test(list_to_atom(Suite), EunitOpts)).
  
  set_proc_env() ->
      %% Save current code path and then prefix ?EUNIT_DIR on it so that our modules
      %% are found there
      CodePath = code:get_path(),
      true = code:add_patha(?EUNIT_DIR),
  
      %% 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(),
      file:set_cwd(?EUNIT_DIR),
      {CodePath, Cwd}.
  
  restore_proc_env({CodePath, Cwd}) ->
      %% Return to original working dir
      file:set_cwd(Cwd),
      %% Restore code path
      true = code:set_path(CodePath).
  
  get_eunit_opts(Config) ->
      %% Enable verbose in eunit if so requested..
      BaseOpts = case rebar_config:is_verbose() of
                     true ->
                         [verbose];
                     false ->
                         []
                 end,
  
      BaseOpts ++ rebar_config:get_list(Config, eunit_opts, []).
  
  eunit_config(Config) ->
      EqcOpts = case is_quickcheck_avail() of
                    true ->
                        [{d, 'EQC'}];
                    false ->
                        []
                end,
  
      ErlOpts = rebar_config:get_list(Config, erl_opts, []),
      EunitOpts = rebar_config:get_list(Config, eunit_compile_opts, []),
  