anchor.diff:  
       ?line ok = wait_until(fun () ->
                                     {status, suspended}
  -                                      == process_info(P1, status)
  +                                      == process_info(P2, status)
                             end),
       ?line ok = wait_until(fun () ->
                                     {status, suspended}
  -                                      == process_info(P2, status)
  +                                      == process_info(P3, status)
                             end),
   
  -    ?line {current_function,
  -     {erts_code_purger,
  -      pending_purge_lambda,
  -      3}} = process_info(P0, current_function),
       ?line {current_function,
        {erts_code_purger,
         pending_purge_lambda,
  
positive.code:      {erts_code_purger,
        pending_purge_lambda,
        3}} = process_info(P2, current_function),
  
      case Type of
  	code_there ->
  
negative.code: 
      case Type of
  	code_gone ->
              ?line {undef, _} = wait_for_down(P1,M1),
              ?line {undef, _} = wait_for_down(P2,M2),
              ?line {undef, _} = wait_for_down(P3,M3);
  	_ ->
              ?line completed = wait_for_down(P1,M1),
              ?line completed = wait_for_down(P2,M2),
              ?line completed = wait_for_down(P3,M3),
  	    catch erlang:purge_module(my_code_test2),
  	    catch erlang:delete_module(my_code_test2),
  	    catch erlang:purge_module(my_code_test2)
      end,
      ok.
  
  wait_for_down(P,M) ->
      receive
          {'DOWN', M, process, P, Reason} ->
              Reason
      after 1000 ->
              timeout
      end.
  
  wait_until(Fun) ->
      wait_until(Fun, 20).
  