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 (recv timeout success)",
              cmd  => fun(#{tester := Tester} = _State) ->
  -                           %% Tester ! {ready, self()},
                              %% ok
                              ev_ready(Tester, accept_recv),
                              ok
  
positive.code:                            LSA   = #{family => Domain,
                                       addr   => LAddr},
                             SSA   = LSA#{port => Port},
                             {ok, State#{lsa => LSA, ssa => SSA}}
                     end},
           #{desc => "create socket",
             cmd  => fun(#{domain := Domain} = State) ->
  
negative.code:                                    ERROR
                             end
                     end},
           #{desc => "announce ready (init)",
             cmd  => fun(#{tester := Tester, sock := Sock} = _State) ->
                             ev_ready(Tester, init, Sock),
                             ok
                     end},
  
           %% *** The actual test ***
           %% We *intentially* leave the socket "as is", no explicit close
           #{desc => "await terminate (from tester)",
             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 ***
           #{desc => "finish",
  