anchor.diff:  groups() ->
       [{P, [P], Ts} || Ts <- [tc(tc())], P <- [shuffle, parallel]]
           ++
  -        [{?util:name([T,R,D,A,C,SD,SS,ST,CD,CS]),
  +        [{?util:name([T,R,D,A,C,S,SS,ST,CS]),
             [],
  -          [{group, if SD orelse CD -> shuffle; true -> parallel end}]}
  +          [{group, if S -> shuffle; not S -> parallel end}]}
            || T <- ?TRANSPORTS,
               R <- ?ENCODINGS,
               D <- ?RFCS,
               A <- ?ENCODINGS,
               C <- ?CONTAINERS,
  -            SD <- ?STRING_DECODES,
  +            S <- ?STRING_DECODES,
               SS <- ?SENDERS,
               ST <- ?CALLBACKS,
  -            CD <- ?STRING_DECODES,
               CS <- ?SENDERS]
           ++
  -        [{T, [], groups([[T,R,D,A,C,SD,SS,ST,CD,CS]
  +        [{T, [], groups([[T,R,D,A,C,S,SS,ST,CS]
                            || R <- ?ENCODINGS,
                               D <- ?RFCS,
                               A <- ?ENCODINGS,
                               C <- ?CONTAINERS,
  -                            SD <- ?STRING_DECODES,
  +                            S <- ?STRING_DECODES,
                               SS <- ?SENDERS,
                               ST <- ?CALLBACKS,
  -                            CD <- ?STRING_DECODES,
                               CS <- ?SENDERS,
                               SS orelse CS])}  %% avoid deadlock
            || T <- ?TRANSPORTS]
  
positive.code:     ok = diameter:start().
  
  start_services(Config) ->
      #group{client_service = CN,
             client_strings = CD,
             server_service = SN,
             server_strings = SD}
          = group(Config),
      ok = diameter:start_service(SN, ?SERVICE(SN, SD)),
      ok = diameter:start_service(CN, [{sequence, ?CLIENT_MASK}
                                       | ?SERVICE(CN, CD)]).
  
  add_transports(Config) ->
      #group{transport = T,
  
negative.code: 
  init_per_group(Name, Config) ->
      case ?util:name(Name) of
          [T,R,D,A,C,S,SS,ST,CS] ->
              G = #group{transport = T,
                         strings = S,
                         client_service = [$C|?util:unique_string()],
                         client_encoding = R,
                         client_dict0 = dict0(D),
                         client_sender = CS,
                         server_service = [$S|?util:unique_string()],
                         server_encoding = A,
                         server_container = C,
                         server_sender = SS,
                         server_throttle = ST},
              %% Limit the number of testcase, since the number of
  