Add groups in test specifications

Ongoing work...

3 files changed, 137 insertions, 15 deletions

diff --git a/lib/common_test/src/ct_framework.erl b/lib/common_test/src/ct_framework.erl
index 89bbc2448f..60978209b3 100644
--- a/lib/common_test/src/ct_framework.erl
+++ b/lib/common_test/src/ct_framework.erl
@@ -631,7 +631,7 @@ group_or_func(Func, _Config) ->
 %%%      and every test case. If the former, all test cases in the suite
 %%%      should be returned. 
 
-get_suite(Mod, all) ->    
+get_suite(Mod, all) ->
     case catch apply(Mod, groups, []) of
 	{'EXIT',_} ->
 	    get_all(Mod, []);
@@ -667,12 +667,18 @@ get_suite(Mod, Name) ->
 		    %% (and only) test case so we can report Error properly
 		    [{?MODULE,error_in_suite,[[Error]]}];
 		ConfTests ->
+
+		    %%! --- Thu Jun  3 19:13:22 2010 --- peppe was here!
+		    %%! HEERE!
+		    %%! Must be able to search recursively for group Name,
+		    %%! this only handles top level groups!
+
 		    FindConf = fun({conf,Props,_,_,_}) ->
 				       case proplists:get_value(name, Props) of
 					   Name -> true;
 					   _    -> false
 				       end
-			       end,					 
+			       end,
 		    case lists:filter(FindConf, ConfTests) of
 			[] ->			% must be a test case
 			    get_seq(Mod, Name);
diff --git a/lib/common_test/src/ct_run.erl b/lib/common_test/src/ct_run.erl
index 7037ac7c1e..0d4a5b31dc 100644
--- a/lib/common_test/src/ct_run.erl
+++ b/lib/common_test/src/ct_run.erl
@@ -510,10 +510,6 @@ install(Opts, LogDir) ->
     case whereis(ct_util_server) of
 	undefined ->
 	    VarFile = variables_file_name(LogDir),
-
-	    %%! --- Tue Jun  1 00:20:33 2010 --- peppe was here!
-	    io:format("Varfile = ~p~n", [VarFile]),
-
 	    case file:open(VarFile, [write]) of
 		{ok,Fd} ->
 		    [io:format(Fd, "~p.\n", [Opt]) || Opt <- Opts],
@@ -1535,13 +1531,27 @@ add_jobs([{TestDir,Suite,all}|Tests], Skip, Opts, CleanUp) ->
 	Error ->
 	    Error
     end;
+
+%% group
+add_jobs([{TestDir,Suite,[{GroupName,_Cases}]}|Tests], Skip, Opts, CleanUp) when
+      is_atom(GroupName) ->
+    add_jobs([{TestDir,Suite,GroupName}|Tests], Skip, Opts, CleanUp);
+add_jobs([{TestDir,Suite,{GroupName,_Cases}}|Tests], Skip, Opts, CleanUp) when
+      is_atom(GroupName) ->
+    add_jobs([{TestDir,Suite,GroupName}|Tests], Skip, Opts, CleanUp);
+
+%% test case
 add_jobs([{TestDir,Suite,[Case]}|Tests], Skip, Opts, CleanUp) when is_atom(Case) ->
     add_jobs([{TestDir,Suite,Case}|Tests], Skip, Opts, CleanUp);
+
 add_jobs([{TestDir,Suite,Cases}|Tests], Skip, Opts, CleanUp) when is_list(Cases) ->
-    case maybe_interpret(Suite, Cases, Opts) of
+    Cases1 = lists:map(fun({GroupName,_}) when is_atom(GroupName) -> GroupName;
+			  (Case) -> Case
+		       end, Cases),
+    case maybe_interpret(Suite, Cases1, Opts) of
 	ok ->
 	    Name =  get_name(TestDir) ++ "." ++	atom_to_list(Suite) ++ ".cases",
