anchor.diff:             end),
       
       %% try to register the same name
  +    ?P("names -> try register (locally) another 'test' (and expect rejection)"),
       no = global:register_name(test, self()),
  +    ?P("names -> try register (on cp1) another 'test' (and expect rejection)"),
       no = rpc:call(Cp1, global, register_name, [test, self()]),
       
       %% let process exit, check that it is unregistered automatically
  +    ?P("names -> terminate the 'test' process"),
       exit_p(Pid),
   
  +    ?P("names -> verify 'test' process has been automatically unregistered"),
           ?UNTIL((undefined =:= global:whereis_name(test)) and
              (undefined =:= rpc:call(Cp1, global, whereis_name, [test])) and
              (undefined =:= rpc:call(Cp2, global, whereis_name, [test])) and
              (undefined =:= rpc:call(Cp3, global, whereis_name, [test]))),
       
       %% test re_register
  +    ?P("names -> start and register another process 'test'"),
       {Pid2, yes} = start_proc(test),
  +    ?P("names -> verify process 'test' has been registered"),
       ?UNTIL(Pid2 =:= rpc:call(Cp3, global, whereis_name, [test])),
       Pid3 = rpc:call(Cp3, ?MODULE, start_proc2, [test]),
       ?UNTIL(Pid3 =:= rpc:call(Cp3, global, whereis_name, [test])),
       Pid3 = global:whereis_name(test),
   
       %% test sending
  +    ?P("names -> test sending (from local)"),
       global:send(test, {ping, self()}),
       receive
   	{pong, Cp3} -> ok
  
positive.code: 	2000 -> ct:fail(timeout1)
      end,
  
      rpc:call(Cp1, global, send, [test, {ping, self()}]),
      receive
  	{pong, Cp3} -> ok
  
negative.code: %% Kill Pid2 and check that 'test' isn't registered.
  
  names(Config) when is_list(Config) ->
      ?TC_TRY(names, fun() -> do_names(Config) end).
  
  do_names(Config) ->
      ?P("names -> begin when"
         "~n   Nodes: ~p"
         "~n   Names: ~p",
         [nodes(),
          case net_adm:names() of
              {ok, N} ->
                  N;
              _ ->
                  "-"
          end]),
      Timeout = 30,
      ct:timetrap({seconds,Timeout}),
      ?P("names -> init high level trace"),
      init_high_level_trace(Timeout),
      ?P("names -> init condition"),
      init_condition(Config),
      ?P("names -> get registered names"),
      OrigNames = global:registered_names(),
  
      ?P("names -> start node cp1"),
      {ok, Cp1} = start_node(cp1, Config),
      ?P("names -> start node cp2"),
      {ok, Cp2} = start_node(cp2, Config),
      ?P("names -> start node cp3"),
      {ok, Cp3} = start_node(cp3, Config),
  
      ?P("names -> wait for ready net"),
      wait_for_ready_net(Config),
  
      %% start a proc and register it
      ?P("names -> start and register process 'test'"),
      {Pid, yes} = start_proc(test),
  
      %% test that it is registered at all nodes
      ?P("names -> verify process has been registered on all nodes"),
          ?UNTIL(begin
              (Pid =:= global:whereis_name(test)) and
              (Pid =:= rpc:call(Cp1, global, whereis_name, [test])) and
  