Implement constants and new features for test specifications

OTP-10049
OTP-10089

3 files changed, 484 insertions, 373 deletions

diff --git a/lib/common_test/src/ct_run.erl b/lib/common_test/src/ct_run.erl
index 46aec04ec1..e801ff925a 100644
--- a/lib/common_test/src/ct_run.erl
+++ b/lib/common_test/src/ct_run.erl
@@ -54,11 +54,13 @@
 	       step,
 	       logdir,
 	       logopts = [],
+	       basic_html,
 	       config = [],
 	       event_handlers = [],
 	       ct_hooks = [],
 	       enable_builtin_hooks,
 	       include = [],
+	       auto_compile,
 	       silent_connections,
 	       stylesheet,
 	       multiply_timetraps = 1,
@@ -102,7 +104,8 @@ script_start() ->
 						  end, Flags)
 			     end,
 		%% used for purpose of testing the run_test interface
-		io:format(user, "~n-------------------- START ARGS --------------------~n", []),
+		io:format(user, "~n-------------------- START ARGS "
+			  "--------------------~n", []),
 		io:format(user, "--- Init args:~n~p~n", [FlagFilter(Init)]),
 		io:format(user, "--- CT args:~n~p~n", [FlagFilter(CtArgs)]),
 		EnvArgs = opts2args(EnvStartOpts),
@@ -110,7 +113,8 @@ script_start() ->
 			  [EnvStartOpts,EnvArgs]),
 		Merged = merge_arguments(CtArgs ++ EnvArgs),
 		io:format(user, "--- Merged args:~n~p~n", [FlagFilter(Merged)]),
-		io:format(user, "----------------------------------------------------~n~n", []),
+		io:format(user, "-----------------------------------"
+			  "-----------------~n~n", []),
 		Merged;
 	    _ ->
 		merge_arguments(CtArgs)
@@ -134,17 +138,20 @@ script_start(Args) ->
 				_ -> ""
 			    end
 		    end,
-		io:format("~nCommon Test~s starting (cwd is ~s)~n~n", [CTVsn,Cwd]),
+		io:format("~nCommon Test~s starting (cwd is ~s)~n~n",
+			  [CTVsn,Cwd]),
 		Self = self(),
 		Pid = spawn_link(fun() -> script_start1(Self, Args) end),
 	        receive
 		    {'EXIT',Pid,Reason} ->
 			case Reason of
 			    {user_error,What} ->
-				io:format("\nTest run failed!\nReason: ~p\n\n", [What]),
+				io:format("\nTest run failed!\nReason: ~p\n\n",
+					  [What]),
 				{error,What};
 			    _ ->
