anchor.diff:  
   
   test_framework_used(FileName) ->
  -    case refac_epp_dodger:parse_file(FileName, []) of 
  -	{ok, Forms}->
  -	    Strs =lists:flatmap(fun(F) ->
  -					case refac_syntax:type(F) of 
  -					    attribute ->
  -						Name = refac_syntax:attribute_name(F),
  -						Args = refac_syntax:attribute_arguments(F),
  -						case refac_syntax:type(Name) of 
  -						    atom-> 
  -							AName = refac_syntax:atom_value(Name),
  -							case (AName==include) orelse (AName==include_lib) of
  -							    true ->
  -								lists:flatmap(fun(A)-> case A of 
  -											   {string, _, Str} -> [Str];
  -											   _ -> []
  -										       end
  -									      end, Args);
  -							   _ -> []
  -						       end;
  -						   _ -> []
  -					       end;
  -					   _ -> []
  +    case refac_epp_dodger:parse_file(FileName, []) of
  +      {ok, Forms} ->
  +	  Strs = lists:flatmap(fun (F) ->
  +				       case refac_syntax:type(F) of
  +					 attribute ->
  +					     Name = refac_syntax:attribute_name(F),
  +					     Args = refac_syntax:attribute_arguments(F),
  +					     case refac_syntax:type(Name) of
  +					       atom ->
  +						   AName = refac_syntax:atom_value(Name),
  +						   case AName == include orelse AName == include_lib of
  +						     true ->
  +							 lists:flatmap(fun (A) -> case A of
  +										    {string, _, Str} -> [Str];
  +										    _ -> []
  +										  end
  +								       end, Args);
  +						     _ -> []
  +						   end;
  +					       _ -> []
  +					     end;
  +					 _ -> []
   				       end
  -			       end,Forms),
  -	    Eunit = lists:any(fun(S) -> lists:suffix("eunit.hrl", S) end,Strs),
  -	    EQC = lists:any(fun(S) -> lists:suffix("eqc.hrl", S) end, Strs),
  -	    EQC_STATEM  =lists:any(fun(S) -> lists:suffix("eqc_statem.hrl", S) end, Strs),
  -	    TestSever = lists:suffix(FileName, "_SUITE.erl") and 
  -		lists:any(fun(S) -> lists:suffix("test_server.hrl", S) end, Strs),
  -	    CommonTest= lists:suffix(FileName, "_SUITE.erl") and 
  -		lists:any(fun(S) -> lists:suffix("ct.hrl", S) end, Strs),
  -	    lists:flatmap(fun({F, V}) -> case V of 
  -					     true -> [F];
  -					     _ -> []
  -					 end
  -			  end,[{eunit, Eunit}, {eqc, EQC}, {eqc_statem, EQC_STATEM}, 
  -			       {testserver, TestSever}, {commontest, CommonTest}]);
  -	_ -> []
  +			       end, Forms),
  +	  Eunit = lists:any(fun (S) -> lists:suffix("eunit.hrl", S) end, Strs),
  +	  EQC = lists:any(fun (S) -> lists:suffix("eqc.hrl", S) end, Strs),
  +	  EQC_STATEM = lists:any(fun (S) -> lists:suffix("eqc_statem.hrl", S) end, Strs),
  +	  TestSever = lists:suffix(FileName, "_SUITE.erl") and
  +			lists:any(fun (S) -> lists:suffix("test_server.hrl", S) end, Strs),
  +	  CommonTest = lists:suffix(FileName, "_SUITE.erl") and
  +			 lists:any(fun (S) -> lists:suffix("ct.hrl", S) end, Strs),
  +	  lists:flatmap(fun ({F, V}) -> case V of
  +					  true -> [F];
  +					  _ -> []
  +					end
  +			end, [{eunit, Eunit}, {eqc, EQC}, {eqc_statem, EQC_STATEM},
  +			      {testserver, TestSever}, {commontest, CommonTest}]);
  +      _ -> []
       end.
      
       
  
