anchor.diff:  t_implicit_inet6(Host, Addr) ->
       Loopback = {0,0,0,0,0,0,0,1},
       case gen_tcp:listen(0, [inet6, {ip,Loopback}]) of
  -	{ok,S1} ->
  -	    io:format("~s ~p~n", ["::1",Loopback]),
  +	{ok, S1} ->
  +	    p("try ~s ~p", ["::1", Loopback]),
   	    implicit_inet6(S1, Loopback),
   	    ok = gen_tcp:close(S1),
   	    %%
   	    Localaddr = ok(get_localaddr()),
  -	    S2 = ok(gen_tcp:listen(0, [{ip,Localaddr}])),
  +	    S2 = case gen_tcp:listen(0, [{ip, Localaddr}]) of
  +                     {ok, LSock2} ->
  +                         LSock2;
  +                     {error, Reason2} ->
  +                         skip(listen_failed_str(Reason2))
  +                 end,
   	    implicit_inet6(S2, Localaddr),
   	    ok = gen_tcp:close(S2),
   	    %%
  -	    io:format("~s ~p~n", [Host,Addr]),
  -	    S3 = ok(gen_tcp:listen(0, [{ifaddr,Addr}])),
  +	    p("try ~s ~p", [Host, Addr]),
  +	    S3 = case gen_tcp:listen(0, [{ifaddr,Addr}]) of
  +                     {ok, LSock3} ->
  +                         LSock3;
  +                     {error, Reason3} ->
  +                         skip(listen_failed_str(Reason3))
  +                 end,
   	    implicit_inet6(S3, Addr),
  -	    ok = gen_tcp:close(S3);
  -	{error,_} ->
  -	    {skip,"IPv6 not supported"}
  +	    ok = gen_tcp:close(S3),
  +	    p("done"),
  +            ok;
  +        {error, Reason1} ->
  +            skip(listen_failed_str(Reason1))
       end.
   
   implicit_inet6(S, Addr) ->
       P = ok(inet:port(S)),
  -    S2 = ok(gen_tcp:connect(Addr, P, [])),
  +    S2 = case gen_tcp:connect(Addr, P, []) of
  +             {ok, CSock} ->
  +                 CSock;
  +             {error, CReason} ->
  +                 skip(connect_failed_str(CReason))
  +         end,
       P2 = ok(inet:port(S2)),
  -    S1 = ok(gen_tcp:accept(S)),
  +    S1 = case gen_tcp:accept(S) of
  +             {ok, ASock} ->
  +                 ASock;
  +             {error, AReason} ->
  +                 skip(accept_failed_str(AReason))
  +         end,
       P1 = P = ok(inet:port(S1)),
       {Addr,P2} = ok(inet:peername(S1)),
       {Addr,P1} = ok(inet:peername(S2)),
  
positive.code: get_localaddr([Localhost|Ls]) ->
      case inet:getaddr(Localhost, inet6) of
         {ok, LocalAddr} ->
             io:format("~s ~p~n", [Localhost, LocalAddr]),
             {ok, LocalAddr};
         _ ->
             get_localaddr(Ls)
  
negative.code: %%% implicit inet6 option to api functions
  
  t_implicit_inet6(Config) when is_list(Config) ->
      try do_t_implicit_inet6(Config)
      catch
          throw:{skip, _} = SKIP ->
              SKIP
      end.
  
  do_t_implicit_inet6(_Config) ->
      p("try get hostname"),
      Host = ok(inet:gethostname()),
      p("try get address for host ~p", [Host]),
      case inet:getaddr(Host, inet6) of
  	{ok, Addr} ->
              p("address: ~p", [Addr]),
  	    t_implicit_inet6(Host, Addr);
  	{error, Reason} ->
  	    {skip,
  	     "Can not look up IPv6 address: "
  	     ++atom_to_list(Reason)}
  