-				io:format("Test run crashed! This could be an internal error "
+				io:format("Test run crashed! "
+					  "This could be an internal error "
 					  "- please report!\n\n"
 					  "~p\n\n", [Reason]),
 				{error,Reason}				
@@ -206,7 +213,7 @@ script_start1(Parent, Args) ->
 	    end
     end,
     %% no_auto_compile + include
-    IncludeDirs =
+    {AutoCompile,IncludeDirs} =
 	case proplists:get_value(no_auto_compile, Args) of
 	    undefined ->
 		application:set_env(common_test, auto_compile, true),
@@ -222,16 +229,16 @@ script_start1(Parent, Args) ->
 		case os:getenv("CT_INCLUDE_PATH") of
 		    false ->
 			application:set_env(common_test, include, InclDirs),
-			InclDirs;
+			{undefined,InclDirs};
 		    CtInclPath ->
 			AllInclDirs =
 			    string:tokens(CtInclPath,[$:,$ ,$,]) ++ InclDirs,
 			application:set_env(common_test, include, AllInclDirs),
-			AllInclDirs
+			{undefined,AllInclDirs}
 		end;
 	    _ ->
 		application:set_env(common_test, auto_compile, false),
-		[]
+		{false,[]}
 	end,
     %% silent connections
     SilentConns =
@@ -243,19 +250,23 @@ script_start1(Parent, Args) ->
     Stylesheet = get_start_opt(stylesheet,
 			       fun([SS]) -> ?abs(SS) end, Args),
     %% basic_html - used by ct_logs
-    case proplists:get_value(basic_html, Args) of
-	undefined ->
-	    application:set_env(common_test, basic_html, false);
-	_ ->
-	    application:set_env(common_test, basic_html, true)
-    end,
+    BasicHtml = case proplists:get_value(basic_html, Args) of
+		    undefined ->
+			application:set_env(common_test, basic_html, false),
+			undefined;
+		    _ ->
+			application:set_env(common_test, basic_html, true),
+			true
+		end,
 
    StartOpts = #opts{label = Label, profile = Profile,
 		     vts = Vts, shell = Shell, cover = Cover,
 		     logdir = LogDir, logopts = LogOpts,
+		     basic_html = BasicHtml,
 		     event_handlers = EvHandlers,
 		     ct_hooks = CTHooks,
 		     enable_builtin_hooks = EnableBuiltinHooks,
+		     auto_compile = AutoCompile,
 		     include = IncludeDirs,
 		     silent_connections = SilentConns,
 		     stylesheet = Stylesheet,
@@ -352,9 +363,36 @@ script_start2(StartOpts = #opts{vts = undefined,
 			      StartOpts#opts.enable_builtin_hooks,
 			      SpecStartOpts#opts.enable_builtin_hooks),
 			
+			Stylesheet =
+			    choose_val(StartOpts#opts.stylesheet,
+				       SpecStartOpts#opts.stylesheet),
+			    
 			AllInclude = merge_vals([StartOpts#opts.include,
 						 SpecStartOpts#opts.include]),
 			application:set_env(common_test, include, AllInclude),
+			
+			AutoCompile =
+			    case choose_val(StartOpts#opts.auto_compile,
+					    SpecStartOpts#opts.auto_compile) of
+				undefined ->
+				    true;
+				ACBool ->
+				    application:set_env(common_test,
+							auto_compile,
+							ACBool),
+				    ACBool
+			    end,
+
+			BasicHtml =
+			    case choose_val(StartOpts#opts.basic_html,
+					    SpecStartOpts#opts.basic_html) of
+				undefined ->
+				    false;
+				BHBool ->
+				    application:set_env(common_test, basic_html, 
+							BHBool),
+				    BHBool
+			    end,
 
 			{TS,StartOpts#opts{label = Label,
 					   profile = Profile,
@@ -362,11 +400,14 @@ script_start2(StartOpts = #opts{vts = undefined,
 					   cover = Cover,
 					   logdir = LogDir,
 					   logopts = AllLogOpts,
+					   basic_html = BasicHtml,
 					   config = SpecStartOpts#opts.config,
 					   event_handlers = AllEvHs,
 					   ct_hooks = AllCTHooks,
 					   enable_builtin_hooks =
 					       EnableBuiltinHooks,
+					   stylesheet = Stylesheet,
+					   auto_compile = AutoCompile,
 					   include = AllInclude,
 					   multiply_timetraps = MultTT,
 					   scale_timetraps = ScaleTT,
@@ -739,8 +780,10 @@ run_test2(StartOpts) ->
 				    (Lbl) when is_atom(Lbl) -> atom_to_list(Lbl)
 				 end, StartOpts),
     %% profile
-    Profile = get_start_opt(profile, fun(Prof) when is_list(Prof) -> Prof;
-					(Prof) when is_atom(Prof) -> atom_to_list(Prof)
+    Profile = get_start_opt(profile, fun(Prof) when is_list(Prof) ->
+					     Prof;
+					(Prof) when is_atom(Prof) ->
+					     atom_to_list(Prof)
 				     end, StartOpts),
     %% logdir
     LogDir = get_start_opt(logdir, fun(LD) when is_list(LD) -> LD end,
@@ -805,7 +848,7 @@ run_test2(StartOpts) ->
     CreatePrivDir = get_start_opt(create_priv_dir, value, StartOpts),
 
     %% auto compile & include files
-    Include =
+    {AutoCompile,Include} =
 	case proplists:get_value(auto_compile, StartOpts) of
 	    undefined ->
 		application:set_env(common_test, auto_compile, true),		
@@ -821,16 +864,16 @@ run_test2(StartOpts) ->
 		case os:getenv("CT_INCLUDE_PATH") of
 		    false ->
 			application:set_env(common_test, include, InclDirs),
-			InclDirs;
+			{undefined,InclDirs};
 		    CtInclPath ->
 			InclDirs1 = string:tokens(CtInclPath, [$:,$ ,$,]),
 			AllInclDirs = InclDirs1++InclDirs,
 			application:set_env(common_test, include, AllInclDirs),
-			AllInclDirs
+			{undefined,AllInclDirs}
 		end;
 	    ACBool ->
 		application:set_env(common_test, auto_compile, ACBool),
-		[]
+		{ACBool,[]}
 	end,
 
     %% decrypt config file
@@ -844,11 +887,14 @@ run_test2(StartOpts) ->
     end,
 
     %% basic html - used by ct_logs
-    case proplists:get_value(basic_html, StartOpts) of
-	undefined ->
-	    application:set_env(common_test, basic_html, false);
-	BasicHtmlBool ->
-	    application:set_env(common_test, basic_html, BasicHtmlBool)
+    BasicHtml =
+	case proplists:get_value(basic_html, StartOpts) of
+	    undefined ->
+		application:set_env(common_test, basic_html, false),
+		undefined;
+	    BasicHtmlBool ->
+		application:set_env(common_test, basic_html, BasicHtmlBool),
+		BasicHtmlBool		
     end,
 
     %% stepped execution
@@ -856,10 +902,12 @@ run_test2(StartOpts) ->
 
     Opts = #opts{label = Label, profile = Profile,
 		 cover = Cover, step = Step, logdir = LogDir,
-		 logopts = LogOpts, config = CfgFiles,
+		 logopts = LogOpts, basic_html = BasicHtml,
+		 config = CfgFiles,
 		 event_handlers = EvHandlers,
 		 ct_hooks = CTHooks,
 		 enable_builtin_hooks = EnableBuiltinHooks,
+		 auto_compile = AutoCompile,
 		 include = Include,
 		 silent_connections = SilentConns,
 		 stylesheet = Stylesheet,
@@ -905,6 +953,8 @@ run_spec_file(Relaxed,
 				SpecOpts#opts.logdir),
 	    AllLogOpts = merge_vals([Opts#opts.logopts,
 				     SpecOpts#opts.logopts]),
+	    Stylesheet = choose_val(Opts#opts.stylesheet,
+				    SpecOpts#opts.stylesheet),
 	    AllConfig = merge_vals([CfgFiles, SpecOpts#opts.config]),
 	    Cover = choose_val(Opts#opts.cover,
 			       SpecOpts#opts.cover),
@@ -918,7 +968,6 @@ run_spec_file(Relaxed,
 				  SpecOpts#opts.event_handlers]),
 	    AllInclude = merge_vals([Opts#opts.include,
 				     SpecOpts#opts.include]),
-
 	    AllCTHooks = merge_vals([Opts#opts.ct_hooks,
 				      SpecOpts#opts.ct_hooks]),
 	    EnableBuiltinHooks = choose_val(Opts#opts.enable_builtin_hooks,
@@ -926,13 +975,36 @@ run_spec_file(Relaxed,
 	    
 	    application:set_env(common_test, include, AllInclude),
 
+	    AutoCompile = case choose_val(Opts#opts.auto_compile,
+					  SpecOpts#opts.auto_compile) of
+			      undefined ->
+				  true;
+			      ACBool ->
+				  application:set_env(common_test, auto_compile,
+						      ACBool),
+				  ACBool
+			  end,
+
+	    BasicHtml =	case choose_val(Opts#opts.basic_html,
+					SpecOpts#opts.basic_html) of
+			    undefined ->
+				false;
+			    BHBool ->
+				application:set_env(common_test, basic_html,
+						    BHBool),
+				BHBool
+			end,
+
 	    Opts1 = Opts#opts{label = Label,
 			      profile = Profile,
 			      cover = Cover,
 			      logdir = which(logdir, LogDir),
 			      logopts = AllLogOpts,
+			      stylesheet = Stylesheet,
+			      basic_html = BasicHtml,
 			      config = AllConfig,
 			      event_handlers = AllEvHs,
+			      auto_compile = AutoCompile,
 			      include = AllInclude,
 			      testspecs = AbsSpecs,
 			      multiply_timetraps = MultTT,
@@ -1188,12 +1260,15 @@ get_data_for_node(#testspec{label = Labels,
 			    profile = Profiles,
 			    logdir = LogDirs,
 			    logopts = LogOptsList,
+			    basic_html = BHs,
+			    stylesheet = SSs,
 			    cover = CoverFs,
 			    config = Cfgs,
 			    userconfig = UsrCfgs,
 			    event_handler = EvHs,
 			    ct_hooks = CTHooks,
 			    enable_builtin_hooks = EnableBuiltinHooks,
+			    auto_compile = ACs,
 			    include = Incl,
 			    multiply_timetraps = MTs,
 			    scale_timetraps = STs,
@@ -1208,6 +1283,8 @@ get_data_for_node(#testspec{label = Labels,
 		  undefined -> [];
 		  LOs -> LOs
 	      end,
+    BasicHtml = proplists:get_value(Node, BHs),
+    Stylesheet = proplists:get_value(Node, SSs),
     Cover = proplists:get_value(Node, CoverFs),
     MT = proplists:get_value(Node, MTs),
     ST = proplists:get_value(Node, STs),
@@ -1216,16 +1293,20 @@ get_data_for_node(#testspec{label = Labels,
 	[CBF || {N,CBF} <- UsrCfgs, N==Node],
     EvHandlers =  [{H,A} || {N,H,A} <- EvHs, N==Node],
     FiltCTHooks = [Hook || {N,Hook} <- CTHooks, N==Node],
+    AutoCompile = proplists:get_value(Node, ACs),
     Include =  [I || {N,I} <- Incl, N==Node],
     #opts{label = Label,
 	  profile = Profile,
 	  logdir = LogDir,
 	  logopts = LogOpts,
+	  basic_html = BasicHtml,
+	  stylesheet = Stylesheet,
 	  cover = Cover,
 	  config = ConfigFiles,
 	  event_handlers = EvHandlers,
 	  ct_hooks = FiltCTHooks,
 	  enable_builtin_hooks = EnableBuiltinHooks,
+	  auto_compile = AutoCompile,
 	  include = Include,
 	  multiply_timetraps = MT,
 	  scale_timetraps = ST,
@@ -1547,23 +1628,29 @@ verify_suites(TestSuites) ->
 				{[DS|Found],NotFound};
 			   true ->
 				Beam = filename:join(TestDir,
-						     atom_to_list(Suite)++".beam"),
+						     atom_to_list(Suite)++
+							 ".beam"),
 				case filelib:is_regular(Beam) of
 				    true  ->
 					{[DS|Found],NotFound};
 				    false ->
 					case code:is_loaded(Suite) of
 					    {file,SuiteFile} ->
-						%% test suite is already loaded and
-						%% since auto_compile == false,
+						%% test suite is already
+						%% loaded and since
+						%% auto_compile == false,
 						%% let's assume the user has
-						%% loaded the beam file explicitly
-						ActualDir = filename:dirname(SuiteFile),
-						{[{ActualDir,Suite}|Found],NotFound};
+						%% loaded the beam file
+						%% explicitly
+						ActualDir = 
+						    filename:dirname(SuiteFile),
+						{[{ActualDir,Suite}|Found],
+						 NotFound};
 					    false ->
 						Name =
 						    filename:join(TestDir,
-								  atom_to_list(Suite)),
+								  atom_to_list(
+								    Suite)),
 						io:format(user,
 							  "Suite ~w not found"
 							  "in directory ~s~n",
@@ -1581,7 +1668,8 @@ verify_suites(TestSuites) ->
 				ActualDir = filename:dirname(SuiteFile),
 				{[{ActualDir,Suite}|Found],NotFound};
 			    false ->
-				io:format(user, "Directory ~s is invalid~n", [Dir]),
+				io:format(user, "Directory ~s is invalid~n",
+					  [Dir]),
 				Name = filename:join(Dir, atom_to_list(Suite)),
 				{Found,[{DS,[Name]}|NotFound]}
 			end
@@ -1616,8 +1704,9 @@ step(TestDir, Suite, Case) ->
 %%%-----------------------------------------------------------------
 %%% @hidden
 %%% @equiv ct:step/4
-step(TestDir, Suite, Case, Opts) when is_list(TestDir), is_atom(Suite), is_atom(Case),
-				   Suite =/= all, Case =/= all ->
+step(TestDir, Suite, Case, Opts) when is_list(TestDir),
+				      is_atom(Suite), is_atom(Case),
+				      Suite =/= all, Case =/= all ->
     do_run([{TestDir,Suite,Case}], [{step,Opts}]).
 
 
@@ -1769,7 +1858,8 @@ set_group_leader_same_as_shell() ->
 		     end
 	     end,	
     case [P || P <- processes(), GS2or3(P),
-	       true == lists:keymember(shell,1,element(2,process_info(P,dictionary)))] of
+	       true == lists:keymember(shell,1,
+				       element(2,process_info(P,dictionary)))] of
 	[GL|_] ->
 	    group_leader(GL, self());
 	[] ->
@@ -1815,12 +1905,14 @@ do_run_test(Tests, Skip, Opts) ->
 				incl_mods  = CovIncl,
 				cross      = CovCross,
 				src        = _CovSrc}} ->
-		    ct_logs:log("COVER INFO","Using cover specification file: ~s~n"
+		    ct_logs:log("COVER INFO",
+				"Using cover specification file: ~s~n"
 				"App: ~w~n"
 				"Cross cover: ~w~n"
 				"Including ~w modules~n"
 				"Excluding ~w modules",
-				[CovFile,CovApp,CovCross,length(CovIncl),length(CovExcl)]),
+				[CovFile,CovApp,CovCross,length(CovIncl),
+				 length(CovExcl)]),
 
 		    %% cover export file will be used for export and import
 		    %% between tests so make sure it doesn't exist initially
@@ -1828,7 +1920,8 @@ do_run_test(Tests, Skip, Opts) ->
 			true ->
 			    DelResult = file:delete(CovExport),
 			    ct_logs:log("COVER INFO",
-					"Warning! Export file ~s already exists. "
+					"Warning! "
+					"Export file ~s already exists. "
 					"Deleting with result: ~p",
 					[CovExport,DelResult]);
 			false ->
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},
diff --git a/lib/common_test/src/ct_util.hrl b/lib/common_test/src/ct_util.hrl
index 6b016e95df..d2851d3463 100644
--- a/lib/common_test/src/ct_util.hrl
+++ b/lib/common_test/src/ct_util.hrl
@@ -34,13 +34,17 @@
 		   profile=[],
 		   logdir=["."],
 		   logopts=[],
+		   basic_html=[],
 		   cover=[],
 		   config=[],
 		   userconfig=[],
 		   event_handler=[],
 		   ct_hooks=[],
 		   enable_builtin_hooks=true,
+		   noinput=false,
 		   include=[],
+		   auto_compile=[],
+		   stylesheet=[],
 		   multiply_timetraps=[],
 		   scale_timetraps=[],
 		   create_priv_dir=[],