anchor.diff:             cmd  => fun(#{lsock := LSock}) ->
                              socket:listen(LSock)
                      end},
  -         #{desc => "announce server port",
  -           cmd  => fun(#{parent := Parent, lport := Port}) ->
  -                           ei("announcing port to parent (~p)", [Parent]),
  -                           Parent ! {server_port, self(), Port},
  -                           ok
  +         #{desc => "announce ready (init)",
  +           cmd  => fun(#{tester := Tester, lport := Port}) ->
  +                           ev_ready(Tester, init, Port),
  +                           ok
  +                   end},
  +
  +         %% The actual test
  +         #{desc => "await continue (accept)",
  +           cmd  => fun(#{tester := Tester}) ->
  +                           ok = ev_await_continue(Tester, tester, accept)
                      end},
            #{desc => "await connection",
              cmd  => fun(#{lsock := LSock} = State) ->
                              case socket:accept(LSock) of
                                  {ok, Sock} ->
                                      ei("accepted: ~n   ~p", [Sock]),
  -                                   {ok, State#{tsock => Sock}};
  -                               {error, _} = ERROR ->
  -                                   ERROR
  -                           end
  -                   end},
  -         #{desc => "await request",
  -           cmd  => fun(#{tsock := Sock, recv := Recv}) ->
  +                                   {ok, State#{csock => Sock}};
  +                               {error, _} = ERROR ->
  +                                   ERROR
  +                           end
  +                   end},
  +         #{desc => "announce ready (accept)",
  +           cmd  => fun(#{tester := Tester}) ->
  +                           ev_ready(Tester, accept),
  +                           ok
  +                   end},
  +         #{desc => "await (recv) request",
  +           cmd  => fun(#{csock := Sock, recv := Recv}) ->
                              case Recv(Sock) of
                                  {ok, ?BASIC_REQ} ->
                                      ok;
  
positive.code:                            end
                     end},
           #{desc => "bind to local address",
             cmd  => fun(#{sock := Sock, lsa := LSA} = State) ->
                             case socket:bind(Sock, LSA) of
                                 {ok, Port} ->
                                     {ok, State#{port => Port}};
                                 {error, _} = ERROR ->
                                     ERROR
                             end
                     end},
           #{desc => "connect to server",
             cmd  => fun(#{sock := Sock, ssa := SSA}) ->
                             socket:connect(Sock, SSA)
                     end},
           #{desc => "send request (to server)",
             cmd  => fun(#{sock := Sock, send := Send}) ->
                             Send(Sock, ?BASIC_REQ)
                     end},
           #{desc => "recv reply (from server)",
             cmd  => fun(#{sock := Sock, recv := Recv}) ->
                             {ok, ?BASIC_REP} = Recv(Sock),
                             ok
                     end},
           #{desc => "close socket",
             cmd  => fun(#{sock := Sock}) ->
                             socket:close(Sock)
                     end},
           #{desc => "finish",
             cmd  => fun(_) ->
                             {ok, normal}
                     end}
          ],
  
      i("start server evaluator"),
      #ev{pid = Pid} = Server = evaluator_start("server", ServerSeq, InitState),
      i("await server (~p) port", [Pid]),
      SPort = receive
                  {server_port, Pid, Port} ->
                      Port
              end,
      i("start client evaluator"),
      Client = evaluator_start("client", ClientSeq, InitState#{server_port => SPort}),
      i("await evaluator(s)"),
      ok = await_evaluator_finish([Server, Client]).
  
  
  
  
negative.code:     process_flag(trap_exit, true),
      ServerSeq = 
          [
           %% *** Wait for start order ***
           #{desc => "await start (from tester)",
             cmd  => fun(State) ->
                             Tester = ev_await_start(),
                             {ok, State#{tester => Tester}}
                     end},
           #{desc => "monitor tester",
             cmd  => fun(#{tester := Tester}) ->
                             _MRef = erlang:monitor(process, Tester),
                             ok
                     end},
  
           %% *** Init part ***
           #{desc => "which local address",
             cmd  => fun(#{domain := Domain} = State) ->
                             LAddr = which_local_addr(Domain),
  