anchor.diff:  
   %% Tests the process_info/2 BIF.
   t_process_info(Config) when is_list(Config) ->
  -    ?line [] = process_info(self(), registered_name),
  -    ?line register(my_name, self()),
  -    ?line {registered_name, my_name} = process_info(self(), registered_name),
  -    ?line {status, running} = process_info(self(), status),
  -    ?line {min_heap_size, 233} = process_info(self(), min_heap_size),
  +    [] = process_info(self(), registered_name),
  +    register(my_name, self()),
  +    {registered_name, my_name} = process_info(self(), registered_name),
  +    {status, running} = process_info(self(), status),
  +    {min_heap_size, 233} = process_info(self(), min_heap_size),
       {min_bin_vheap_size,46422} = process_info(self(), min_bin_vheap_size),
  -    ?line {current_function,{?MODULE,t_process_info,1}} =
  +    {current_function,{?MODULE,t_process_info,1}} =
   	process_info(self(), current_function),
  -    ?line {current_function,{?MODULE,t_process_info,1}} =
  +    {current_function,{?MODULE,t_process_info,1}} =
   	apply(erlang, process_info, [self(),current_function]),
   
       %% current_location and current_stacktrace
  
positive.code: process_info_lock_reschedule3(Config) when is_list(Config) ->
      %% We need a process that is running and an item that requires
      %% process_info to take the main process lock.
      ?line Target1 = spawn_link(fun tok_loop/0),
      ?line Name1 = process_info_lock_reschedule_running,
      ?line register(Name1, Target1),
      ?line Target2 = spawn_link(fun () -> receive after infinity -> ok end end),
      ?line Name2 = process_info_lock_reschedule_waiting,
      ?line register(Name2, Target2),
      ?line PI = fun(N) ->
  		       case N rem 10 of
  			   0 -> erlang:yield();
  			   _ -> ok
  		       end,
  		       ?line do_pi_msg_len({proc, Target1},
  					   {arg, message_queue_len})
  	       end,
      ?line many_args(100000,1,2,3,4,5,6,7,8,9),
      ?line lists:foreach(PI, lists:seq(1,1000000)),
      %% Make sure Target1 still is willing to "tok loop"
      ?line case process_info(Target1, status) of
  	      {status, OkStatus} when OkStatus == runnable;
  				      OkStatus == running;
  				      OkStatus == garbage_collecting ->
  		  ?line unlink(Target1),
  		  ?line unlink(Target2),
  		  ?line exit(Target1, bang),
  		  ?line exit(Target2, bang),
  		  ?line OkStatus;
  	      {status, BadStatus} ->
  		  ?line ?t:fail(BadStatus)
  	  end.
  
  process_status_exiting(Config) when is_list(Config) ->
      %% Make sure that erts_debug:get_internal_state({process_status,P})
      %% returns exiting if it is in status P_EXITING.
      ?line erts_debug:set_internal_state(available_internal_state,true),
      ?line Prio = process_flag(priority, max),
      ?line P = spawn_opt(fun () -> receive after infinity -> ok end end,
  			[{priority, normal}]),
      ?line erlang:yield(),
      %% The tok_loop processes are here to make it hard for the exiting
      %% process to be scheduled in for exit...
      ?line TokLoops = lists:map(fun (_) ->
  				       spawn_opt(fun tok_loop/0,
  						 [link,{priority, high}])
  			       end,
  			       lists:seq(1, erlang:system_info(schedulers_online))),
      ?line exit(P, boom),
      ?line wait_until(
  	    fun () ->
  		    exiting =:= erts_debug:get_internal_state({process_status,P})
  	    end),
      ?line lists:foreach(fun (Tok) -> unlink(Tok), exit(Tok,bang) end, TokLoops),
      ?line process_flag(priority, Prio),
      ?line ok.
  
  otp_4725(Config) when is_list(Config) ->
      ?line Tester = self(),
      ?line Ref1 = make_ref(),
      ?line Pid1 = spawn_opt(fun () ->
  				   Tester ! {Ref1, process_info(self())},
  				   receive
  				       Ref1 -> bye
  				   end
  			   end,
  			   [link,
  			    {priority, max},
  			    {fullsweep_after, 600}]),
      ?line receive
  	      {Ref1, ProcInfo1A} ->
  		  ?line ProcInfo1B = process_info(Pid1),
  		  ?line Pid1 ! Ref1,
  		  ?line check_proc_infos(ProcInfo1A, ProcInfo1B)
  	  end,
      ?line Ref2 = make_ref(),
      ?line Pid2 = spawn_opt(fun () ->
  				   Tester ! {Ref2, process_info(self())},
  				   receive
  				       Ref2 -> bye
  				   end
  			   end,
  			   []),
      ?line receive
  	      {Ref2, ProcInfo2A} ->
  		  ?line ProcInfo2B = process_info(Pid2),
  		  ?line Pid2 ! Ref2,
  		  ?line check_proc_infos(ProcInfo2A, ProcInfo2B)
  	  end,
      ?line ok.
  
  check_proc_infos(A, B) ->
      ?line IC = lists:keysearch(initial_call, 1, A),
      ?line IC = lists:keysearch(initial_call, 1, B),
  
      ?line L = lists:keysearch(links, 1, A),
      ?line L = lists:keysearch(links, 1, B),
  
      ?line D = lists:keysearch(dictionary, 1, A),
      ?line D = lists:keysearch(dictionary, 1, B),
  
      ?line TE = lists:keysearch(trap_exit, 1, A),
      ?line TE = lists:keysearch(trap_exit, 1, B),
  
      ?line EH = lists:keysearch(error_handler, 1, A),
      ?line EH = lists:keysearch(error_handler, 1, B),
  
      ?line P = lists:keysearch(priority, 1, A),
      ?line P = lists:keysearch(priority, 1, B),
  
      ?line GL = lists:keysearch(group_leader, 1, A),
      ?line GL = lists:keysearch(group_leader, 1, B),
  
      ?line GC = lists:keysearch(garbage_collection, 1, A),
      ?line GC = lists:keysearch(garbage_collection, 1, B),
  
      ?line ok.
  
  
  %% Dummies.
  
