anchor.diff:  spawn(_Config) ->
   
       Tc = fun(Pid) ->
  -                 Pid ! fun() -> erlang:spawn(lists,seq,[1,10]), ok end
  +                 Pid ! fun() -> kill_me(erlang:spawn(lists,seq,[1,10])), ok end
            end,
   
       Expect =
  
positive.code: 
      Pid = erlang:spawn_link(fun() -> ServerFun(0, undefined) end),
  
  
      Tc = fun(N) ->
                   Pid ! {N, self()},
                   receive done -> ok after 1000 -> ct:fail(timeout) end,
  
negative.code:         _ ->
              tracer_test:load(DataDir)
      end,
      common_init_per_testcase(Config).
  
  common_init_per_testcase(Config) ->
      Killer = erlang:spawn(fun() -> killer_loop([]) end),
      register(killer_process, Killer),
      Config.
  
  end_per_testcase(TC, _Config) when TC =:= load; TC =:= reload ->
      purge(),
      exit(whereis(tracer_test_config), kill),
      kill_processes();
  end_per_testcase(_, _Config) ->
      purge(),
      kill_processes().
  
  kill_processes() ->
      killer_process ! {get_pids,self()},
      receive
          {pids_to_kill,Pids} -> ok
      end,
      _ = [begin
               case erlang:is_process_alive(P) of
                   true ->
                       io:format("Killing ~p\n", [P]);
                   false ->
                       ok
               end,
               erlang:unlink(P),
               exit(P, kill)
           end || P <- Pids],
      ok.
  
  killer_loop(Pids) ->
      receive
          {add_pid,Pid} ->
              killer_loop([Pid|Pids]);
          {get_pids,To} ->
              To ! {pids_to_kill,Pids}
      end.
  
  kill_me(Pid) ->
      killer_process ! {add_pid,Pid},
      Pid.
  
  %%% Test cases follow.
  
  load(_Config) ->
      purge(),
  