anchor.diff:  recv_reopen(listen, Ref) ->
       {_, reopen} = ?WD_EVENT(Ref).
   
  -%% reg/4
  +%% reg/3
   %%
   %% Lookup the pid of the transport process and publish a term for
   %% send/2 to lookup.
  -reg(Type, Ref, SvcName, T) ->
  -    TPid = tpid(Type, Ref, diameter:service_info(SvcName, transport)),
  +reg(TRef, SvcName, T) ->
  +    TPid = tpid(TRef, diameter:service_info(SvcName, transport)),
       true = diameter_reg:add_new({?MODULE, TPid, T}).
   
  -%% tpid/3
  -
  -tpid(connect, Ref, [[{ref, Ref},
  -                     {type, connect},
  -                     {options, _},
  -                     {watchdog, _},
  -                     {peer, _},
  -                     {apps, _},
  -                     {caps, _},
  -                     {port, [{owner, TPid} | _]}
  -                     | _]]) ->
  +%% tpid/2
  +
  +tpid(Ref, [[{ref, Ref},
  +            {type, connect},
  +            {options, _},
  +            {watchdog, _},
  +            {peer, _},
  +            {apps, _},
  +            {caps, _},
  +            {port, [{owner, TPid} | _]}
  +            | _]]) ->
       TPid;
   
  -tpid(listen, Ref, [[{ref, Ref},
  -                    {type, listen},
  -                    {options, _},
  -                    {accept, As}
  -                    | _]]) ->
  +tpid(Ref, [[{ref, Ref},
  +            {type, listen},
  +            {options, _},
  +            {accept, As}
  +            | _]]) ->
       [[{watchdog, _},
         {peer, _},
         {apps, _},
  
positive.code: 
  %% The misbehaving peer.
  reopen(Type, _, SvcName, Ref, Wd, N, M) ->
      ?LOG("peer, ~p, ~p", [Type, Ref]),
  
      %% First transport process.
      {initial, okay} = ?WD_EVENT(Ref),
      ?EVENT({up, Ref, _, _, #diameter_packet{}}),
  
      reg(Type, Ref, SvcName, {SvcName, {Wd,N,M}}),
  
      {okay, down} = ?WD_EVENT(Ref),
  
      %% Second transport process.
      ?EVENT({watchdog, Ref, _, {_, reopen}, _}),
      reg(Type, Ref, SvcName, 3),
      ?EVENT({watchdog, Ref, _, {_, down}, _}),
  
      %% Third transport process.
      ?EVENT({watchdog, Ref, _, {_, reopen}, _}),
      reg(Type, Ref, SvcName, 0),
      ?EVENT({watchdog, Ref, _, {_, down}, _}),
  
      ok.
  
negative.code: %% reopen/6
  
  reopen(Type, Test, Ref, Wd, N, M) ->
      {SvcName, TRef} = start(Type, Ref, cfg(Type, Test, Wd)),
      reopen(Type, Test, SvcName, TRef, Wd, N, M).
  
  cfg(Type, Type, Wd) ->
      {Wd, [], []};
  cfg(_Type, _Test, _Wd) ->
      {?WD(?PEER_WD), [{okay, 0}], [{module, ?MODULE}]}.
  
  %% reopen/7
  
  %% The watchdog to be tested.
  reopen(Type, Type, SvcName, Ref, Wd, N, M) ->
      ?LOG("node ~p", [[Type, SvcName, Ref, Wd, N, M]]),
  
      %% Connection should come up immediately as a consequence of
      %% starting the watchdog process. In the accepting case this
  