negative.code: garbage_collect(doc) -> [];
  garbage_collect(suite) -> [];
  garbage_collect(Config) when is_list(Config) ->
      Prio = process_flag(priority, high),
      true = erlang:garbage_collect(),
      
      TokLoopers = lists:map(fun (_) ->
  		spawn_opt(fun tok_loop/0, [{priority, low}, link])
  	end, lists:seq(1, 10)),
  
      lists:foreach(fun (Pid) ->
  		Mon = erlang:monitor(process, Pid),
  		DownBefore = receive
  		    {'DOWN', Mon, _, _, _} ->
  			true
  		after 0 ->
  			false
  		end,
  		GC = erlang:garbage_collect(Pid),
  		DownAfter = receive
  		    {'DOWN', Mon, _, _, _} ->
  			true
  		after 0 ->
  			false
  		end,
  		true = erlang:demonitor(Mon),
  		case {DownBefore, DownAfter} of
  		    {true, _} -> false = GC;
  		    {false, false} -> true = GC;
  		    _ -> GC
  		end
  	end, processes()),
  
      lists:foreach(fun (Pid) ->
  		unlink(Pid),
  		exit(Pid, bang)
  	end, TokLoopers),
      process_flag(priority, Prio),
      ok.
  
  process_info_messages(doc) ->
      ["This used to cause the nofrag emulator to dump core"];
  process_info_messages(suite) ->
      [];
  process_info_messages(Config) when is_list(Config) ->
      process_info_messages_test(),
      ok.
  
  process_info_messages_loop(0) -> ok;
  process_info_messages_loop(N) -> process_info_messages_loop(N-1).
  