anchor.diff:  		exit:{skipped, SkipReason} ->
   		    io:format(" => skipping group: ~p~n", [SkipReason]),
   		    [{skipped, {Mod, Group}, SkipReason, 0}];
  -		exit:{undef, _} ->
  +		error:undef ->
   		    [t({Mod, Case, Groups}, Config) || 
   			      Case <- GroupsAndCases];
   		T:E ->
  
positive.code: 		  end,
  	    t(lists:map(Map, Cases), Config);
  
          {'EXIT', {undef, _}} ->
  	    io:format("Undefined:   ~p~n", [{Mod, Fun}]),
  	    [{nyi, {Mod, Fun}, ok, 0}];
  		    
          Error ->
  	    io:format("Ignoring:   ~p: ~p~n", [{Mod, Fun}, Error]),
  	    [{failed, {Mod, Fun}, Error, 0}]
      end;
  t(Mod, Config) when is_atom(Mod) ->
      io:format("~w:t -> entry with"
  	      "~n   Mod:    ~p"
  	      "~n   Config: ~p"
  	      "~n", [?MODULE, Mod, Config]),    
      %% This is assumed to be a test suite, so we start by calling 
      %% the top test suite function(s) (all/0 and groups/0).
      case (catch Mod:all()) of
  	Cases when is_list(Cases) -> 
  	    %% The list may contain atoms (actual test cases) and
  	    %% group-tuples (a tuple naming a group of test cases).
  
negative.code: %%     {Mod, Fun, ExpectedRes, ActualRes}
  %%----------------------------------------------------------------------
  
  tickets([Mod]) ->
      tickets(Mod);
  tickets(Mod) when is_atom(Mod) ->
      %% p("tickets -> entry with"
      %% 	      "~n   Mod: ~p", [Mod]),
      Res0 = t({Mod, {group, tickets}, Mod:groups()}, default_config()),
      Res  = lists:flatten(Res0),
      %% p("tickets(~w) -> Res: ~p~n", [Mod, Res]),
      display_result(Res),
      Res.
  
  