anchor.diff:      ParaFun(false),
       ParaFun(true),
       ok.
  +mad_sender(S) ->
  +    {_, _, USec} = now(),
  +    case gen_tcp:send(S, integer_to_list(USec)) of
  +        ok ->
  +            mad_sender(S);
  +        Err ->
  +            Err
  +    end.
  +
  +
  +flush() ->
  +    receive
  +	_X ->
  +	    %erlang:display(_X),
  +	    flush()
  +    after 0 ->
  +	    ok
  +    end.
  +
  +send_timeout_active(suite) ->
  +    [];
  +send_timeout_active(doc) ->
  +    ["Test the send_timeout socket option for active sockets"];
  +send_timeout_active(Config) when is_list(Config) ->
  +    Dog = test_server:timetrap(test_server:seconds(20)),
  +    %% Basic
  +    BasicFun = 
  +	fun(AutoClose) ->
  +		?line {Loop,A,RNode,C} = setup_active_timeout_sink(1, AutoClose),
  +		inet:setopts(A, [{active, once}]),
  +		?line Mad = spawn_link(RNode,fun() -> mad_sender(C) end),
  +		?line {error,timeout} = 
  +		    Loop(fun() ->
  +				 receive
  +				     {tcp, Sock, _Data} ->
  +					 inet:setopts(A, [{active, once}]),
  +					 Res = gen_tcp:send(A,lists:duplicate(1000, $a)),
  +					 %erlang:display(Res),
  +					 Res;
  +				     Err ->
  +					 io:format("sock closed: ~p~n", [Err]),
  +					 Err
  +				 end
  +			 end),
  +		unlink(Mad),
  +		exit(Mad,kill),
  +		?line test_server:stop_node(RNode)
  +	end,
  +    BasicFun(false),
  +    flush(),
  +    BasicFun(true),
  +    flush(),
  +    test_server:timetrap_cancel(Dog),
  +    ok.
   
   after_send_timeout(AutoClose) ->
       case AutoClose of
  
positive.code: 	 accept_timeouts_in_order/1,accept_timeouts_in_order2/1,
  	 accept_timeouts_in_order3/1,accept_timeouts_mixed/1, 
  	 killing_acceptor/1,killing_multi_acceptors/1,killing_multi_acceptors2/1,
  	 several_accepts_in_one_go/1,active_once_closed/1, send_timeout/1, 
  	 otp_7731/1, zombie_sockets/1, otp_7816/1, otp_8102/1]).
  
  %% Internal exports.
  
negative.code:     {Loop,A}.
      
  setup_timeout_sink(Timeout, AutoClose) ->
      ?line Dir = filename:dirname(code:which(?MODULE)),
      ?line {ok,R} = test_server:start_node(test_default_options_slave,slave,
  				       [{args,"-pa " ++ Dir}]),    
      ?line Host = list_to_atom(lists:nth(2,string:tokens(atom_to_list(node()),"@"))),
      ?line {ok, L} = gen_tcp:listen(0, [{active,false},{packet,2},
  				 {send_timeout,Timeout},
  				 {send_timeout_close,AutoClose}]),
      ?line Fun = fun(F) -> 
  		  receive 
  		      {From,X} when is_function(X) -> 
  			  From ! {self(),X()}, F(F); 
  		      die -> ok 
  		  end 
  	  end, 
      ?line Pid =  rpc:call(R,erlang,spawn,[fun() -> Fun(Fun) end]),
      ?line {ok, Port} = inet:port(L),
      ?line Remote = fun(Fu) -> 
  		     Pid ! {self(), Fu}, 
  		     receive {Pid,X} -> X 
  		     end 
  	     end,
      ?line {ok, C} = Remote(fun() -> 
  			     gen_tcp:connect(Host,Port,
  					     [{active,false},{packet,2}]) 
  		     end),
      ?line {ok,A} = gen_tcp:accept(L),
      ?line gen_tcp:send(A,"Hello"),
      ?line {ok, "Hello"} = Remote(fun() -> gen_tcp:recv(C,0) end),
      ?line Loop2 = fun(_,_,0) -> 
  		    {failure, timeout}; 
  	       (L2,F2,N) -> 
  		    Ret = F2(),
  