anchor.diff:      ok.
   
   wait_for_ready_net(Config) ->
  -    wait_for_ready_net(?NODES, Config).
  +    {Pid, MRef} = spawn_monitor(fun() ->
  +                                        wait_for_ready_net(?NODES, Config)
  +                                end),
  +    wait_for_ready_net_loop(Pid, MRef).
  +
  +wait_for_ready_net_loop(Pid, MRef) ->
  +    receive
  +        {'DOWN', MRef, process, Pid, Info} ->
  +            ?P("wait-for-ready-net process terminated: "
  +               "~n      ~p", [Info]),
  +            ok;
  +
  +        {'EXIT', ParentPid, {timetrap_timeout, _Timeout, _Stack}} ->
  +            ?P("wait-for-ready-net -> received timetrap timeout:"
  +               "~n   Regarding: ~p"
  +               "~n   Waiter:    ~p"
  +               "~n      Current Location: ~p"
  +               "~n      Mesages:          ~p",
  +               [ParentPid, Pid, pi(Pid, current_location), pi(Pid, messages)]),
  +            ct:fail("Timeout waiting for ready network")
  +
  +    end.
   
   wait_for_ready_net(Nodes0, Config) ->
       Nodes = lists:sort(Nodes0),
  -    io:format("wait_for_ready_net ~p~n", [Nodes]),
  +    ?P("wait_for_ready_net ->"
  +       "~n   Nodes: ~p", [Nodes]),
       ?UNTIL(begin
  -               lists:all(fun(N) -> Nodes =:= get_known(N) end, Nodes) and
  +               lists:all(fun(N) ->
  +                                 ?P("wait_for_ready_net -> "
  +                                    "get known (by global) for ~p", [N]),
  +                                 GNs = get_known(N),
  +                                 ?P("wait_for_ready_net -> verify same for ~p:"
  +                                    "~n   Global Known: ~p"
  +                                    "~n   Nodes:        ~p", [N, GNs, Nodes]),
  +                                 GRes = Nodes =:= GNs,
  +                                 ?P("wait_for_ready_net => ~p", [GRes]),
  +                                 GRes
  +                         end,
  +                         Nodes) and
   		   lists:all(fun(N) ->
  -				     LNs = rpc:call(N, erlang, nodes, []),
  -				     Nodes =:= lists:sort([N | LNs])
  -			     end, Nodes)
  +                                     ?P("wait_for_ready_net -> "
  +                                        "get erlang nodes for ~p", [N]),
  +				     case rpc:call(N, erlang, nodes, []) of
  +                                         RNs0 when is_list(RNs0) ->
  +                                             RNs = lists:sort([N | RNs0]),
  +                                             ?P("wait_for_ready_net -> "
  +                                                "verify same for ~p: "
  +                                                "~n   Remote nodes:  ~p"
  +                                                "~n   (Local) Nodes: ~p",
  +                                                [N, RNs, Nodes]),
  +                                             ERes = Nodes =:= RNs,
  +                                             ?P("wait_for_ready_net => ~p",
  +                                                [ERes]),
  +                                             ERes;
  +                                         BadRes ->
  +                                             ?P("failed get remote nodes: "
  +                                                "~n      ~p", [BadRes]),
  +                                             false
  +                                     end
  +			     end,
  +                             Nodes)
              end).
   
   get_known(Node) ->
  
positive.code: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  pi(Item) ->
      {Item, Val} = process_info(self(), Item),
      Val.
      
  
  
negative.code: cr(Res) ->
      receive
  	{resolve_called, Name, Node} ->
  	    ?P("resolve called: ~w ~w", [Name, Node]),
   	    cr(Res+1)
      after
  	0 -> Res
  