Implement constants and new features for test specifications

OTP-10049
OTP-10089

1 files changed, 345 insertions, 331 deletions

diff --git a/lib/common_test/src/ct_testspec.erl b/lib/common_test/src/ct_testspec.erl
index 4c05f57520..293ff00b07 100644
--- a/lib/common_test/src/ct_testspec.erl
+++ b/lib/common_test/src/ct_testspec.erl
@@ -29,6 +29,8 @@
 
 -include("ct_util.hrl").
 
+-define(testspec_fields, record_info(fields, testspec)).
+
 %%%------------------------------------------------------------------
 %%% NOTE:
 %%% Multiple testspecs may be used as input with the result that
@@ -46,9 +48,16 @@
 %%% Version 1 - extract and return all tests and skips for Node 
 %%%             (incl all_nodes)
 %%%-------------------------------------------------------------------
-prepare_tests(TestSpec,Node) when is_record(TestSpec,testspec), is_atom(Node) ->
-    case lists:keysearch(Node,1,prepare_tests(TestSpec)) of
-	{value,{Node,Run,Skip}} ->
+prepare_tests(TestSpec,Node) when is_record(TestSpec,testspec) ->
+    Node1 = case Node of
+		{N,H} when is_atom(N), is_atom(H) ->
+		    list_to_atom(atom_to_list(N) ++ "@"
+				 ++ atom_to_list(H));
+		N when is_atom(N) ->
+		    N
+	    end,
+    case lists:keysearch(Node1,1,prepare_tests(TestSpec)) of
+	{value,{Node1,Run,Skip}} ->
 	    {Run,Skip};
 	false ->
 	    {[],[]}
@@ -278,7 +287,8 @@ collect_tests_from_list(Terms,Nodes,Relaxed) when is_list(Nodes) ->
 	E = {error,_} ->
 	    E;
 	TS ->
-	    #testspec{config=Cfgs,event_handler=EvHs,include=Incl,tests=Tests} = TS,
+	    #testspec{config=Cfgs,event_handler=EvHs,
+		      include=Incl,tests=Tests} = TS,
 	    TS#testspec{config=lists:reverse(Cfgs),
 			event_handler=lists:reverse(EvHs),
 			include=lists:reverse(Incl),
@@ -287,21 +297,84 @@ collect_tests_from_list(Terms,Nodes,Relaxed) when is_list(Nodes) ->
     
 collect_tests(Terms,TestSpec,Relaxed) ->
     put(relaxed,Relaxed),
-    TestSpec1 = get_global(Terms,TestSpec),
-    TestSpec2 = get_all_nodes(Terms,TestSpec1),
-    {Terms2, TestSpec3} = filter_init_terms(Terms, [], TestSpec2),
+    Terms1 = replace_names(Terms),
+
+    %%! --- Fri Aug 10 22:51:23 2012 --- peppe was here!
+    io:format(user, "~nTERMS:~n", []),
+    [io:format(user, "~p~n", [T]) || T <- Terms1],
+
+    TestSpec1 = get_global(Terms1,TestSpec),
+    TestSpec2 = get_all_nodes(Terms1,TestSpec1),
+    {Terms2, TestSpec3} = filter_init_terms(Terms1, [], TestSpec2),
     add_tests(Terms2,TestSpec3).
 
