anchor.diff:  		      end),
   	     %% Check that the socket is not busy/closed...
   	     Error = after_send_timeout(AutoClose),
  -	     ?line {error,Error} = gen_tcp:send(A,<<"Hej">>),
  -	     ?line test_server:stop_node(RNode)
  +	     {error,Error} = gen_tcp:send(A,<<"Hej">>),
  +	     test_server:stop_node(RNode)
   	end,
       BasicFun(false),
       BasicFun(true),
       %% Check timeout length
  -   ?line  Self = self(),
  -   ?line  Pid = 
  -	spawn(fun() ->
  -		      {Loop,A,RNode} = setup_timeout_sink(1000, true),
  -		      {error,timeout} = 
  -			  Loop(fun() ->
  -				       Res = gen_tcp:send(A,<<1:10000>>),
  -				       %%erlang:display(Res),
  -				       Self ! Res,
  -				       Res
  -			       end),
  -		      test_server:stop_node(RNode)
  -	      end),		  
  -    ?line Diff = get_max_diff(),
  -    ?line io:format("Max time for send: ~p~n",[Diff]),
  -    ?line true = (Diff > 500) and (Diff < 1500),
  +    Self = self(),
  +    Pid = spawn(fun() ->
  +                        {Loop,A,RNode} = setup_timeout_sink(1000, true),
  +                        {error,timeout} = Loop(fun() ->
  +                                     Res = gen_tcp:send(A,<<1:10000>>),
  +                                     %%erlang:display(Res),
  +                                     Self ! Res,
  +                                     Res
  +                             end),
  +                        test_server:stop_node(RNode)
  +	      end),
  +    Diff = get_max_diff(),
  +    io:format("Max time for send: ~p~n",[Diff]),
  +    true = (Diff > 500) and (Diff < 1500),
       %% Let test_server slave die...
  -    ?line Mon = erlang:monitor(process, Pid),
  -    ?line receive {'DOWN',Mon,process,Pid,_} -> ok end,
  +    Mon = erlang:monitor(process, Pid),
  +    receive {'DOWN',Mon,process,Pid,_} -> ok end,
       %% Check that parallell writers do not hang forever
  -    ParaFun = 
  +    ParaFun =
   	fun(AutoClose) ->
  -		?line {Loop,A,RNode} = setup_timeout_sink(1000, AutoClose),
  +		{Loop,A,RNode} = setup_timeout_sink(1000, AutoClose),
   		SenderFun = fun() ->
  -				    {error,Error} = 
  +				    {error,Error} =
   					Loop(fun() ->
   						     gen_tcp:send(A, <<1:10000>>)
   					     end),
   				    Self ! {error,Error}
   			    end,
  -		?line spawn_link(SenderFun),
  -		?line spawn_link(SenderFun),
  -		?line receive 
  -			  {error,timeout} -> ok
  -		      after 10000 ->
  -			      ?line exit(timeout)
  -		      end,
  +		spawn_link(SenderFun),
  +		spawn_link(SenderFun),
  +                receive
  +                    {error,timeout} -> ok
  +                after 10000 ->
  +                          exit(timeout)
  +                end,
   		NextErr = after_send_timeout(AutoClose),
  -		?line receive
  -			  {error,NextErr} -> ok
  -		      after 10000 ->
  -			      ?line exit(timeout)
  -		      end,
  -		?line {error,NextErr} = gen_tcp:send(A,<<"Hej">>),
  -		?line test_server:stop_node(RNode)
  +                receive
  +                    {error,NextErr} -> ok
  +                after 10000 ->
  +                          exit(timeout)
  +                end,
  +		{error,NextErr} = gen_tcp:send(A,<<"Hej">>),
  +		test_server:stop_node(RNode)
   	end,
       ParaFun(false),
       ParaFun(true),
       ok.
  +
   mad_sender(S) ->
       {_, _, USec} = now(),
       case gen_tcp:send(S, integer_to_list(USec)) of
  
positive.code:      "to the other end."];
  close_with_pending_output(suite) -> [];
  close_with_pending_output(Config) when is_list(Config) ->
      ?line {ok, L} = gen_tcp:listen(0, [binary, {active, false}]),
      ?line {ok, {_, Port}} = inet:sockname(L),
      ?line Packets = 16,
      ?line Total = 2048*Packets,
      case start_remote(close_pending) of
  	{ok, Node} ->
  	    ?line {ok, Host} = inet:gethostname(),
  	    ?line spawn_link(Node, ?MODULE, sender, [Port, Packets, Host]),
  	    ?line {ok, A} = gen_tcp:accept(L),
  	    ?line case gen_tcp:recv(A, Total) of
  		      {ok, Bin} when byte_size(Bin) == Total ->
  			  gen_tcp:close(A),
  			  gen_tcp:close(L);
  		      {ok, Bin} ->
  			  ?line test_server:fail({small_packet, 
                                                    byte_size(Bin)});
  		      Error ->
  			  ?line test_server:fail({unexpected, Error})
  		  end,
  	    ok;
  	{error, no_remote_hosts} ->
  	    {skipped,"No remote hosts"};
  	{error, Other} ->
  	    ?line ?t:fail({failed_to_start_slave_node, Other})
      end.
  
  sender(Port, Packets, Host) ->
  
negative.code: killing_acceptor(doc) ->
      ["Check that single acceptor behaves as expected when killed"];
  killing_acceptor(Config) when is_list(Config) ->    
      {ok,LS}=gen_tcp:listen(0,[]),
      Pid = spawn(fun() -> erlang:display({accepted,self(),gen_tcp:accept(LS)}) end),
      receive after 100 -> ok
      end,
      {ok,L1} = prim_inet:getstatus(LS),
      true = lists:member(accepting, L1),
      exit(Pid,kill),
      receive after 100 -> ok
      end,
      {ok,L2} = prim_inet:getstatus(LS),
      false  = lists:member(accepting, L2),
      ok.
  
  killing_multi_acceptors(suite) ->
  