anchor.diff:  
   %% ===========================================================================
   
  -%% Fraction of shuffle/parallel groups to randomly skip.
  --define(SKIP, 0.90).
  -
  -%% Positive number of testcases from which to select (randomly) from
  -%% tc(), the list of testcases to run, or [] to run all. The random
  -%% selection is to limit the time it takes for the suite to run.
  --define(LIMIT, #{tcp => 42, sctp => 5}).
  -
   -define(util, diameter_util).
   
   -define(A, list_to_atom).
  
positive.code: init_per_group(_) ->
      [{timetrap, {seconds, 30}}].
  
  init_per_group(Name, Config)
    when Name == shuffle;
         Name == parallel ->
      start_services(Config),
      add_transports(Config),
      replace({sleep, Name == parallel}, Config);
  
  init_per_group(sctp = Name, Config) ->
      {_, Sctp} = lists:keyfind(Name, 1, Config),
      if Sctp ->
              Config;
         true ->
              {skip, Name}
      end;
  
  init_per_group(Name, Config) ->
      Nas = proplists:get_value(rfc4005, Config, false),
      case ?util:name(Name) of
          [_,R,_,_,_,_,_,_] when R == rfc4005, true /= Nas ->
              {skip, rfc4005};
          [T,R,E,D,S,ST,SS,CS] ->
              G = #group{transport = T,
                         strings = S,
                         encoding = E,
                         client_service = [$C|?util:unique_string()],
                         client_dict = appdict(R),
                         client_sender = CS,
                         server_service = [$S|?util:unique_string()],
                         server_decoding = D,
                         server_sender = SS,
                         server_throttle = ST},
              replace([{group, G}, {runlist, select(T)}], Config);
          _ ->
              Config
      end.
  
  end_per_group(Name, Config)
    when Name == shuffle;
         Name == parallel ->
      remove_transports(Config),
      stop_services(Config);
  
  end_per_group(_, _) ->
      ok.
  
  select(T) ->
      try maps:get(T, ?LIMIT) of
          N ->
              lists:sublist(?util:scramble(tc()), max(5, rand:uniform(N)))
      catch
          error:_ -> ?LIMIT
      end.
  
  %% --------------------
  
  
negative.code: 
  %% Skip testcases that can reasonably fail under SCTP.
  init_per_testcase(Name, Config) ->
      case [G || #group{transport = sctp} = G
                     <- [proplists:get_value(group, Config)]]
      of
          [_] when Name == send_maxlen;
                   Name == send_long ->
              {skip, sctp};
          _ ->
              [{testcase, Name} | Config]
      end.
  
  end_per_testcase(_, _) ->
      ok.
  
  %% --------------------
  
  