anchor.diff:  
   
   list_session_connections(Provider, SessId) ->
  -    case rpc:call(Provider, session_connections, list, [SessId]) of
  -        {ok, Cons} ->
  -            Cons;
  -        Error ->
  -            Error
  -    end.
  +    rpc:call(Provider, session_connections, list, [SessId]).
   
   
   -spec expected_configuration(node()) -> #{binary() := binary() | [binary()]}.
  
positive.code:         {ok, [list_to_binary(inet:ntoa(IP)) || IP <- IPsAtoms]}
      end,
      test_utils:mock_expect(Nodes, provider_logic, get_nodes, GetNodesFun),
      Cons = list_session_connections(P1Worker, OutgoingSessId),
      lists:foreach(fun(Conn) -> connection:close(Conn) end, Cons),
      timer:sleep(timer:seconds(2)),
  
      [Conn2, Conn1] = ?assertMatch([_, _], list_session_connections(P1Worker, OutgoingSessId), ?ATTEMPTS),
      connection:close(Conn1),
      [Conn3, _] = ?assertMatch([_Conn3, Conn2], list_session_connections(P1Worker, OutgoingSessId), ?ATTEMPTS),
  
      ?assertNotEqual(Conn1, Conn3).
  
  
negative.code:     IncomingSessId = get_provider_session_id(Provider, incoming, PeerProviderId),
      OutgoingSessId = get_provider_session_id(Provider, outgoing, PeerProviderId),
  
      IncomingSessExists = session_exists(Provider, IncomingSessId),
      % Outgoing session is always created but will fail to make any connection
      % in case of providers incompatibilities.
      OutgoingConnExists = case session_exists(Provider, OutgoingSessId) of
          true ->
              case list_session_connections(Provider, OutgoingSessId) of
                  {ok, [_ | _]} -> true;
                  _ -> false
              end;
          false ->
              false
      end,
  
      IncomingSessExists orelse OutgoingConnExists.
  
  
  get_provider_session_id(Worker, Type, ProviderId) ->
  