anchor.diff:      ?P("await (timeout checker) process death"),
       receive {'DOWN', Mon, process, Pid, _} -> ok end,
   
  +    ?P("done"),
  +    ok.
  +
  +%% Test the send_timeout socket option.
  +send_timeout_para_wo_autoclose(Config) when is_list(Config) ->
  +    Pre  = fun() ->
  +                   Dir = filename:dirname(code:which(?MODULE)),
  +                   ?P("create node"),
  +                   {ok, RNode} = ?START_NODE(?UNIQ_NODE_NAME, "-pa " ++ Dir),
  +                   RNode
  +           end,
  +    Case = fun(Node) -> do_send_timeout_para_wo_autoclose(Config, Node) end,
  +    Post = fun(Node) ->
  +                   ?P("stop node ~p", [Node]),
  +                   ?STOP_NODE(Node)
  +           end,
  +    ?TC_TRY(?FUNCTION_NAME, Pre, Case, Post).
  +
  +do_send_timeout_para_wo_autoclose(Config, RNode) ->
  +    ?P("begin"),
  +    {TslTimeout, SndTimeout, BinData, SndBuf} = send_timeout_cfg(Config),
  +
       %% Check that parallel writers do not hang forever
       ?P("check parallel writers wo autoclose"),
       send_timeout_para(Config, BinData, SndBuf, TslTimeout, SndTimeout,
   		      false, RNode),
  -    ?P("check parallel writers w autoclose"),
  +
  +    ?P("done"),
  +    ok.
  +
  +%% Test the send_timeout socket option.
  +send_timeout_para_w_autoclose(Config) when is_list(Config) ->
  +    Pre  = fun() ->
  +                   Dir = filename:dirname(code:which(?MODULE)),
  +                   ?P("create node"),
  +                   {ok, RNode} = ?START_NODE(?UNIQ_NODE_NAME, "-pa " ++ Dir),
  +                   RNode
  +           end,
  +    Case = fun(Node) -> do_send_timeout_para_w_autoclose(Config, Node) end,
  +    Post = fun(Node) ->
  +                   ?P("stop node ~p", [Node]),
  +                   ?STOP_NODE(Node)
  +           end,
  +    ?TC_TRY(?FUNCTION_NAME, Pre, Case, Post).
  +
  +do_send_timeout_para_w_autoclose(Config, RNode) ->
  +    ?P("begin"),
  +    {TslTimeout, SndTimeout, BinData, SndBuf} = send_timeout_cfg(Config),
  +
  +    %% Check that parallel writers do not hang forever
  +    ?P("check parallel writers wo autoclose"),
       send_timeout_para(Config, BinData, SndBuf, TslTimeout, SndTimeout,
   		      true, RNode),
   
       ?P("done"),
       ok.
  -
  -send_timeout_basic(Config, BinData, SndBuf, TslTimeout, SndTimeout,
  -		   AutoClose, RNode) ->
  -    ?P("[basic] sink"),
  -    {A, Pid}              = setup_timeout_sink(Config, RNode, SndTimeout,
  -					       AutoClose, SndBuf),
  -    Send                  = fun() -> gen_tcp:send(A, BinData) end,
  -    {{error, timeout}, _} = timeout_sink_loop(Send, TslTimeout),
  -
  -    %% Check that the socket is not busy/closed...
  -    ?P("[basic] verify socket not busy/closed"),
  -    case gen_tcp:send(A, BinData) of
  -	{error, Reason} ->
  -	    ?P("[basic] (expected) send failure"),
  -	    after_send_timeout(AutoClose, Reason),
  -	    (catch gen_tcp:close(A)),
  -	    exit(Pid, kill),
  -	    ok;
  -	ok ->
  -            %% Note that there is no active reader on the other end,
  -            %% so a 'channel' has been filled, should remain filled.
  -	    ?P("[basic] UNEXPECTED send success"),
  -	    (catch gen_tcp:close(A)),
  -	    exit(Pid, kill),
  -	    ct:fail("Unexpected send success")
  -    end.
   
   send_timeout_para(Config, BinData, BufSz, TslTimeout, SndTimeout,
   		  AutoClose, RNode) ->
  
positive.code:             anc_await_closed_and_down(S, Pid, MRef, Size, Closed, Down)
      end.
  
  %% Test the send_timeout socket option.
  send_timeout(Config) when is_list(Config) ->
      Pre  = fun() ->
                     Dir = filename:dirname(code:which(?MODULE)),
                     ?P("create node"),
                     {ok, RNode} = ?START_NODE(?UNIQ_NODE_NAME, "-pa " ++ Dir),
                     RNode
             end,
      Case = fun(Node) -> do_send_timeout(Config, Node) end,
      Post = fun(Node) ->
                     ?P("stop node ~p", [Node]),
                     ?STOP_NODE(Node)
             end,
      ?TC_TRY(?FUNCTION_NAME, Pre, Case, Post).
  
  do_send_timeout(Config, RNode) ->
      ?P("begin"),
      {TslTimeout, SndTimeout, BinData, SndBuf} = 
  	case ?IS_SOCKET_BACKEND(Config) of
  	    true ->
  		{100, 3000, binary:copy(<<$a:8>>, 10*1024), 5*1024};
  	    false ->
  		{1,   1000, binary:copy(<<$a:8>>, 1*1024),  16*1024}
  	end,
  
      %% Basic
      ?P("basic check wo autoclose"),
      send_timeout_basic(Config, BinData, SndBuf, TslTimeout, SndTimeout,
  		       false, RNode),
      ?P("basic check w autoclose"),
      send_timeout_basic(Config, BinData, SndBuf, TslTimeout, SndTimeout,
  		       true, RNode),
  
      %% Check timeout length.
      ?P("spawn sink process (check timeout length)"),
  
negative.code: 			Send = fun() -> gen_tcp:send(A, BinData) end,
  			Self ! {self(), timeout_sink_loop(Send, TslTimeout)}
  		end,
      ?P("[para] spawn sender process 1"),
      Snd1 = spawn_link(SenderFun),
      ?P("[para] spawn sender process 2"),
      Snd2 = spawn_link(SenderFun),
  
      SockInfo    = fun() -> (catch inet:info(A)) end,
  