anchor.diff:             cmd  => fun(#{lsock := LSock}) ->
                              socket:listen(LSock, 1)
                      end},
  -         #{desc => "monitor tester",
  -           cmd  => fun(#{tester := Tester} = State) ->
  -                           MRef = erlang:monitor(process, Tester),
  -                           {ok, State#{tester_mref => MRef}}
  -                   end},
  -         #{desc => "announce ready",
  +         #{desc => "announce ready (init)",
              cmd  => fun(#{tester := Tester, lport := Port}) ->
  -                           %% Tester ! {ready, self(), Port},
                              ev_ready(Tester, init, Port),
                              ok
                      end},
  +
  +         %% *** The actual test ***
            #{desc => "await continue (accept and recv)",
              cmd  => fun(#{tester := Tester}) ->
                              ok = ev_await_continue(Tester, tester, accept_recv)
                      end},
  -
  -         %% *** The actual test ***
            #{desc => "attempt accept",
              cmd  => fun(#{lsock := LSock} = State) ->
                              case socket:accept(LSock) of
  
positive.code:                    end},
           #{desc => "order (owner) terminate",
             cmd  => fun(#{owner := Pid} = _State) ->
                             Pid ! {terminate, self()},
                             ok
                     end},
           #{desc => "await (owner) termination",
             cmd  => fun(#{owner := Owner} = _State) ->
                             receive
                                 {'DOWN', _, process, Owner, _} ->
                                     ok
                             end
                     end},
           #{desc => "verify no socket (closed)",
             cmd  => fun(#{owner := Owner, sock := Sock} = _State) ->
                             case socket:getopt(Sock, otp, controlling_process) of
                                 {ok, Pid} ->
                                     {error, {unexpected_success, Owner, Pid}};
                                 {error, closed} ->
                                     ok;
                                 {error, Reason} ->
  
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 (recv timeout success)",
             cmd  => fun(#{tester := Tester} = _State) ->
                             %% ok
                             ev_ready(Tester, accept_recv),
                             ok
  