anchor.diff:                             end
                      end},
            #{desc => "validate timeout time",
  -           cmd  => fun(#{start := Start, stop := Stop, timeout := To} = _State) ->
  +           cmd  => fun(#{start := Start, stop := Stop, timeout := To} = State) ->
                              TDiff  = tdiff(Start, Stop),
                              if
                                  (TDiff >= To) ->
  -                                   ok;
  +                                   State1 = maps:remove(start, State),
  +                                   State2 = maps:remove(stop,  State1),
  +                                   {ok, State2};
                                  true ->
                                      {error, {unexpected_timeout, TDiff, To}}
                              end
                      end},
  -         #{desc => "announce ready",
  -           cmd  => fun(#{tester := Tester}) ->
  -                           ei("announcing port to tester (~p)", [Tester]),
  -                           Tester ! {ready, self()},
  -                           ok
  -                   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) ->
  -                           receive
  -                               {'DOWN', _, process, Tester, Reason} ->
  -                                   ee("Unexpected DOWN regarding tester ~p: "
  -                                      "~n   ~p", [Tester, Reason]),
  -                                   {error, {unexpected_exit, tester}};
  -                               {terminate, Tester} ->
  -                                   ok
  -                           end
  -                   end},
  -
  -         %% *** Close (listen) socket ***
  -         #{desc => "close (listen) socket",
  -           cmd  => fun(#{lsock := LSock} = State) ->
  -                           sock_close(LSock),
  -                           {ok, maps:remove(lsock, State)}
  +           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 ***
  
positive.code:         ],
  
  
      SecAcceptorSeq =
          [
           %% *** Init part ***
           #{desc => "await start",
             cmd  => fun(State) ->
                             receive
                                 {start, Tester, LSock} ->
                                     MRef = erlang:monitor(process, Tester),
                                     {ok, State#{tester      => Tester,
                                                 lsock       => LSock,
                                                 tester_mref => MRef}}
                             end
                     end},
           #{desc => "announce ready (1)",
             cmd  => fun(#{tester := Tester} = _State) ->
                             Tester ! {ready, self()},
                             ok
                     end},
           #{desc => "await continue",
             cmd  => fun(#{tester := Tester} = _State) ->
                             receive
                                 {'DOWN', _, process, Tester, Reason} ->
                                     ee("Unexpected DOWN regarding tester ~p: "
                                        "~n   ~p", [Tester, Reason]),
                                     {error, {unexpected_exit, tester, Reason}};
                                 {continue, Tester} ->
                                     ok
                             end
                     end},
  
           %% *** The actual test part ***
           #{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} ->
                                     (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 (2)",
             cmd  => fun(#{tester := Tester} = _State) ->
                             Tester ! {ready, self()},
                             ok
                     end},
           #{desc => "await terminate",
             cmd  => fun(#{tester := Tester} = _State) ->
                             receive
                                 {'DOWN', _, process, Tester, Reason} ->
                                     ee("Unexpected DOWN regarding tester ~p: "
                                        "~n   ~p", [Tester, Reason]),
                                     {error, {unexpected_exit, tester, Reason}};
                                 {terminate, Tester} ->
                                     ok
                             end
                     end},
  
           %% *** We are done ***
           #{desc => "finish",
             cmd  => fun(_) ->
                             {ok, normal}
                     end}
          ],
  
  
      TesterSeq =
          [
           %% Init part
  
negative.code: api_to_maccept_tcp6(doc) ->
      [];
  api_to_maccept_tcp6(_Config) when is_list(_Config) ->
      ?TT(?SECS(20)),
      tc_try(api_to_maccept_tcp4,
             fun() ->
                     not_yet_implemented(),
  