-get_global([{merge_tests, Bool} | Ts], Spec) ->
-    get_global(Ts,Spec#testspec{ merge_tests = Bool });
+%% replace names (atoms) in the testspec matching those in 'define' terms by
+%% searching recursively through tuples and lists
+replace_names(Terms) ->
+    Defs = lists:flatmap(fun({define,Name,Replacement}) ->
+				 [{Name,Replacement}];
+			    (_) -> []
+			 end, Terms),
+    replace_names(Terms,[],Defs).
+
+replace_names([{define,_,_}|Ts],Modified,Defs) ->
+    replace_names(Ts,Modified,Defs);
+replace_names([Term|Ts],Modified,Defs) when is_tuple(Term) ->
+    [TypeTag|Data] = tuple_to_list(Term),
+    Term1 = list_to_tuple([TypeTag|replace_names_in_elems(Data,[],Defs)]),
+    replace_names(Ts,[Term1|Modified],Defs);
+replace_names([Term|Ts],Modified,Defs) when is_atom(Term) ->
+    case proplists:get_value(Term,Defs) of
+	undefined -> replace_names(Ts,[Term|Modified],Defs);
+	Replacement -> replace_names(Ts,[Replacement|Modified],Defs)
+    end;
+replace_names([Term|Ts],Modified,Defs) ->
+    replace_names(Ts,[Term|Modified],Defs);
+replace_names([],Modified,_Defs) ->
+    lists:reverse(Modified).
+
+replace_names_in_elems([Elem|Es],Modified,Defs) when is_tuple(Elem) ->
+    Elem1 = list_to_tuple(replace_names_in_elems(tuple_to_list(Elem),[],Defs)),
+    replace_names_in_elems(Es,[Elem1|Modified],Defs);
+replace_names_in_elems([Elem|Es],Modified,Defs) when is_atom(Elem) ->
+    case proplists:get_value(Elem,Defs) of
+	undefined -> replace_names_in_elems(Es,[Elem|Modified],Defs);
+	Replacement -> replace_names_in_elems(Es,[Replacement|Modified],Defs)
+    end;
+replace_names_in_elems([Str=[Char|_]|Es],Modified,Defs) when is_integer(Char) ->
+    replace_names_in_elems(Es,[Str|Modified],Defs);
+replace_names_in_elems([Elem|Es],Modified,Defs) when is_list(Elem) ->
+    List = replace_names_in_elems(Elem,[],Defs),
+    replace_names_in_elems(Es,[List|Modified],Defs);
+replace_names_in_elems([Elem|Es],Modified,Defs) ->
+    replace_names_in_elems(Es,[Elem|Modified],Defs);
+replace_names_in_elems([],Modified,_Defs) ->
+    lists:reverse(Modified).
+
+
+%% global terms that will be used for analysing all other terms in the spec
+get_global([{merge_tests,Bool} | Ts], Spec) ->
+    get_global(Ts,Spec#testspec{merge_tests=Bool});
+
+%% the 'define' term replaces the 'alias' and 'node' terms, but we need to keep
+%% the latter two for backwards compatibility...
 get_global([{alias,Ref,Dir}|Ts],Spec=#testspec{alias=Refs}) ->
     get_global(Ts,Spec#testspec{alias=[{Ref,get_absdir(Dir,Spec)}|Refs]});
 get_global([{node,Ref,Node}|Ts],Spec=#testspec{nodes=Refs}) ->
-    get_global(Ts,Spec#testspec{nodes=[{Ref,Node}|lists:keydelete(Node,2,Refs)]});
+    Node1 = case Node of
+		{N,H} when is_atom(N), is_atom(H) ->
+		    list_to_atom(atom_to_list(N) ++ "@"
+				 ++ atom_to_list(H));
+		_ ->
+		    Node
+	    end,
+    get_global(Ts,Spec#testspec{nodes=[{Ref,Node1} |
+				       lists:keydelete(Node1,2,Refs)]});
+
 get_global([_|Ts],Spec) -> get_global(Ts,Spec);
 get_global([],Spec) -> Spec.
 
-get_absfile(Callback, FullName,#testspec{spec_dir=SpecDir}) ->
+get_absfile(Callback,FullName,#testspec{spec_dir=SpecDir}) ->
     % we need to temporary switch to new cwd here, because
     % otherwise config files cannot be found
     {ok, OldWd} = file:get_cwd(),
@@ -321,11 +394,15 @@ get_absfile(Callback, FullName,#testspec{spec_dir=SpecDir}) ->
 	    FullName
     end.
 
+get_absfile(Split=[[Ch|_]|_],Spec) when is_integer(Ch) ->
+    get_absfile(filename:join(Split),Spec);
 get_absfile(FullName,#testspec{spec_dir=SpecDir}) ->
     File = filename:basename(FullName),
     Dir = get_absname(filename:dirname(FullName),SpecDir),
     filename:join(Dir,File).
 
+get_absdir(Split=[[Ch|_]|_],Spec) when is_integer(Ch) ->
+    get_absdir(filename:join(Split),Spec);
 get_absdir(Dir,#testspec{spec_dir=SpecDir}) ->
     get_absname(Dir,SpecDir).
 
@@ -370,36 +447,41 @@ get_all_nodes([],Spec) ->
     Spec.
 
 filter_init_terms([{init, InitOptions}|Ts], NewTerms, Spec)->
-    filter_init_terms([{init, list_nodes(Spec), InitOptions}|Ts], NewTerms, Spec);
-filter_init_terms([{init, NodeRef, InitOptions}|Ts], NewTerms, Spec)
-    when is_atom(NodeRef)->
+    filter_init_terms([{init, list_nodes(Spec), InitOptions}|Ts],
+		      NewTerms, Spec);
+filter_init_terms([{init, NodeRef, InitOptions}|Ts],
+		  NewTerms, Spec) when is_atom(NodeRef)->
     filter_init_terms([{init, [NodeRef], InitOptions}|Ts], NewTerms, Spec);
-filter_init_terms([{init, NodeRefs, InitOption}|Ts], NewTerms, Spec) when is_tuple(InitOption) ->
+filter_init_terms([{init, NodeRefs, InitOption}|Ts],
+		  NewTerms, Spec) when is_tuple(InitOption) ->
     filter_init_terms([{init, NodeRefs, [InitOption]}|Ts], NewTerms, Spec);
-filter_init_terms([{init, [NodeRef|NodeRefs], InitOptions}|Ts], NewTerms, Spec=#testspec{init=InitData})->
-    NodeStartOptions = case lists:keyfind(node_start, 1, InitOptions) of
-	{node_start, NSOptions}->
-	    case lists:keyfind(callback_module, 1, NSOptions) of
-		{callback_module, _Callback}->
-		    NSOptions;
-		false->
-		    [{callback_module, ct_slave}|NSOptions]
-	    end;
-	false->
-	    []
-    end,
+filter_init_terms([{init, [NodeRef|NodeRefs], InitOptions}|Ts],
+		  NewTerms, Spec=#testspec{init=InitData})->
+    NodeStartOptions =
+	case lists:keyfind(node_start, 1, InitOptions) of
+	    {node_start, NSOptions}->
+		case lists:keyfind(callback_module, 1, NSOptions) of
+		    {callback_module, _Callback}->
+			NSOptions;
+		    false->
+			[{callback_module, ct_slave}|NSOptions]
+		end;
+	    false->
+		[]
+	end,
     EvalTerms = case lists:keyfind(eval, 1, InitOptions) of
-	{eval, MFA} when is_tuple(MFA)->
-	    [MFA];
-	{eval, MFAs} when is_list(MFAs)->
-	    MFAs;
-	false->
-	    []
-    end,
+		    {eval, MFA} when is_tuple(MFA)->
+			[MFA];
+		    {eval, MFAs} when is_list(MFAs)->
+			MFAs;
+		    false->
+			[]
+		end,
     Node = ref2node(NodeRef,Spec#testspec.nodes),
     InitData2 = add_option({node_start, NodeStartOptions}, Node, InitData, true),
     InitData3 = add_option({eval, EvalTerms}, Node, InitData2, false),
-    filter_init_terms([{init, NodeRefs, InitOptions}|Ts], NewTerms, Spec#testspec{init=InitData3});
+    filter_init_terms([{init, NodeRefs, InitOptions}|Ts],
+		      NewTerms, Spec#testspec{init=InitData3});
 filter_init_terms([{init, [], _}|Ts], NewTerms, Spec)->
     filter_init_terms(Ts, NewTerms, Spec);
 filter_init_terms([Term|Ts], NewTerms, Spec)->
@@ -416,7 +498,8 @@ add_option({Key, Value}, Node, List, WarnIfExists) when is_list(Value)->
     end,
     NewOption = case lists:keyfind(Key, 1, OldOptions) of
 	{Key, OldOption} when WarnIfExists, OldOption/=[]->
-	    io:format("There is an option ~w=~w already defined for node ~p, skipping new ~w~n",
+	    io:format("There is an option ~w=~w already "
+		      "defined for node ~p, skipping new ~w~n",
 		[Key, OldOption, Node, Value]),
 	    OldOption;
 	{Key, OldOption}->
@@ -446,267 +529,18 @@ save_nodes(Nodes,Spec=#testspec{nodes=NodeRefs}) ->
 				    end
 			    end
 		    end,NodeRefs,Nodes),
-    Spec#testspec{nodes=NodeRefs1}.    							
+    Spec#testspec{nodes=NodeRefs1}.
 
 list_nodes(#testspec{nodes=NodeRefs}) ->
     lists:map(fun({_Ref,Node}) -> Node end, NodeRefs).		      
 
 
-
-%%     ---------------------------------------------------------
-%%   /                                                           \
-%%  |  When adding tests, remember to update valid_terms/0 also!  |
-%%   \                                                           /
-%%     ---------------------------------------------------------
-
-
-%% Associate a "global" logdir with all nodes
-%% except those with specific logdir, e.g:
-%% ["/tmp/logdir",{ct1@finwe,"/tmp/logdir2"}]
-%% means all nodes should write to /tmp/logdir
-%% except ct1@finwe that should use /tmp/logdir2.
-
-%% --- logdir ---
-add_tests([{logdir,all_nodes,Dir}|Ts],Spec) ->
-    Dirs = Spec#testspec.logdir,
-    Tests = [{logdir,N,get_absdir(Dir,Spec)} || 
-		N <- list_nodes(Spec),
-		lists:keymember(ref2node(N,Spec#testspec.nodes),
-				1,Dirs) == false],
-    add_tests(Tests++Ts,Spec);
-add_tests([{logdir,Nodes,Dir}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,logdir,[Dir],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);    
-add_tests([{logdir,Node,Dir}|Ts],Spec) ->
-    Dirs = Spec#testspec.logdir,
-    Dirs1 = [{ref2node(Node,Spec#testspec.nodes),get_absdir(Dir,Spec)} |
-	     lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,Dirs)],
-    add_tests(Ts,Spec#testspec{logdir=Dirs1});
-add_tests([{logdir,Dir}|Ts],Spec) ->
-    add_tests([{logdir,all_nodes,Dir}|Ts],Spec);
-
-%% --- logopts ---
-add_tests([{logopts,all_nodes,Opts}|Ts],Spec) ->
-    LogOpts = Spec#testspec.logopts,
-    Tests = [{logopts,N,Opts} ||
-		N <- list_nodes(Spec),
-		lists:keymember(ref2node(N,Spec#testspec.nodes),1,
-				LogOpts) == false],
-    add_tests(Tests++Ts,Spec);
-add_tests([{logopts,Nodes,Opts}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,logopts,[Opts],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{logopts,Node,Opts}|Ts],Spec) ->
-    LogOpts = Spec#testspec.logopts,
-    LogOpts1 = [{ref2node(Node,Spec#testspec.nodes),Opts} |
-		lists:keydelete(ref2node(Node,Spec#testspec.nodes),
-				1,LogOpts)],
-    add_tests(Ts,Spec#testspec{logopts=LogOpts1});
-add_tests([{logopts,Opts}|Ts],Spec) ->
-    add_tests([{logopts,all_nodes,Opts}|Ts],Spec);
-
-%% --- label ---
-add_tests([{label,all_nodes,Lbl}|Ts],Spec) ->
-    Labels = Spec#testspec.label,
-    Tests = [{label,N,Lbl} || N <- list_nodes(Spec),
-			      lists:keymember(ref2node(N,Spec#testspec.nodes),
-					      1,Labels) == false],
-    add_tests(Tests++Ts,Spec);
-add_tests([{label,Nodes,Lbl}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,label,[Lbl],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{label,Node,Lbl}|Ts],Spec) ->
-    Labels = Spec#testspec.label,
-    Labels1 = [{ref2node(Node,Spec#testspec.nodes),Lbl} |
-	       lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,Labels)],
-    add_tests(Ts,Spec#testspec{label=Labels1});
-add_tests([{label,Lbl}|Ts],Spec) ->
-    add_tests([{label,all_nodes,Lbl}|Ts],Spec);
-
-%% --- cover ---
-add_tests([{cover,all_nodes,File}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {cover,N,File} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{cover,Nodes,File}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,cover,[File],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);    
-add_tests([{cover,Node,File}|Ts],Spec) ->
-    CoverFs = Spec#testspec.cover,
-    CoverFs1 = [{ref2node(Node,Spec#testspec.nodes),get_absfile(File,Spec)} |
-		lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,CoverFs)],
-    add_tests(Ts,Spec#testspec{cover=CoverFs1});
-add_tests([{cover,File}|Ts],Spec) ->
-    add_tests([{cover,all_nodes,File}|Ts],Spec);
-
-%% --- multiply_timetraps ---
-add_tests([{multiply_timetraps,all_nodes,MT}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {multiply_timetraps,N,MT} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{multiply_timetraps,Nodes,MT}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,multiply_timetraps,[MT],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{multiply_timetraps,Node,MT}|Ts],Spec) ->
-    MTs = Spec#testspec.multiply_timetraps,
-    MTs1 = [{ref2node(Node,Spec#testspec.nodes),MT} |
-	    lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,MTs)],
-    add_tests(Ts,Spec#testspec{multiply_timetraps=MTs1});
-add_tests([{multiply_timetraps,MT}|Ts],Spec) ->
-    add_tests([{multiply_timetraps,all_nodes,MT}|Ts],Spec);
-
-%% --- scale_timetraps ---
-add_tests([{scale_timetraps,all_nodes,ST}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {scale_timetraps,N,ST} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{scale_timetraps,Nodes,ST}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,scale_timetraps,[ST],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{scale_timetraps,Node,ST}|Ts],Spec) ->
-    STs = Spec#testspec.scale_timetraps,
-    STs1 = [{ref2node(Node,Spec#testspec.nodes),ST} |
-	    lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,STs)],
-    add_tests(Ts,Spec#testspec{scale_timetraps=STs1});
-add_tests([{scale_timetraps,ST}|Ts],Spec) ->
-    add_tests([{scale_timetraps,all_nodes,ST}|Ts],Spec);
-
-%% --- create_priv_dir ---
-add_tests([{create_priv_dir,all_nodes,PD}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {create_priv_dir,N,PD} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{create_priv_dir,Nodes,PD}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,create_priv_dir,[PD],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{create_priv_dir,Node,PD}|Ts],Spec) ->
-    PDs = Spec#testspec.create_priv_dir,
-    PDs1 = [{ref2node(Node,Spec#testspec.nodes),PD} |
-	    lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,PDs)],
-    add_tests(Ts,Spec#testspec{create_priv_dir=PDs1});
-add_tests([{create_priv_dir,PD}|Ts],Spec) ->
-    add_tests([{create_priv_dir,all_nodes,PD}|Ts],Spec);
-
-%% --- config ---
-add_tests([{config,all_nodes,Files}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {config,N,Files} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{config,Nodes,Files}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,config,[Files],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{config,Node,[F|Fs]}|Ts],Spec) when is_list(F) ->
-    Cfgs = Spec#testspec.config,
-    Node1 = ref2node(Node,Spec#testspec.nodes),
-    add_tests([{config,Node,Fs}|Ts],
-	      Spec#testspec{config=[{Node1,get_absfile(F,Spec)}|Cfgs]});
-add_tests([{config,_Node,[]}|Ts],Spec) ->
-    add_tests(Ts,Spec);
-add_tests([{config,Node,F}|Ts],Spec) ->
-    add_tests([{config,Node,[F]}|Ts],Spec);
-add_tests([{config,Files}|Ts],Spec) ->
-    add_tests([{config,all_nodes,Files}|Ts],Spec);
-
-
-%% --- userconfig ---
-add_tests([{userconfig,all_nodes,CBF}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {userconfig,N,CBF} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{userconfig,Nodes,CBF}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,userconfig,[CBF],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{userconfig,Node,[{Callback, Config}|CBF]}|Ts],Spec) ->
-    Cfgs = Spec#testspec.userconfig,
-    Node1 = ref2node(Node,Spec#testspec.nodes),
-    add_tests([{userconfig,Node,CBF}|Ts],
-	      Spec#testspec{userconfig=[{Node1,{Callback,
-				get_absfile(Callback, Config ,Spec)}}|Cfgs]});
-add_tests([{userconfig,_Node,[]}|Ts],Spec) ->
-    add_tests(Ts,Spec);
-add_tests([{userconfig,Node,CBF}|Ts],Spec) ->
-    add_tests([{userconfig,Node,[CBF]}|Ts],Spec);
-add_tests([{userconfig,CBF}|Ts],Spec) ->
-    add_tests([{userconfig,all_nodes,CBF}|Ts],Spec);
-
-%% --- event_handler ---
-add_tests([{event_handler,all_nodes,Hs}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {event_handler,N,Hs,[]} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{event_handler,all_nodes,Hs,Args}|Ts],Spec) when is_list(Args) ->
-    Tests = lists:map(fun(N) -> {event_handler,N,Hs,Args} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{event_handler,Hs}|Ts],Spec) ->
-    add_tests([{event_handler,all_nodes,Hs,[]}|Ts],Spec);
-add_tests([{event_handler,HsOrNodes,HsOrArgs}|Ts],Spec) ->
-    case is_noderef(HsOrNodes,Spec#testspec.nodes) of
-	true ->					% HsOrNodes == Nodes, HsOrArgs == Hs
-	    case {HsOrNodes,HsOrArgs} of
-		{Nodes,Hs} when is_list(Nodes) ->
-		    Ts1 = separate(Nodes,event_handler,[Hs,[]],Ts,
-				   Spec#testspec.nodes),
-		    add_tests(Ts1,Spec);
-		{_Node,[]} ->		    
-		    add_tests(Ts,Spec);
-		{Node,HOrHs} ->
-		    EvHs = Spec#testspec.event_handler,
-		    Node1 = ref2node(Node,Spec#testspec.nodes),
-		    case HOrHs of
-			[H|Hs] when is_atom(H) ->
-			    add_tests([{event_handler,Node,Hs}|Ts],
-				      Spec#testspec{event_handler=[{Node1,H,[]}|EvHs]});
-			H when is_atom(H) ->
-			    add_tests(Ts,Spec#testspec{event_handler=[{Node1,H,[]}|EvHs]})
-		    end
-	    end;
-	false ->				% HsOrNodes == Hs, HsOrArgs == Args
-	    add_tests([{event_handler,all_nodes,HsOrNodes,HsOrArgs}|Ts],Spec)
-    end;
-add_tests([{event_handler,Nodes,Hs,Args}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,event_handler,[Hs,Args],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{event_handler,Node,[H|Hs],Args}|Ts],Spec) when is_atom(H) ->
-    EvHs = Spec#testspec.event_handler,
-    Node1 = ref2node(Node,Spec#testspec.nodes),
-    add_tests([{event_handler,Node,Hs,Args}|Ts],
-	      Spec#testspec{event_handler=[{Node1,H,Args}|EvHs]});
-add_tests([{event_handler,_Node,[],_Args}|Ts],Spec) ->
-    add_tests(Ts,Spec);
-add_tests([{event_handler,Node,H,Args}|Ts],Spec) when is_atom(H) ->
-    EvHs = Spec#testspec.event_handler,
-    Node1 = ref2node(Node,Spec#testspec.nodes),
-    add_tests(Ts,Spec#testspec{event_handler=[{Node1,H,Args}|EvHs]});
-
-%% --- ct_hooks --
-add_tests([{ct_hooks, all_nodes, Hooks} | Ts], Spec) ->
-    Tests = [{ct_hooks,N,Hooks} || N <- list_nodes(Spec)],
-    add_tests(Tests ++ Ts, Spec);
-add_tests([{ct_hooks, Node, [Hook|Hooks]}|Ts], Spec) ->
-    SuiteCbs = Spec#testspec.ct_hooks,
-    Node1 = ref2node(Node,Spec#testspec.nodes),
-    add_tests([{ct_hooks, Node, Hooks} | Ts],
-	      Spec#testspec{ct_hooks = [{Node1,Hook} | SuiteCbs]});
-add_tests([{ct_hooks, _Node, []}|Ts], Spec) ->
-    add_tests(Ts, Spec);
-add_tests([{ct_hooks, Hooks}|Ts], Spec) ->
-    add_tests([{ct_hooks, all_nodes, Hooks}|Ts], Spec);
-
-%% -- enable_builtin_hooks --
-add_tests([{enable_builtin_hooks,Bool}|Ts],Spec) ->
-    add_tests(Ts, Spec#testspec{ enable_builtin_hooks = Bool });
-
-%% --- include ---
-add_tests([{include,all_nodes,InclDirs}|Ts],Spec) ->
-    Tests = lists:map(fun(N) -> {include,N,InclDirs} end, list_nodes(Spec)),
-    add_tests(Tests++Ts,Spec);
-add_tests([{include,Nodes,InclDirs}|Ts],Spec) when is_list(Nodes) ->
-    Ts1 = separate(Nodes,include,[InclDirs],Ts,Spec#testspec.nodes),
-    add_tests(Ts1,Spec);
-add_tests([{include,Node,[D|Ds]}|Ts],Spec) when is_list(D) ->
-    Dirs = Spec#testspec.include,
-    Node1 = ref2node(Node,Spec#testspec.nodes),
-    add_tests([{include,Node,Ds}|Ts],
-	      Spec#testspec{include=[{Node1,get_absdir(D,Spec)}|Dirs]});
-add_tests([{include,_Node,[]}|Ts],Spec) ->
-    add_tests(Ts,Spec);
-add_tests([{include,Node,D}|Ts],Spec) ->
-    add_tests([{include,Node,[D]}|Ts],Spec);
-add_tests([{include,InclDirs}|Ts],Spec) ->
-    add_tests([{include,all_nodes,InclDirs}|Ts],Spec);
+%%     -----------------------------------------------------
+%%   /                                                       \
+%%  |  When adding test/config terms, remember to update      |
+%%  |  valid_terms/0 also!                                    |
+%%   \                                                       /
+%%     -----------------------------------------------------
 
 %% --- suites ---
 add_tests([{suites,all_nodes,Dir,Ss}|Ts],Spec) ->
@@ -739,8 +573,10 @@ add_tests([{groups,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([{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,
@@ -792,7 +628,8 @@ add_tests([{skip_suites,Node,Dir,Ss,Cmt}|Ts],Spec) ->
 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,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) ->
@@ -800,8 +637,10 @@ add_tests([{skip_groups,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([{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,
@@ -833,6 +672,27 @@ add_tests([{skip_cases,Node,Dir,Suite,Cs,Cmt}|Ts],Spec) ->
 			Suite,Cs,Cmt,Tests,Spec#testspec.merge_tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
 
+%% --- various configuration terms ---
+add_tests([{config,Nodes,CfgDir,Files}|Ts],Spec) when is_list(Nodes);
+						      Nodes == all_nodes ->
+    add_tests([{config,Nodes,{CfgDir,Files}}|Ts],Spec);
+add_tests([{config,Node,CfgDir,FileOrFiles}|Ts],Spec) ->
+    add_tests([{config,Node,{CfgDir,FileOrFiles}}|Ts],Spec);
+add_tests([{config,CfgDir=[Ch|_],Files}|Ts],Spec) when is_integer(Ch) ->
+    add_tests([{config,all_nodes,{CfgDir,Files}}|Ts],Spec);
+
+add_tests([{event_handler,Nodes,Hs,Args}|Ts],Spec) when is_list(Nodes);
+							Nodes == all_nodes ->
+    add_tests([{event_handler,Nodes,{Hs,Args}}|Ts],Spec);
+add_tests([{event_handler,Node,HOrHs,Args}|Ts],Spec) ->
+    add_tests([{event_handler,Node,{HOrHs,Args}}|Ts],Spec);
+
+add_tests([{enable_builtin_hooks,Bool}|Ts],Spec) ->
+    add_tests(Ts, Spec#testspec{enable_builtin_hooks = Bool});
+
+add_tests([{noinput,Bool}|Ts],Spec) ->
+    add_tests(Ts, Spec#testspec{noinput = Bool});
+
 %% --- handled/errors ---
 add_tests([{alias,_,_}|Ts],Spec) ->		% handled
     add_tests(Ts,Spec);
@@ -840,45 +700,155 @@ add_tests([{alias,_,_}|Ts],Spec) ->		% handled
 add_tests([{node,_,_}|Ts],Spec) ->		% handled
     add_tests(Ts,Spec);
 
-add_tests([{merge_tests, _} | Ts], Spec) -> % handled
+add_tests([{merge_tests, _} | Ts], Spec) ->     % handled
     add_tests(Ts,Spec);
 
+%%     --------------------------------------------------
+%%   /                                                    \
+%%  |  General add_tests/2 clauses below will work for     |
+%%  |  most test spec configuration terms                  |
+%%   \                                                    /
+%%     --------------------------------------------------
+
+%% create one test entry per known node and reinsert
+add_tests([Term={Tag,all_nodes,Data}|Ts],Spec) ->
+    check_term(Term),
+    Tests = [{Tag,Node,Data} ||	Node <- list_nodes(Spec),
+				should_be_added(Tag,Node,Data,Spec)],
+    add_tests(Tests++Ts,Spec);
+%% create one test entry per node in Nodes and reinsert
+add_tests([{Tag,[],Data}|Ts],Spec) ->
+    add_tests([{Tag,all_nodes,Data}|Ts],Spec);
+add_tests([{Tag,String=[Ch|_],Data}|Ts],Spec) when is_integer(Ch) ->
+    add_tests([{Tag,all_nodes,{String,Data}}|Ts],Spec);
+add_tests([{Tag,NodesOrOther,Data}|Ts],Spec) when is_list(NodesOrOther) ->
+    case lists:all(fun(Test) -> is_node(Test,Spec#testspec.nodes)
+		   end, NodesOrOther) of
+	true ->
+	    Ts1 = separate(NodesOrOther,Tag,[Data],Ts,Spec#testspec.nodes),
+	    add_tests(Ts1,Spec);
+	false ->
+	    add_tests([{Tag,all_nodes,{NodesOrOther,Data}}|Ts],Spec)
+    end;
+%% update data for testspec term of type Tag
+add_tests([Term={Tag,NodeOrOther,Data}|Ts],Spec) ->
+    case is_node(NodeOrOther,Spec#testspec.nodes) of
+	true ->
+	    check_term(Term),
+	    Node = ref2node(NodeOrOther,Spec#testspec.nodes),
+	    NodeIxData = 
+		handle_data(Tag,Node,Data,Spec) ++
+		update_recorded(Tag,Node,Spec),
+	    add_tests(Ts,mod_field(Spec,Tag,NodeIxData));
+	false ->
+	    add_tests([{Tag,all_nodes,{NodeOrOther,Data}}|Ts],Spec)
+    end;
+%% this test should be added for all known nodes
+add_tests([{Tag,Data}|Ts],Spec) ->
+    add_tests([{Tag,all_nodes,Data}|Ts],Spec);
+
+%% some other data than a tuple
+add_tests([Other|Ts],Spec) ->	
+    case get(relaxed) of
+	true ->		
+	    add_tests(Ts,Spec);
+	false ->
+	    throw({error,{undefined_term_in_spec,Other}})
+    end;
+
+add_tests([],Spec) ->				% done
+    Spec.
+
 %% check if it's a CT term that has bad format or if the user seems to
 %% have added something of his/her own, which we'll let pass if relaxed
 %% mode is enabled.
-add_tests([Other|Ts],Spec) when is_tuple(Other) ->
-    [Name|_] = tuple_to_list(Other),
+check_term(Term) ->
+    [Name|_] = tuple_to_list(Term),
     case lists:keymember(Name,1,valid_terms()) of
 	true ->					% halt
-	    throw({error,{bad_term_in_spec,Other}});
+	    throw({error,{bad_term_in_spec,Term}});
 	false ->				% ignore
 	    case get(relaxed) of
 		true ->
 		    %% warn if name resembles a CT term
-		    case resembles_ct_term(Name,size(Other)) of
+		    case resembles_ct_term(Name,size(Term)) of
 			true ->
 			    io:format("~nSuspicious term, please check:~n"
-				      "~p~n", [Other]);
+				      "~p~n", [Term]);
 			false ->
 			    ok
-		    end,
-		    add_tests(Ts,Spec);
+		    end;
 		false ->
-		    throw({error,{undefined_term_in_spec,Other}})
+		    throw({error,{undefined_term_in_spec,Term}})
 	    end
-    end;
+    end.
 
-add_tests([Other|Ts],Spec) ->	
-    case get(relaxed) of
-	true ->		
-	    add_tests(Ts,Spec);
-	false ->
-	    throw({error,{undefined_term_in_spec,Other}})
-    end;
+%% specific data handling before saving in testspec record, e.g.
+%% converting relative paths to absolute for directories and files
+%% (introduce a clause *only* if the data value needs processing)
+handle_data(logdir,Node,Dir,Spec) ->
+    [{Node,ref2dir(Dir,Spec)}];
+handle_data(cover,Node,File,Spec) ->
+    [{Node,get_absfile(File,Spec)}];
+handle_data(include,Node,Dirs=[D|_],Spec) when is_list(D) ->
+    [{Node,ref2dir(Dir,Spec)} || Dir <- Dirs];
+handle_data(include,Node,Dir=[Ch|_],Spec) when is_integer(Ch) ->
+    handle_data(include,Node,[Dir],Spec);
+handle_data(config,Node,File=[Ch|_],Spec) when is_integer(Ch) ->
+    handle_data(config,Node,[File],Spec);
+handle_data(config,Node,{CfgDir,File=[Ch|_]},Spec) when is_integer(Ch) ->
+    handle_data(config,Node,{CfgDir,[File]},Spec);
+handle_data(config,Node,Files=[F|_],Spec) when is_list(F) ->
+    [{Node,get_absfile(File,Spec)} || File <- Files];
+handle_data(config,Node,{CfgDir,Files=[F|_]},Spec) when is_list(F) ->
+    [{Node,filename:join(ref2dir(CfgDir,Spec),File)} || File <- Files];
+handle_data(userconfig,Node,CBs,Spec) when is_list(CBs) ->
+    [{Node,{Callback,get_absfile(Callback,Config,Spec)}} ||
+	{Callback,Config} <- CBs];
+handle_data(userconfig,Node,CB,Spec) when is_tuple(CB) ->
+    handle_data(userconfig,Node,[CB],Spec);
+handle_data(event_handler,Node,H,Spec) when is_atom(H) ->
+    handle_data(event_handler,Node,{[H],[]},Spec);
+handle_data(event_handler,Node,{H,Args},Spec) when is_atom(H) ->
+    handle_data(event_handler,Node,{[H],Args},Spec);
+handle_data(event_handler,Node,Hs,_Spec) when is_list(Hs) ->
+    [{Node,EvH,[]} || EvH <- Hs];
+handle_data(event_handler,Node,{Hs,Args},_Spec) when is_list(Hs) ->
+    [{Node,EvH,Args} || EvH <- Hs];
+handle_data(ct_hooks,Node,Hooks,_Spec) when is_list(Hooks) ->
+    [{Node,Hook} || Hook <- Hooks ];
+handle_data(ct_hooks,Node,Hook,_Spec) ->
+    [{Node,Hook}];
+handle_data(stylesheet,Node,CSSFile,Spec) ->
+    [{Node,get_absfile(CSSFile,Spec)}];
+handle_data(_Tag,Node,Data,_Spec) ->
+    [{Node,Data}].
+
+%% check if duplicates should be saved or not
+should_be_added(Tag,Node,_Data,Spec) ->
+    if 
+	%% list terms *without* possible duplicates here
+	Tag == logdir; Tag == logopts;
+	Tag == basic_html; Tag == label;
+	Tag == auto_compile; Tag == stylesheet ->
+	    lists:keymember(ref2node(Node,Spec#testspec.nodes),1,
+			    read_field(Spec,Tag)) == false;
+	%% for terms *with* possible duplicates
+	true ->
+	    true
+    end.
 
-add_tests([],Spec) ->				% done
-    Spec.
+%% check if previous elements for Node should be deleted
+update_recorded(Tag,Node,Spec) ->
+    if Tag == config; Tag == userconfig; Tag == event_handler;
+       Tag == ct_hooks; Tag == include ->
+	    read_field(Spec,Tag);
+       true ->
+	    %% delete previous value for Tag
+	    lists:keydelete(Node,1,read_field(Spec,Tag))
+    end.
 
+%% create one test term per node
 separate(Nodes,Tag,Data,Tests,Refs) ->
     Separated = separate(Nodes,Tag,Data,Refs),
     Separated ++ Tests.
@@ -886,7 +856,25 @@ separate([N|Ns],Tag,Data,Refs) ->
     [list_to_tuple([Tag,ref2node(N,Refs)|Data])|separate(Ns,Tag,Data,Refs)];
 separate([],_,_,_) ->
     [].
-    
+
+%% read the value for FieldName in record Rec#testspec
+read_field(Rec, FieldName) ->
+    catch lists:foldl(fun(F, Pos) when F == FieldName ->
+			      throw(element(Pos, Rec));
+			 (_,Pos)  ->
+			      Pos+1
+		      end,2,?testspec_fields).
+
+%% modify the value for FieldName in record Rec#testspec
+mod_field(Rec, FieldName, NewVal) ->
+    [_testspec|RecList] = tuple_to_list(Rec),
+    RecList1 =
+	(catch lists:foldl(fun(F, {Prev,[_OldVal|Rest]}) when F == FieldName ->
+				   throw(lists:reverse(Prev) ++ [NewVal|Rest]);
+			      (_,{Prev,[Field|Rest]})  ->
+				   {[Field|Prev],Rest}
+			   end,{[],RecList},?testspec_fields)),
+    list_to_tuple([testspec|RecList1]).
 
 %% Representation:
 %% {{Node,Dir},[{Suite1,[GrOrCase11,GrOrCase12,...]},
@@ -1103,32 +1091,50 @@ ref2node(RefOrNode,Refs) ->
 		    throw({error,{noderef_missing,RefOrNode}})
 	    end;
 	_ ->					% a node
-	    RefOrNode
+	    case RefOrNode of
+		{TheNode,TheHost} ->
+		    list_to_atom(atom_to_list(TheNode) ++ "@"
+				 ++ atom_to_list(TheHost));
+		_ ->
+		    RefOrNode
+	    end
     end.
 
-ref2dir(Ref,Refs) when is_atom(Ref) ->
+ref2dir(Ref,Spec) ->
+    ref2dir(Ref,Spec#testspec.alias,Spec).
+
+ref2dir(Ref,Refs,Spec) when is_atom(Ref) ->
     case lists:keysearch(Ref,1,Refs) of
 	{value,{Ref,Dir}} ->
-	    Dir;
+	    get_absdir(Dir,Spec);
 	false ->
 	    throw({error,{alias_missing,Ref}})
     end;
-ref2dir(Dir,_) when is_list(Dir) ->
-    Dir.
+ref2dir(Dir,_,Spec) when is_list(Dir) ->
+    get_absdir(Dir,Spec).
 
-is_noderef(What,Nodes) when is_atom(What) ->
-    is_noderef([What],Nodes);
-is_noderef([master|_],_Nodes) ->
+is_node(What,Nodes) when is_atom(What) ->
+    is_node([What],Nodes);
+is_node([master|_],_Nodes) ->
     true;
-is_noderef([What|_],Nodes) ->
-    case lists:keymember(What,1,Nodes) or
-	 lists:keymember(What,2,Nodes) of
+is_node(What={N,H},Nodes) when is_atom(N), is_atom(H) ->
+    is_node([What],Nodes);
+is_node([What|_],Nodes) ->
+    Nodename =	case What of
+		    {N,H} when is_atom(N), is_atom(H) ->
+			list_to_atom(atom_to_list(N) ++ "@"
+				     ++ atom_to_list(H));
+		    _ ->
+			What
+		end,
+    case lists:keymember(Nodename,1,Nodes) or
+	 lists:keymember(Nodename,2,Nodes) of
 	true ->					
 	    true;
 	false ->
 	    false
     end;
-is_noderef([],_) ->
+is_node([],_) ->
     false.
 
 valid_terms() ->
@@ -1138,14 +1144,17 @@ valid_terms() ->
      {cover,3},
      {config,2},
      {config,3},
+     {config,4},
      {userconfig,2},
      {userconfig,3},
      {alias,3},
-     {merge_tests,1},
+     {merge_tests,2},
      {logdir,2},
      {logdir,3},
      {logopts,2},
      {logopts,3},
+     {basic_html,2},
+     {basic_html,3},
      {label,2},
      {label,3},
      {event_handler,2},
@@ -1153,13 +1162,18 @@ valid_terms() ->
      {event_handler,4},
      {ct_hooks,2},
      {ct_hooks,3},
-     {enable_builtin_hooks,1},
+     {enable_builtin_hooks,2},
+     {noinput,2},
      {multiply_timetraps,2},
      {multiply_timetraps,3},
      {scale_timetraps,2},
      {scale_timetraps,3},
      {include,2},
      {include,3},
+     {auto_compile,2},
+     {auto_compile,3},
+     {stylesheet,2},
+     {stylesheet,3},
      {suites,3},
      {suites,4},
      {groups,4},