anchor.diff:  peer_down(_SvcName, _Peer, State) ->
       State.
   
  -%% pick_peer/5/6
  -
  -pick_peer([Peer], _, ?CLIENT, _State, Name)
  +%% pick_peer/6-7
  +
  +pick_peer(Peers, _, ?CLIENT, _State, Name, Id)
     when Name /= send_detach ->
  -    {ok, Peer}.
  -
  -pick_peer([_Peer], _, ?CLIENT, _State, send_nopeer, ?EXTRA) ->
  +    find(Id, Peers).
  +
  +pick_peer(_Peers, _, ?CLIENT, _State, send_nopeer, _, ?EXTRA) ->
       false;
   
  -pick_peer([Peer], _, ?CLIENT, _State, send_detach, {_,_}) ->
  -    {ok, Peer}.
  -
  -%% prepare_request/4/5
  -
  -prepare_request(_Pkt, ?CLIENT, {_Ref, _Caps}, send_discard) ->
  +pick_peer(Peers, _, ?CLIENT, _State, send_detach, Id, {_,_}) ->
  +    find(Id, Peers).
  +
  +find(Id, Peers) ->
  +    [P] = lists:flatmap(fun(C) -> peer(Id, C) end,
  +                        diameter:service_info(?CLIENT, transport)),
  +    case lists:keyfind(P, 1, Peers) of %% OTP-10470 will provide a better way.
  +        {_,_} = TC ->
  +            {ok, TC};
  +        false = No ->
  +            No
  +    end.
  +
  +peer(Id, [{ref, _},
  +          {type, connect},
  +          {options, Opts},
  +          {watchdog, _},
  +          {peer, {PeerRef, _}}
  +          | _]) ->
  +    [PeerRef || lists:member({id, Id}, Opts)].
  +
  +%% prepare_request/5-6
  +
  +prepare_request(_Pkt, ?CLIENT, {_Ref, _Caps}, send_discard, _) ->
       {discard, unprepared};
   
  -prepare_request(Pkt, ?CLIENT, {_Ref, Caps}, Name) ->
  +prepare_request(Pkt, ?CLIENT, {_Ref, Caps}, Name, _) ->
       {send, prepare(Pkt, Caps, Name)}.
   
  -prepare_request(Pkt, ?CLIENT, {_Ref, Caps}, send_detach, _) ->
  +prepare_request(Pkt, ?CLIENT, {_Ref, Caps}, send_detach, _, _) ->
       {eval_packet, {send, prepare(Pkt, Caps)}, [fun log/2, detach]}.
   
   log(#diameter_packet{} = P, T) ->
  
positive.code: 
  call(Config, Req, Opts) ->
      Name = proplists:get_value(testcase, Config),
      [Enc] = name(proplists:get_value(group, Config)),
      diameter:call(?CLIENT,
                    dict(Req),
                    req(Req, Enc),
                    [{extra, [Name]} | Opts]).
  
  req(['ACR' = H | T], record) ->
      ?ACCT:'#new-'(?ACCT:msg2rec(H), T);
  
negative.code:     Rec.
  
  %% Contruct and deconstruct names to work around group names being
  %% restricted to atoms.
  
  name(Names)
    when is_list(Names) ->
  