anchor.diff:                             socket:listen(LSock)
                      end},
            #{desc => "announce ready (init)",
  -           cmd  => fun(#{tester := Tester, lsa := LSA, lport := Port}) ->
  -                           SA = LSA#{port => Port},
  -                           Tester ! {ready, self(), SA},
  +           cmd  => fun(#{tester := Tester, local_sa := LSA, lport := Port}) ->
  +                           ServerSA = LSA#{port => Port},
  +                           ev_ready(Tester, init, ServerSA),
                              ok
                      end},
   
            %% The actual test
            #{desc => "await continue (accept)",
              cmd  => fun(#{tester := Tester} = _State) ->
  -                           receive
  -                               {continue, Tester} ->
  -                                   ok;
  -                               {'DOWN', _, process, Tester, Reason} ->
  -                                   ee("Unexpected DOWN regarding tester ~p: "
  -                                      "~n   ~p", [Tester, Reason]),
  -                                   {error, {unexpected_exit, tester}}
  -                           end
  +                           ev_await_continue(Tester, tester, accept)
                      end},
            #{desc => "accept",
              cmd  => fun(#{lsock := LSock} = State) ->
  
positive.code:          %% Start the server
           #{desc => "order server start",
             cmd  => fun(#{server := Pid} = _State) ->
                             Pid ! {start, self()},
                             ok
                     end},
           #{desc => "await server ready (init)",
             cmd  => fun(#{server := Pid} = State) ->
                             receive
                                 {ready, Pid, ServerSA} ->
                                     {ok, State#{server_sa => ServerSA}};
                                 {'DOWN', _, process, Pid, Reason} ->
                                     ee("Unexpected DOWN regarding server ~p: "
                                        "~n   ~p", [Pid, Reason]),
                                     {error, {unexpected_exit, server}}
                             end
                     end},
  
           %% Start the client
  
negative.code:          %% *** Init part ***
           #{desc => "await start",
             cmd  => fun(State) ->
                             {Tester, {Node, ServerSA}} = ev_await_start(),
                             {ok, State#{tester    => Tester, 
                                         node      => Node, 
                                         server_sa => ServerSA}}
                     end},
           #{desc => "monitor tester",
             cmd  => fun(#{tester := Tester} = _State) ->
                             _MRef = erlang:monitor(process, Tester),
                             ok
                     end},
           #{desc => "start remote client on client node",
             cmd  => fun(#{node := Node} = State) ->
                             Pid = sc_rc_tcp_client_start(Node),
                             ei("client ~p started", [Pid]),
                             {ok, State#{client => Pid}}
                     end},
           #{desc => "monitor remote client",
             cmd  => fun(#{client := Pid}) ->
                             _MRef = erlang:monitor(process, Pid),
                             ok
                     end},
           #{desc => "order remote client to start",
             cmd  => fun(#{client := Client, server_sa := ServerSA}) ->
                             Client ! {start, self(), ServerSA},
                             ok
                     end},
           #{desc => "await remote client ready",
             cmd  => fun(#{tester := Tester,
                           client := Client} = _State) ->
                             receive
  