-	    case catch test_server_ctrl:add_cases_with_skip(Name, Suite, Cases,
+	    case catch test_server_ctrl:add_cases_with_skip(Name, Suite, Cases1,
 							    skiplist(TestDir,Skip)) of
 		{'EXIT',_} ->
 		    CleanUp;
diff --git a/lib/common_test/src/ct_testspec.erl b/lib/common_test/src/ct_testspec.erl
index dc017921cc..0f68b062f6 100644
--- a/lib/common_test/src/ct_testspec.erl
+++ b/lib/common_test/src/ct_testspec.erl
@@ -631,16 +631,29 @@ add_tests([{suites,Node,Dir,Ss}|Ts],Spec) ->
 %% by means of groups defined only in the test specification.
 add_tests([{groups,all_nodes,Dir,Suite,Gs}|Ts],Spec) ->
     add_tests([{groups,list_nodes(Spec),Dir,Suite,Gs}|Ts],Spec);
+add_tests([{groups,all_nodes,Dir,Suite,Gs,{cases,TCs}}|Ts],Spec) ->
+    add_tests([{groups,list_nodes(Spec),Dir,Suite,Gs,{cases,TCs}}|Ts],Spec);
 add_tests([{groups,Dir,Suite,Gs}|Ts],Spec) ->
     add_tests([{groups,all_nodes,Dir,Suite,Gs}|Ts],Spec);
+add_tests([{groups,Dir,Suite,Gs,{cases,TCs}}|Ts],Spec) ->
+    add_tests([{groups,all_nodes,Dir,Suite,Gs,{cases,TCs}}|Ts],Spec);
 add_tests([{groups,Nodes,Dir,Suite,Gs}|Ts],Spec) when is_list(Nodes) ->
     Ts1 = separate(Nodes,groups,[Dir,Suite,Gs],Ts,Spec#testspec.nodes),
     add_tests(Ts1,Spec);
+add_tests([{groups,Nodes,Dir,Suite,Gs,{cases,TCs}}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,groups,[Dir,Suite,Gs,{cases,TCs}],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
 add_tests([{groups,Node,Dir,Suite,Gs}|Ts],Spec) ->
     Tests = Spec#testspec.tests,
-    Tests1 = insert_cases(ref2node(Node,Spec#testspec.nodes),
+    Tests1 = insert_groups(ref2node(Node,Spec#testspec.nodes),
+			   ref2dir(Dir,Spec#testspec.alias),
+			   Suite,Gs,all,Tests),
+    add_tests(Ts,Spec#testspec{tests=Tests1});
+add_tests([{groups,Node,Dir,Suite,Gs,{cases,TCs}}|Ts],Spec) ->
+    Tests = Spec#testspec.tests,
+    Tests1 = insert_groups(ref2node(Node,Spec#testspec.nodes),
 			   ref2dir(Dir,Spec#testspec.alias),
-			   Suite,Gs,Tests),
+			   Suite,Gs,TCs,Tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
 
 %% --- cases ---
@@ -676,16 +689,29 @@ add_tests([{skip_suites,Node,Dir,Ss,Cmt}|Ts],Spec) ->
 %% --- skip_groups ---
 add_tests([{skip_groups,all_nodes,Dir,Suite,Gs,Cmt}|Ts],Spec) ->
     add_tests([{skip_groups,list_nodes(Spec),Dir,Suite,Gs,Cmt}|Ts],Spec);
+add_tests([{skip_groups,all_nodes,Dir,Suite,Gs,{cases,TCs},Cmt}|Ts],Spec) ->
+    add_tests([{skip_groups,list_nodes(Spec),Dir,Suite,Gs,{cases,TCs},Cmt}|Ts],Spec);
 add_tests([{skip_groups,Dir,Suite,Gs,Cmt}|Ts],Spec) ->
     add_tests([{skip_groups,all_nodes,Dir,Suite,Gs,Cmt}|Ts],Spec);
+add_tests([{skip_groups,Dir,Suite,Gs,{cases,TCs},Cmt}|Ts],Spec) ->
+    add_tests([{skip_groups,all_nodes,Dir,Suite,Gs,{cases,TCs},Cmt}|Ts],Spec);
 add_tests([{skip_groups,Nodes,Dir,Suite,Gs,Cmt}|Ts],Spec) when is_list(Nodes) ->
     Ts1 = separate(Nodes,skip_groups,[Dir,Suite,Gs,Cmt],Ts,Spec#testspec.nodes),
     add_tests(Ts1,Spec);
+add_tests([{skip_groups,Nodes,Dir,Suite,Gs,{cases,TCs},Cmt}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,skip_groups,[Dir,Suite,Gs,{cases,TCs},Cmt],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
 add_tests([{skip_groups,Node,Dir,Suite,Gs,Cmt}|Ts],Spec) ->
     Tests = Spec#testspec.tests,
-    Tests1 = skip_cases(ref2node(Node,Spec#testspec.nodes),
-			ref2dir(Dir,Spec#testspec.alias),
-			Suite,Gs,Cmt,Tests),
+    Tests1 = skip_groups(ref2node(Node,Spec#testspec.nodes),
+			 ref2dir(Dir,Spec#testspec.alias),
+			 Suite,Gs,all,Cmt,Tests),
+    add_tests(Ts,Spec#testspec{tests=Tests1});
+add_tests([{skip_groups,Node,Dir,Suite,Gs,{cases,TCs},Cmt}|Ts],Spec) ->
+    Tests = Spec#testspec.tests,
+    Tests1 = skip_groups(ref2node(Node,Spec#testspec.nodes),
+			 ref2dir(Dir,Spec#testspec.alias),
+			 Suite,Gs,TCs,Cmt,Tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
 
 %% --- skip_cases ---
@@ -756,8 +782,11 @@ separate([],_,_,_) ->
     
 
 %% Representation:
-%% {{Node,Dir},[{Suite1,[case11,case12,...]},{Suite2,[case21,case22,...]},...]}
-%% {{Node,Dir},[{Suite1,{skip,Cmt}},{Suite2,[{case21,{skip,Cmt}},case22,...]},...]}
+%% {{Node,Dir},[{Suite1,[GrOrCase11,GrOrCase12,...]},
+%%              {Suite2,[GrOrCase21,GrOrCase22,...]},...]}
+%% {{Node,Dir},[{Suite1,{skip,Cmt}},
+%%              {Suite2,[{GrOrCase21,{skip,Cmt}},GrOrCase22,...]},...]}
+%% GrOrCase = {GroupName,[Case1,Case2,...]} | Case
 
 insert_suites(Node,Dir,[S|Ss],Tests) ->
     Tests1 = insert_cases(Node,Dir,S,all,Tests),
@@ -767,6 +796,54 @@ insert_suites(_Node,_Dir,[],Tests) ->
 insert_suites(Node,Dir,S,Tests) ->
     insert_suites(Node,Dir,[S],Tests).
 
+insert_groups(Node,Dir,Suite,Group,Cases,Tests) when is_atom(Group) ->
+    insert_groups(Node,Dir,Suite,[Group],Cases,Tests);
+insert_groups(Node,Dir,Suite,Groups,Cases,Tests) when
+      ((Cases == all) or is_list(Cases)) and is_list(Groups) ->
+    case lists:keysearch({Node,Dir},1,Tests) of
+	{value,{{Node,Dir},[{all,_}]}} ->
+	    Tests;
+	{value,{{Node,Dir},Suites0}} ->
+	    Suites1 = insert_groups1(Suite,
+				     [{Gr,Cases} || Gr <- Groups],
+				     Suites0),
+	    insert_in_order({{Node,Dir},Suites1},Tests);
+	false ->
+	    Groups1 = [{Gr,Cases} || Gr <- Groups],
+	    insert_in_order({{Node,Dir},[{Suite,Groups1}]},Tests)
+    end;
+insert_groups(Node,Dir,Suite,Groups,Case,Tests) when is_atom(Case) ->
+    Cases = if Case == all -> all; true -> [Case] end,
+    insert_groups(Node,Dir,Suite,Groups,Cases,Tests).
+
+insert_groups1(_Suite,_Groups,all) ->
+    all;
+insert_groups1(Suite,Groups,Suites0) ->
+    case lists:keysearch(Suite,1,Suites0) of
+	{value,{Suite,all}} ->
+	    Suites0;
+	{value,{Suite,GrAndCases0}} ->
+	    GrAndCases = insert_groups2(Groups,GrAndCases0),
+	    insert_in_order({Suite,GrAndCases},Suites0);
+	false ->
+	    insert_in_order({Suite,Groups},Suites0)
+    end.
+
+insert_groups2(_Groups,all) ->
+    all;
+insert_groups2([Group={GrName,Cases}|Groups],GrAndCases) ->
+    case lists:keysearch(GrName,1,GrAndCases) of
+	{value,{GrName,all}} ->
+	    GrAndCases;
+	{value,{GrName,Cases0}} ->
+	    Cases1 = insert_in_order(Cases,Cases0),
+	    insert_groups2(Groups,insert_in_order({GrName,Cases1},GrAndCases));
+	false ->
+	    insert_groups2(Groups,insert_in_order(Group,GrAndCases))
+    end;
+insert_groups2([],GrAndCases) ->
+    GrAndCases.
+
 insert_cases(Node,Dir,Suite,Cases,Tests) when is_list(Cases) ->
     case lists:keysearch({Node,Dir},1,Tests) of
 	{value,{{Node,Dir},[{all,_}]}} ->
@@ -801,6 +878,35 @@ skip_suites(_Node,_Dir,[],_Cmt,Tests) ->
 skip_suites(Node,Dir,S,Cmt,Tests) ->
     skip_suites(Node,Dir,[S],Cmt,Tests).
 
+skip_groups(Node,Dir,Suite,Group,Case,Cmt,Tests) when is_atom(Group) ->
+    skip_groups(Node,Dir,Suite,[Group],[Case],Cmt,Tests);
+skip_groups(Node,Dir,Suite,Groups,Cases,Cmt,Tests) when
+      ((Cases == all) or is_list(Cases)) and is_list(Groups) ->
+    Suites =
+	case lists:keysearch({Node,Dir},1,Tests) of
+	    {value,{{Node,Dir},Suites0}} ->
+		Suites0;
+	    false ->
+		[]
+	end,
+    Suites1 = skip_groups1(Suite,[{Gr,Cases} || Gr <- Groups],Cmt,Suites),
+    insert_in_order({{Node,Dir},Suites1},Tests);
+skip_groups(Node,Dir,Suite,Groups,Case,Cmt,Tests) when is_atom(Case) ->
+    Cases = if Case == all -> all; true -> [Case] end,
+    skip_groups(Node,Dir,Suite,Groups,Cases,Cmt,Tests).
+
+skip_groups1(Suite,Groups,Cmt,Suites0) ->
+    SkipGroups = lists:map(fun(Group) ->
+				   {Group,{skip,Cmt}}
+			   end,Groups),
+    case lists:keysearch(Suite,1,Suites0) of
+	{value,{Suite,GrAndCases0}} ->
+	    GrAndCases1 = GrAndCases0 ++ SkipGroups,
+	    insert_in_order({Suite,GrAndCases1},Suites0);
+	false ->
+	    insert_in_order({Suite,SkipGroups},Suites0)
+    end.
+
 skip_cases(Node,Dir,Suite,Cases,Cmt,Tests) when is_list(Cases) ->
     Suites =
 	case lists:keysearch({Node,Dir},1,Tests) of