anchor.diff:  		      die -> ok
   		  end
   	  end,
  +    ?P("[sink] start remote runner process (on ~p)", [RNode]),
       Pid =  rpc:call(RNode, erlang, spawn, [fun() -> Fun(Fun) end]),
       {ok, Port} = inet:port(L),
       Remote = fun(Fu) ->
  
positive.code:                            {error, timeout} = timeout_sink_loop(Send)
  	      end),
      Diff = get_max_diff(),
      ?P("Max time for send: ~p~n",[Diff]),
      true = (Diff > 500) and (Diff < 1500),
  
      %% Wait for the process to die.
      ?P("wait (timeout checker) process death"),
      receive {'DOWN', Mon, process, Pid, _} -> ok end,
  
      %% Check that parallell writers do not hang forever
      ?P("parallell writers check wo autoclose"),
      send_timeout_para(false, RNode),
      ?P("parallell writers check w autoclose"),
      send_timeout_para(true, RNode),
  
      ?P("stop (slave) node"),
  
negative.code: 			{error,Error} = timeout_sink_loop(Send),
  			Self ! {error,Error}
  		end,
      ?P("[para] spawn process 1 with sender fun"),
      spawn_link(SenderFun),
      ?P("[para] spawn process 2 with sender fun"),
      spawn_link(SenderFun),
  
      ?P("[para] await sender timeout"),
      receive
  	{error, timeout} ->
              ?P("[para] timeout received"),
              ok
      after 10000 ->
              ?P("[para] UNEXPECTED timeout(1,~w)", [AutoClose]),
  	    exit({timeout, AutoClose})
      end,
  
      ?P("await sender error"),
      receive
  	{error, Error_1} ->
              ?P("[para] error (~p) received", [Error_1]),
              after_send_timeout(AutoClose, Error_1)
      after 10000 ->
              ?P("[para] UNEXPECTED timeout(2,~w)", [AutoClose]),
  	    exit({timeout, AutoClose})
      end,
  
      {error,Error_2} = gen_tcp:send(A, <<"Hej">>),
      after_send_timeout(AutoClose, Error_2),
      ?P("[para] done"),    
      ok.
  
  
  