anchor.diff:      [];
   api_to_connect_tcp6(_Config) when is_list(_Config) ->
       %% tc_begin(api_to_connect_tcp6),
  -    %% ok = api_to_connect_tcp(inet6),
  +    %% InitState = #{domain => inet6},
  +    %% ok = api_to_connect_tcp(InitState),
       %% tc_end().
       not_yet_implemented().
   
  
positive.code: %% For instance, on FreeBSD (11.2) the reponse when the backlog is full
  %% is a econreset.
  
  api_to_connect_tcp(Domain) ->
      process_flag(trap_exit, true),
      p("init"),
      Client     = self(),
      LocalAddr  = which_local_addr(Domain),
      LocalSA    = #{family => Domain, addr => LocalAddr}, 
      ServerName = f("~s:server", [get_tc_name()]),
      Server = spawn_link(fun() ->
                                  put(sname, ServerName),
                                  p("open"),
                                  LSock = sock_open(Domain, stream, tcp),
                                  p("bind"),
                                  ServerLPort = sock_bind(LSock, LocalSA),
                                  p("listen on ~w", [ServerLPort]),
                                  sock_listen(LSock, 1),
                                  p("inform client"),
                                  Client ! {self(), ServerLPort},
                                  p("await termination command"),
                                  receive
                                      die ->
                                          p("terminating"),
                                          exit(normal)
                                  end
                          end),
      
      p("await server port"),
      ServerLPort = 
          receive
              {Server, Port} ->
                  Port
          end,
      p("open(s)"),
      CSock1       = sock_open(Domain, stream, tcp),
      CSock2       = sock_open(Domain, stream, tcp),
      CSock3       = sock_open(Domain, stream, tcp),
      p("bind(s)"),
      _ClientPort1 = sock_bind(CSock1, LocalSA),
      _ClientPort2 = sock_bind(CSock2, LocalSA),
      _ClientPort3 = sock_bind(CSock3, LocalSA),
      ServerSA = LocalSA#{port => ServerLPort},
      api_to_connect_tcp_await_timeout([CSock1, CSock2, CSock3], ServerSA),
      p("terminate server"),
      Server ! die,
      receive
          {'EXIT', Server, _} ->
              p("server terminated"),
              ok
      end,
      ok.
  
  
  
negative.code:     [];
  api_to_connect_tcp4(_Config) when is_list(_Config) ->
      tc_begin(api_to_connect_tcp4),
      InitState = #{domain => inet},
      ok = api_to_connect_tcp(InitState),
      tc_end().
      %% not_yet_implemented().
  
  