anchor.diff:           %% *** Wait for start order ***
            #{desc => "await start (from tester)",
              cmd  => fun(State) ->
  -                           receive
  -                               {start, Tester} when is_pid(Tester) ->
  -                                   {ok, State#{tester => Tester}}
  -                           end
  +                           Tester = ev_await_start(),
  +                           {ok, State#{tester => Tester}}
                      end},
   
            %% *** Init part ***
  
positive.code:          %% *** Activate server ***
           #{desc => "start server",
             cmd  => fun(#{server := Server} = _State) ->
                             Server ! {start, self()},
                             ok
                     end},
           #{desc => "await server ready (init)",
             cmd  => fun(#{server := Server} = State) ->
                             receive
                                 {'DOWN', _, process, Server, Reason} ->
                                     {error, {unexpected_exit, server, Reason}};
                                 {ready, Server, Port} ->
                                     {ok, State#{server_port => Port}}
                             end
                     end},
           #{desc => "order server to continue (with accept)",
             cmd  => fun(#{server := Server} = _State) ->
                             Server ! {continue, self()},
                             ok
                     end},
  
           %% *** Activate client ***
           #{desc => "start client",
             cmd  => fun(#{client := Client, server_port := Port} = _State) ->
                             Client ! {start, self(), Port},
                             ok
                     end},
           #{desc => "await client ready",
             cmd  => fun(#{client := Client} = _State) ->
                             receive
                                 {'DOWN', _, process, Client, Reason} ->
                                     {error, {unexpected_exit, client, Reason}};
                                 {ready, Client} ->
                                     ok
                             end
                     end},
  
           %% *** The actual test ***
           #{desc => "order client to continue (with connect)",
             cmd  => fun(#{client := Client} = _State) ->
                             Client ! {continue, self()},
                             ok
                     end},
           #{desc => "await server ready (accept/recv)",
             cmd  => fun(#{server := Server} = _State) ->
                             receive
                                 {'DOWN', _, process, Server, Reason} ->
                                     {error, {unexpected_exit, server, Reason}};
                                 {ready, Server} ->
                                     ok
                             end
                     end},
  
           %% *** Termination ***
           #{desc => "order client to terminate",
             cmd  => fun(#{client := Client} = _State) ->
                             Client ! {terminate, self()},
                             ok
                     end},
           #{desc => "await client termination",
             cmd  => fun(#{client := Client} = State) ->
                             receive
                                 {'DOWN', _, process, Client, _Reason} ->
                                     State1 = maps:remove(client, State),
                                     State2 = maps:remove(client_mref, State1),
                                     {ok, State2}
                             end
                     end},
           #{desc => "order server to terminate",
             cmd  => fun(#{server := Server} = _State) ->
                             Server ! {terminate, self()},
                             ok
                     end},
           #{desc => "await server termination",
             cmd  => fun(#{server := Server} = State) ->
                             receive
                                 {'DOWN', _, process, Server, _Reason} ->
                                     State1 = maps:remove(server, State),
                                     State2 = maps:remove(server_mref, State1),
                                     State3 = maps:remove(server_port, State2),
                                     {ok, State3}
                             end
                     end},
  
           %% *** We are done ***
  
negative.code:                    end},
           #{desc => "announce ready (recv timeout success)",
             cmd  => fun(#{tester := Tester} = _State) ->
                             %% Tester ! {ready, self()},
                             %% ok
                             ev_ready(Tester, accept_recv),
                             ok
                     end},
  
           %% *** Termination ***
           #{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},
           #{desc => "close (traffic) socket",
             cmd  => fun(#{sock := Sock} = State) ->
                             sock_close(Sock),
                             {ok, maps:remove(sock, State)}
                     end},
           #{desc => "close (listen) socket",
             cmd  => fun(#{lsock := LSock} = State) ->
                             sock_close(LSock),
                             {ok, maps:remove(lsock, State)}
                     end},
  
           %% *** We are done ***
           #{desc => "finish",
  