anchor.diff:  
   all() ->
       [start, start_services, add_transports, result_codes]
  -        ++ [{group, ?util:name([E,C]), P} || E <- ?ENCODINGS,
  -                                             C <- ?CONNECTIONS,
  -                                             P <- [[], [parallel]]]
  +        ++ [{group, ?util:name([R,C,A]), P} || R <- ?ENCODINGS,
  +                                               C <- ?CONTAINERS,
  +                                               A <- ?ENCODINGS,
  +                                               P <- [[], [parallel]]]
           ++ [remove_transports, stop_services, stop].
   
   groups() ->
       Ts = tc(),
  -    [{?util:name([E,C]), [], Ts} || E <- ?ENCODINGS, C <- ?CONNECTIONS].
  +    [{?util:name([R,C,A]), [], Ts} || R <- ?ENCODINGS,
  +                                      C <- ?CONTAINERS,
  +                                      A <- ?ENCODINGS].
   
   init_per_group(Name, Config) ->
       [{group, Name} | Config].
  
positive.code:     {V,B} = ?CLIENT_MASK,
      V = EI bsr B,  %% assert
      V = HI bsr B,  %%
      request(M, Caps).
  
  %% send_nok
  request(#diameter_base_accounting_ACR{'Accounting-Record-Number' = 0},
  
negative.code: 
  call(Config, Req, Opts) ->
      Name = proplists:get_value(testcase, Config),
      [Encoding, C, E] = ?util:name(proplists:get_value(group, Config)),
      diameter:call(?CLIENT,
                    dict(Req),
                    msg(Req, Encoding),
                    [{extra, [Name, client(E,C)]} | Opts]).
  
  client(E, C) ->
      list_to_atom([$c, $0 + 2*codec(E) + container(C)]).
  
  client(N) ->
      {codec(N bsr 1), container(N rem 2)}.
  
  codec(record) -> 0;
  codec(list) -> 1;
  codec(0) -> record;
  codec(1) -> list.
  
  %% Here we're just mapping booleans but the readable atoms are part of
  %% (constructed) group names, so it's good that they're readable.
  
  container(pkt) -> 0;
  container(msg) -> 1;
  container(0) -> pkt;
  container(1) -> msg.
  
  msg([H|T], record)
    when H == 'ACR';
         H == 'ACA' ->
      ?ACCT:'#new-'(?ACCT:msg2rec(H), T);
  msg([H|T], record) ->
      ?BASE:'#new-'(?BASE:msg2rec(H), T);
  msg(T, _) ->
      T.
  
  dict(['ACR' | _]) ->
  