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: 
  -record(group,
          {transport,
           client_service,
           client_encoding,
           client_dict0,
           client_strings,
           client_sender,
           server_service,
           server_encoding,
           server_container,
           server_strings,
           server_sender,
           server_throttle}).
  
  
negative.code:     #group{} = proplists:get_value(group, Config).
  
  string(V, Config) ->
      #group{strings = B} = group(Config),
      decode(V,B).
  
  decode(S, true)
  