positive.code: %%@doc Build a function call graph out of the Erlang files contained in the given directories.
  
  
  -spec(build_scc_callgraph(DirList::[dir()]) -> #callgraph{}).
  build_scc_callgraph(DirList) ->
      CallerCalleesWithDef = build_callercallee_callgraph(DirList),
      CallerCallees =  lists:map(fun ({{Caller, _CallerDef}, Callee}) -> {Caller, Callee} end, CallerCalleesWithDef),
      {Sccs, E} = refac_callgraph:construct(CallerCalleesWithDef),
      #callgraph{callercallee = CallerCallees, scc_order = Sccs, external_calls = E}.
      
     
  
  -spec(build_callercallee_callgraph/1::([dir()]) -> [{{{atom(), atom(), integer()}, syntaxTree()}, [{atom(), atom(), integer()}]}]).
  build_callercallee_callgraph(SearchPaths) ->
      Files = refac_util:expand_files(SearchPaths, ".erl"),
      lists:append(lists:map(fun(FileName) ->
  				   {ok, {AnnAST, Info}} = refac_util:parse_annotate_file(FileName, true, SearchPaths),  %% should this be false?
  				   do_build_callgraph(FileName, {AnnAST, Info})
  			   end, Files)).
      
     
  -spec(do_build_callgraph/2::(filename(), {syntaxTree(),moduleInfo()}) -> 
      [{{{atom(), atom(), integer()}, syntaxTree()}, [{atom(), atom(), integer()}]}]).
  
  do_build_callgraph(FileName, {AnnAST, Info}) ->
      case lists:keysearch(module, 1, Info) of 
  	{value, {module, ModName}}  -> ModName;
  	_ -> ModName = list_to_atom(filename:basename(FileName, ".erl")),
  	     ModName
      end,
      F1 = fun (T, S) ->
  		 case refac_syntax:type(T) of
  		   function ->
  		       FunName = refac_syntax:data(refac_syntax:function_name(T)),
  		       Arity = refac_syntax:function_arity(T),
  		       Caller = {{ModName, FunName, Arity}, T},
  		       CalledFuns = called_funs(ModName, T),
  		       ordsets:add_element({Caller, CalledFuns}, S);
  		     _ -> S
  		 end
  	 end,
      lists:usort(refac_syntax_lib:fold(F1, [], AnnAST)).
  
  -spec(called_funs/2::(modulename(), syntaxTree()) ->[{modulename(), functionname, functionarity()}]).
  called_funs(ModName, Tree) ->
      HandleSpecialFuns = fun (Arguments, S) ->
  				case Arguments of
  				    [M, F, A] ->
  					case {refac_syntax:type(M), refac_syntax:type(F), refac_syntax:type(A)} of
  					    {atom, atom, list} ->
  						ModName1 = refac_syntax:atom_value(M),
  						FunName = refac_syntax:atom_value(F),
  						Arity = refac_syntax:list_length(A),
  						ordsets:add_element({ModName1, FunName, Arity}, S);
  					    _ -> S
  					end;
  				    _ -> S
  				end
  			end,
      F = fun (T, S) ->
  		case refac_syntax:type(T) of
  		    application ->
  			Operator = refac_syntax:application_operator(T),
  			Arguments = refac_syntax:application_arguments(T),
  			case lists:keysearch(fun_def, 1, refac_syntax:get_ann(Operator)) of 
  			    {value, {fun_def, {M, F, A, _, _}}} -> 
  				S1 =ordsets:add_element({M, F, A}, S),
  				case {M, F, A} of 
  				    {erlang, apply, 3} -> HandleSpecialFuns(Arguments, S1);
  				    _ -> S1
  				end;
  			    _ -> S
  			end;
  		    arity_qualifier ->
  			Fun = refac_syntax:arity_qualifier_body(T),
  			A = refac_syntax:arity_qualifier_argument(T),
  			case {refac_syntax:type(Fun), refac_syntax:type(A)} of
  			    {atom, integer} ->
  				FunName = refac_syntax:atom_value(Fun),
  				Arity = refac_syntax:integer_value(A),
  				ordsets:add_element({ModName, FunName, Arity}, S);
  			    {module_qualifier, integer} ->
  			        M = refac_syntax:module_qualifier_argument(T),
  				F = refac_syntax:module_qualifier_body(T),
  				case (refac_syntax:type(M) == atom) and (refac_syntax:type(F)==atom) of
  				    true -> {refac_syntax:atom_value(M), refac_syntax:atom_value(F), refac_syntax:integer_value(A)};
  				    _ -> S
  				end;
  			    _ -> S
  			end;
  		    _ -> S
  		end
  	end,
      lists:usort(refac_syntax_lib:fold(F, [], Tree)).
  
  
  %% =====================================================================
  %% @spec bifs_side_effect_table()->[{{atom(), atom(), integer()}, boolean()}]
  %% @doc The side effect table of BIFs.
  
negative.code: 		 true -> from_dets(local_side_effect_tab, SideEffectFile);
  		 _ -> ets:new(local_side_effect_tab, [set, public])
  	       end,
      #callgraph{callercallee = _CallerCallee, scc_order = Sccs, external_calls = _E} = wrangler_callgraph_server:build_scc_callgraph(FilesToAnalyse),
      build_side_effect_tab(Sccs, LocalPlt, LibPlt),
      to_dets(LocalPlt, SideEffectFile),
      dets:close(list_to_atom(LibSideEffectFile)),
  