anchor.diff:           %% *** Wait for start order part ***
            #{desc => "await start (from tester)",
              cmd  => fun(State) ->
  -                           Tester = ?SEV_AWAIT_START(),
  -                           {ok, State#{tester => Tester}}
  +                           {Tester, Backlog} = ?SEV_AWAIT_START(),
  +                           {ok, State#{tester  => Tester,
  +                                       backlog => Backlog}}
                      end},
            #{desc => "monitor tester",
              cmd  => fun(#{tester := Tester} = _State) ->
  
positive.code:            fun() ->
                     not_yet_implemented(),
                     ?TT(?SECS(10)),
                     InitState = #{domain => inet6, timeout => 5000},
                     ok = api_to_connect_tcp(InitState)
             end).
  
  
negative.code:          ?SEV_FINISH_NORMAL
          ],
  
      ClientSeq =
          [
           %% *** Wait for start order part ***
           #{desc => "await start",
             cmd  => fun(State) ->
                             {Tester, ServerSA} = ?SEV_AWAIT_START(),
                             {ok, State#{tester    => Tester,
                                         server_sa => ServerSA}}
                     end},
           #{desc => "monitor tester",
             cmd  => fun(#{tester := Tester} = _State) ->
                             _MRef = erlang:monitor(process, Tester),
                             ok
                     end},
  
           %% *** Init part ***
           #{desc => "which local address",
             cmd  => fun(#{domain := Domain} = State) ->
                             LAddr = which_local_addr(Domain),
                             LSA   = #{family => Domain, addr => LAddr},
                             {ok, State#{local_sa => LSA}}
                     end},
           #{desc => "create node",
             cmd  => fun(#{host := Host} = State) ->
                             case start_node(Host, client) of
                                 {ok, Node} ->
                                     ?SEV_IPRINT("client node ~p started",
                                                 [Node]),
                                     {ok, State#{node => Node}};
                                 {error, Reason, _} ->
                                     {error, Reason}
                             end
                     end},
           #{desc => "monitor client node",
             cmd  => fun(#{node := Node} = _State) ->
                             true = erlang:monitor_node(Node, true),
                             ok
                     end},
           #{desc => "start remote client on client node",
             cmd  => fun(#{node := Node} = State) ->
                             Pid = api_toc_tcp_client_start(Node),
                             ?SEV_IPRINT("remote client ~p started", [Pid]),
                             {ok, State#{rclient => Pid}}
                     end},
           #{desc => "monitor remote client",
             cmd  => fun(#{rclient := Pid}) ->
                             _MRef = erlang:monitor(process, Pid),
                             ok
                     end},
           #{desc => "order remote client to start",
             cmd  => fun(#{rclient   := Client,
                           server_sa := ServerSA}) ->
                             ?SEV_ANNOUNCE_START(Client, ServerSA),
                             ok
                     end},
           #{desc => "await remote client ready",
             cmd  => fun(#{tester  := Tester,
                           rclient := Client} = _State) ->
                             ?SEV_AWAIT_READY(Client, rclient, init,
                                              [{tester, Tester}])
                     end},
           #{desc => "announce ready (init)",
             cmd  => fun(#{tester := Tester}) ->
                             ?SEV_ANNOUNCE_READY(Tester, init),
                             ok
                     end},
  
           %% The actual test
           #{desc => "await continue (connect)",
             cmd  => fun(#{tester  := Tester,
                           rclient := Client} = State) ->
                             case ?SEV_AWAIT_CONTINUE(Tester, tester, connect,
                                                      [{rclient, Client}]) of
                                 {ok, {ConTimeout, ConLimit}} ->
                                     {ok, State#{connect_timeout => ConTimeout,
                                                 connect_limit   => ConLimit}};
                                 {error, _} = ERROR ->
                                     ERROR
                             end
                     end},
           #{desc => "order remote client to continue (connect)",
             cmd  => fun(#{rclient         := RClient,
                           connect_timeout := ConTimeout,
                           connect_limit   := ConLimit}) ->
                             ?SEV_ANNOUNCE_CONTINUE(RClient, connect,
                                                    {ConTimeout, ConLimit}),
                             ok
                     end},
           #{desc => "await remote client ready (connect)",
             cmd  => fun(#{tester  := Tester,
                           rclient := RClient} = State) ->
                             case ?SEV_AWAIT_READY(RClient, rclient, connect,
                                                   [{tester, Tester}]) of
                                 {ok, ok = _Result} ->
                                     {ok, maps:remove(connect_limit, State)};
                                 {ok, Result} ->
                                     Result;
                                 {error, _} = ERROR ->
                                     ERROR
                             end
                     end},
  
           #{desc => "announce ready (connect)",
             cmd  => fun(#{tester := Tester}) ->
                             ?SEV_ANNOUNCE_READY(Tester, connect),
                             ok
                     end},
  
           %% Termination
           #{desc => "await terminate (from tester)",
             cmd  => fun(#{tester  := Tester,
                           rclient := RClient} = State) ->
                             case ?SEV_AWAIT_TERMINATE(Tester, tester,
                                                       [{rclient, RClient}]) of
                                 ok ->
                                     {ok, maps:remove(tester, State)};
                                 {error, _} = ERROR ->
                                     ERROR
                             end
                     end},
           #{desc => "kill remote client",
             cmd  => fun(#{rclient := Client}) ->
                             ?SEV_ANNOUNCE_TERMINATE(Client),
                             ok
                     end},
           #{desc => "await remote client termination",
             cmd  => fun(#{rclient := Client} = State) ->
                             ?SEV_AWAIT_TERMINATION(Client),
                             State1 = maps:remove(rclient, State),
                             {ok, State1}
                     end},
           #{desc => "stop client node",
             cmd  => fun(#{node := Node} = _State) ->
                             stop_node(Node)
                     end},
           #{desc => "await client node termination",
             cmd  => fun(#{node := Node} = State) ->
                             receive
                                 {nodedown, Node} ->
                                     State1 = maps:remove(node_id, State),
                                     State2 = maps:remove(node,    State1),
                                     {ok, State2}
                             end
                     end},
  
           %% *** We are done ***
           ?SEV_FINISH_NORMAL
          ],
  
      TesterSeq =
          [
           %% *** Init part ***
  