anchor.diff:  %% after the test is completed.
   cover_analyse(Dir,#cover{level=Analyse,mods=Modules,stop=Stop}) ->
       io:fwrite(user, "Cover analysing... ", []),
  -    DetailsFun =
  +    {ATFOk,ATFFail} =
   	case Analyse of
   	    details ->
   		case cover:export(filename:join(Dir,"all.coverdata")) of
   		    ok ->
  -			fun(M) ->
  -				OutFile = filename:join(Dir,
  -							atom_to_list(M) ++
  -							".COVER.html"),
  -				case cover:analyse_to_file(M,OutFile,[html]) of
  -				    {ok,_} ->
  -					{file,OutFile};
  -				    Error ->
  -					Error
  -				end
  -			end;
  +			{result,Ok1,Fail1} =
  +			    cover:analyse_to_file(Modules,[{outdir,Dir},html]),
  +			{lists:map(fun(OutFile) ->
  +					   M = list_to_atom(
  +						 filename:basename(
  +						   filename:rootname(OutFile,
  +								     ".COVER.html")
  +						  )
  +						),
  +					   {M,{file,OutFile}}
  +				   end, Ok1),
  +			lists:map(fun({Reason,M}) ->
  +					  {M,{error,Reason}}
  +				  end, Fail1)};
   		    Error ->
  -			fun(_) -> Error end
  +			{[],lists:map(fun(M) -> {M,Error} end, Modules)}
   		end;
   	    overview ->
   		case cover:export(filename:join(Dir,"all.coverdata")) of
   		    ok ->
  -			fun(_) -> undefined end;
  +			{[],lists:map(fun(M) -> {M,undefined} end, Modules)};
   		    Error ->
  -			fun(_) -> Error end
  +			{[],lists:map(fun(M) -> {M,Error} end, Modules)}
   		end
   	end,
  -    R = pmap2(
  -	  fun(M) ->
  -		  case cover:analyse(M,module) of
  -		      {ok,{M,{Cov,NotCov}}} ->
  -			  {M,{Cov,NotCov,DetailsFun(M)}};
  -		      Err ->
  -			  io:fwrite(user,
  -				    "\nWARNING: Analysis failed for ~w. Reason: ~p\n",
  -				    [M,Err]),
  -			  {M,Err}
  -		  end
  -	  end, Modules),
  +    {result,AOk,AFail} = cover:analyse(Modules,module),
  +    R = merge_analysis_results(AOk,ATFOk++ATFFail,[]) ++
  +	[{M,{error,Reason}} || {Reason,M} <- AFail],
  +
       io:fwrite(user, "done\n\n", []),
   
       case Stop of
  
positive.code:     end,
      R.
  
  pmap2(Fun,List) ->
      Collector = self(),
      Pids = lists:map(fun(E) ->
  			     spawn(fun() ->
  					   Collector ! {res,self(),Fun(E)}
  				   end)
  		     end, List),
      lists:map(fun(Pid) ->
  		      receive
  			  {res,Pid,Res} ->
  			      Res
  		      end
  	      end, Pids).
  
  do_cover_for_node(Node,CoverFunc) ->
      do_cover_for_node(Node,CoverFunc,true).
  
negative.code: 
  do_cover_compile(Modules) ->
      cover:start(),
      Sticky = prepare_cover_compile(Modules,[]),
      R = cover:compile_beam(Modules),
      [warn_compile(Error) || Error <- R,element(1,Error)=/=ok],
      [code:stick_mod(M) || M <- Sticky],
      ok.
  
  warn_compile({error,{Reason,Module}}) ->
      io:fwrite("\nWARNING: Could not cover compile ~ts: ~p\n",
  	      [Module,{error,Reason}]).
  
  %% Make sure all modules are loaded and unstick if sticky
  prepare_cover_compile([M|Ms],Sticky) ->
      case {code:is_sticky(M),code:is_loaded(M)} of
  	{true,_} ->
  	    code:unstick_mod(M),
  	    prepare_cover_compile(Ms,[M|Sticky]);
  	{false,false} ->
  	    case code:load_file(M) of
  		{module,_} ->
  		    prepare_cover_compile([M|Ms],Sticky);
  		Error ->
  		    io:fwrite("\nWARNING: Could not load ~w: ~p\n",[M,Error]),
  		    prepare_cover_compile(Ms,Sticky)
  	    end;
  	{false,_} ->
  	    prepare_cover_compile(Ms,Sticky)
      end;
  prepare_cover_compile([],Sticky) ->
      Sticky.
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %% cover_analyse(Dir,#cover{level=Analyse,mods=Modules,stop=Stop) ->
  