anchor.diff:             cmd  => fun(#{lsock := LSock}) ->
                              socket:listen(LSock)
                      end},
  -
  -         #{desc => "announce ready",
  +         #{desc => "announce ready (init)",
              cmd  => fun(#{lsock := LSock, tester := Tester}) ->
  -                           ei("announcing port to tester (~p)", [Tester]),
  -                           Tester ! {ready, self(), LSock},
  -                           ok
  -                   end},
  -         #{desc => "await continue",
  +                           ev_ready(Tester, init, LSock),
  +                           ok
  +                   end},
  +
  +         %% *** The actual test ***
  +         #{desc => "await continue (accept)",
              cmd  => fun(#{tester := Tester} = _State) ->
  -                           receive
  -                               {'DOWN', _, process, Tester, Reason} ->
  -                                   ee("Unexpected DOWN regarding tester ~p: "
  -                                      "~n   ~p", [Tester, Reason]),
  -                                   {error, {unexpected_exit, tester}};
  -                               {continue, Tester} ->
  -                                   ok
  -                           end
  +                           ev_await_continue(Tester, tester, accept),
  +                           ok
  +                   end},
  +         #{desc => "attempt to accept (without success)",
  +           cmd  => fun(#{lsock := LSock, timeout := To} = State) ->
  +                           Start = t(),
  +                           case socket:accept(LSock, To) of
  +                               {error, timeout} ->
  +                                   {ok, State#{start => Start, stop => t()}};
  +                               {ok, Sock} ->
  +                                   ee("Unexpected accept success: "
  +                                      "~n   ~p", [Sock]),
  +                                   (catch socket:close(Sock)),
  +                                   {error, unexpected_success};
  +                               {error, _} = ERROR ->
  +                                   ERROR
  +                           end
  +                   end},
  +         #{desc => "validate timeout time",
  +           cmd  => fun(#{start := Start, stop := Stop, timeout := To} = _State) ->
  +                           TDiff  = tdiff(Start, Stop),
  +                           if
  +                               (TDiff >= To) ->
  +                                   ok;
  +                               true ->
  +                                   {error, {unexpected_timeout, TDiff, To}}
  +                           end
  +                   end},
  +         #{desc => "announce ready (accept)",
  +           cmd  => fun(#{tester := Tester}) ->
  +                           ev_ready(Tester, accept),
  +                           ok
  +                   end},
  +
  +         %% *** Terminate ***
  +         #{desc => "await terminate",
  +           cmd  => fun(#{tester := Tester} = _State) ->
  +                           ev_await_terminate(Tester, tester),
  +                           ok
  +                   end},
  +         %% *** Close (listen) socket ***
  +         #{desc => "close (listen) socket",
  +           cmd  => fun(#{lsock := LSock} = State) ->
  +                           sock_close(LSock),
  +                           {ok, maps:remove(lsock, State)}
  +                   end},
  +
  +         %% *** We are done ***
  +         #{desc => "finish",
  +           cmd  => fun(_) ->
  +                           {ok, normal}
  +                   end}
  +        ],
  +
  +
  +    SecAcceptorSeq =
  +        [
  +         %% *** Init part ***
  +         #{desc => "await start",
  +           cmd  => fun(State) ->
  +                           {Tester, LSock} = ev_await_start(),
  +                           {ok, State#{tester => Tester,
  +                                       lsock  => LSock}}
  +                           
  +                   end},
  +         #{desc => "monitor tester",
  +           cmd  => fun(#{tester := Pid} = _State) ->
  +                           _MRef = erlang:monitor(process, Pid),
  +                           ok
  +                   end},
  +         #{desc => "announce ready (init)",
  +           cmd  => fun(#{tester := Tester} = _State) ->
  +                           ev_ready(Tester, init),
  +                           ok
                      end},
   
            %% *** The actual test part ***
  +         #{desc => "await continue (accept)",
  +           cmd  => fun(#{tester := Tester} = _State) ->
  +                           ev_await_continue(Tester, tester, accept),
  +                           ok
  +                   end},
            #{desc => "attempt to accept (without success)",
              cmd  => fun(#{lsock := LSock, timeout := To} = State) ->
                              Start = t(),
  
positive.code:          %% *** Init part ***
           #{desc => "await start",
             cmd  => fun(State) ->
                             receive
                                 {start, Tester} ->
                                     MRef = erlang:monitor(process, Tester),
                                     {ok, State#{tester      => Tester,
                                                 tester_mref => MRef}}
                             end
                     end},
           #{desc => "which local address",
             cmd  => fun(#{domain := Domain} = State) ->
  
negative.code:                            end
                     end},
           #{desc => "validate timeout time",
             cmd  => fun(#{start := Start, stop := Stop, timeout := To} = State) ->
                             TDiff  = tdiff(Start, Stop),
                             if
                                 (TDiff >= To) ->
                                     State1 = maps:remove(start, State),
                                     State2 = maps:remove(stop,  State1),
                                     {ok, State2};
                                 true ->
                                     {error, {unexpected_timeout, TDiff, To}}
                             end
                     end},
           #{desc => "announce ready (accept)",
             cmd  => fun(#{tester := Tester} = _State) ->
                             ev_ready(Tester, accept),
                             ok
                     end},
  
           %% *** Terminate ***
           #{desc => "await terminate",
             cmd  => fun(#{tester := Tester} = State) ->
                             case ev_await_terminate(Tester, tester) of
                                 ok ->
                                     {ok, maps:remove(tester, State)};
                                 {error, _} = ERROR ->
                                     ERROR
                             end
                     end},
  
           %% *** We are done ***
  