Merge remote branch 'origin/peppe/common_test/testspec_updates' into maint

* origin/peppe/common_test/testspec_updates:
  Test new testspec functionality and correct bugs
  Implement constants and new features for test specifications

Conflicts:
	lib/common_test/src/ct_run.erl
	lib/common_test/test/Makefile

OTP-10049
OTP-10089
OTP-10145

11 files changed, 2071 insertions, 452 deletions

diff --git a/lib/common_test/doc/src/run_test_chapter.xml b/lib/common_test/doc/src/run_test_chapter.xml
index 30486d3eec..bc0af63790 100644
--- a/lib/common_test/doc/src/run_test_chapter.xml
+++ b/lib/common_test/doc/src/run_test_chapter.xml
@@ -425,7 +425,7 @@
     <p>Below is the test specification syntax. Test specifications can
       be used to run tests both in a single test host environment and
       in a distributed Common Test environment (Large Scale
-      Testing). The node parameters in the init term are only
+      Testing). The node parameters in the <c>init</c> term are only
       relevant in the latter (see the
       <seealso marker="ct_master_chapter#test_specifications">Large
       Scale Testing</seealso> chapter for information). For details on
@@ -575,9 +575,9 @@
       <item>Lastly, all suites for systems t3 are to be completely skipped and this
 	should be explicitly noted in the log files.</item>
     </list>
-    <p>It is possible to specify initialization options for nodes defined in the
-      test specification. Currently, there are options to start the node and/or to
-      evaluate any function on the node.
+    <p>With the <c>init</c> term it's possible to specify initialization options
+      for nodes defined in the test specification. Currently, there are options
+      to start the node and/or to evaluate any function on the node.
       See the <seealso marker="ct_master_chapter#ct_slave">Automatic startup of
       the test target nodes</seealso> chapter for details.</p>
     <p>It is possible for the user to provide a test specification that
diff --git a/lib/common_test/src/ct_run.erl b/lib/common_test/src/ct_run.erl
index 42d450f67f..ddb0d36c0f 100644
--- a/lib/common_test/src/ct_run.erl
+++ b/lib/common_test/src/ct_run.erl
@@ -58,11 +58,13 @@
 	       step,
 	       logdir,
 	       logopts = [],
+	       basic_html,
 	       config = [],
 	       event_handlers = [],
 	       ct_hooks = [],
 	       enable_builtin_hooks,
 	       include = [],
+	       auto_compile,
 	       silent_connections,
 	       stylesheet,
 	       multiply_timetraps = 1,
@@ -106,7 +108,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),
@@ -114,7 +117,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)
@@ -137,17 +141,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\n", [What]),
+			    io:format("\nTest run failed!\nReason: ~p\n\n\n",
+                                      [What]),
 			    finish(Tracing, ?EXIT_STATUS_TEST_RUN_FAILED, Args);
 			_ ->
-			    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\n", [Reason]),
 			    finish(Tracing, ?EXIT_STATUS_TEST_RUN_FAILED, Args)
@@ -261,7 +268,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),
@@ -277,16 +284,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 =
@@ -298,19 +305,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,
@@ -407,9 +418,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,
@@ -417,11 +455,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,
@@ -795,8 +836,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,
@@ -861,7 +904,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),		
@@ -877,16 +920,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
@@ -900,11 +943,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
@@ -912,10 +958,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,
@@ -961,6 +1009,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),
@@ -974,7 +1024,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,
@@ -982,13 +1031,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,
@@ -1246,12 +1318,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,
@@ -1266,6 +1341,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),
@@ -1274,16 +1351,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,
@@ -1606,23 +1687,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",
@@ -1640,7 +1727,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
@@ -1675,8 +1763,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}]).
 
 
@@ -1828,7 +1917,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());
 	[] ->
@@ -1874,12 +1964,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
@@ -1887,7 +1979,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 ->
@@ -2561,7 +2654,7 @@ opts2args(EnvStartOpts) ->
 		     ({decrypt,{file,File}}) ->
 			  [{ct_decrypt_file,[File]}];
 		     ({basic_html,true}) ->
-			  ({basic_html,[]});
+			  [{basic_html,[]}];
 		     ({basic_html,false}) ->
 			  [];
 		     ({event_handler,EH}) when is_atom(EH) ->
diff --git a/lib/common_test/src/ct_testspec.erl b/lib/common_test/src/ct_testspec.erl
index 4c05f57520..cbd7dc1f35 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,7 +48,8 @@
 %%% 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) ->
+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}} ->
 	    {Run,Skip};
@@ -249,22 +252,23 @@ collect_tests_from_file1([Spec|Specs],TestSpec,Relaxed) ->
     SpecDir = filename:dirname(filename:absname(Spec)),
     case file:consult(Spec) of
 	{ok,Terms} ->	    
-	    TestSpec1 = collect_tests(Terms,
-				      TestSpec#testspec{spec_dir=SpecDir},
-				      Relaxed),
-	    collect_tests_from_file1(Specs,TestSpec1,Relaxed);
+	    case collect_tests(Terms,
+			       TestSpec#testspec{spec_dir=SpecDir},
+			       Relaxed) of
+		TS = #testspec{tests=Tests, logdir=LogDirs} when Specs == [] ->
+		    LogDirs1 = lists:delete(".",LogDirs) ++ ["."],
+		    TS#testspec{tests=lists:flatten(Tests), logdir=LogDirs1};  
+		TS = #testspec{alias = As, nodes = Ns} ->
+		    TS1 = TS#testspec{alias = lists:reverse(As),
+				      nodes = lists:reverse(Ns)},
+		    collect_tests_from_file1(Specs,TS1,Relaxed)
+	    end;
 	{error,Reason} ->
 	    ReasonStr =
 		lists:flatten(io_lib:format("~s",
 					    [file:format_error(Reason)])),
 	    throw({error,{Spec,ReasonStr}})
-    end;
-collect_tests_from_file1([],TS=#testspec{config=Cfgs,event_handler=EvHs,
-					 include=Incl,tests=Tests},_) ->
-    TS#testspec{config=lists:reverse(Cfgs),
-		event_handler=lists:reverse(EvHs),
-		include=lists:reverse(Incl),
-		tests=lists:flatten(Tests)}.
+    end.
 
 collect_tests_from_list(Terms,Relaxed) ->
     collect_tests_from_list(Terms,[node()],Relaxed).
@@ -278,30 +282,163 @@ 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,
-	    TS#testspec{config=lists:reverse(Cfgs),
-			event_handler=lists:reverse(EvHs),
-			include=lists:reverse(Incl),
-			tests=lists:flatten(Tests)}
+	    #testspec{tests=Tests, logdir=LogDirs} = TS,
+	    LogDirs1 = lists:delete(".",LogDirs) ++ ["."],
+	    TS#testspec{tests=lists:flatten(Tests), logdir=LogDirs1}
     end.
     
 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),
+    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(Def={define,Name,_Replacement}) ->
+			      %% check that name follows convention
+			      if not is_atom(Name) ->
+				      throw({illegal_name_in_testspec,Name});
+				 true ->
+				      [First|_] = atom_to_list(Name),
+				      if ((First == $?) or (First == $$)
+					  or (First == $_)
+					  or ((First >= $A)
+					      and (First =< $Z))) ->
+					      [Def];
+					 true ->
+					      throw({illegal_name_in_testspec,
+						     Name})
+				      end
+			      end;
+			 (_) -> []
+		      end, Terms),
+    DefProps = replace_names_in_defs(Defs,[]),
+    replace_names(Terms,[],DefProps).
+
+replace_names_in_defs([Def|Left],ModDefs) ->
+    [{define,Name,Replacement}] = replace_names([Def],[],ModDefs),
+    replace_names_in_defs(Left,[{Name,Replacement}|ModDefs]);
+replace_names_in_defs([],ModDefs) ->
+    ModDefs.
+
+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=[Ch|_]|Ts],Modified,Defs) when is_integer(Ch) ->
+    %% Term *could* be a string, attempt to search through it
+    Term1 = replace_names_in_string(Term,Defs),
+    replace_names(Ts,[Term1|Modified],Defs);
+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 ->
+	    %% if Term is a node name, check it for replacements as well
+	    Elem1 = replace_names_in_node(Elem,Defs),
+	    replace_names_in_elems(Es,[Elem1|Modified],Defs);
+	Replacement ->
+	    replace_names_in_elems(Es,[Replacement|Modified],Defs)
+    end;
+replace_names_in_elems([Elem=[Ch|_]|Es],Modified,Defs) when is_integer(Ch) ->
+    %% Term *could* be a string, attempt to search through it
+    case replace_names_in_string(Elem,Defs) of
+	Elem ->
+	    List = replace_names_in_elems(Elem,[],Defs),
+	    replace_names_in_elems(Es,[List|Modified],Defs);
+	Elem1 ->
+	    replace_names_in_elems(Es,[Elem1|Modified],Defs)
+    end;
+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).
+
+replace_names_in_string(Term,Defs=[{Name,Replacement=[Ch|_]}|Ds])
+  when is_integer(Ch) ->
+    try re:replace(Term,[$'|atom_to_list(Name)]++"'",
+		   Replacement,[{return,list}]) of
+	Term ->					% no match, proceed
+	    replace_names_in_string(Term,Ds);
+	Term1 ->
+	    replace_names_in_string(Term1,Defs)
+    catch
+	_:_ -> Term			% Term is not a string
+    end;
+replace_names_in_string(Term,[_|Ds]) ->
+    replace_names_in_string(Term,Ds);
+replace_names_in_string(Term,[]) ->
+    Term.
+
+replace_names_in_node(Node,Defs) ->
+    String = atom_to_list(Node),
+    case lists:member($@,String) of
+	true ->
+	    list_to_atom(replace_names_in_node1(String,Defs));
+	false ->
+	    Node
+    end.
+
+replace_names_in_node1(NodeStr,Defs=[{Name,Replacement}|Ds]) ->
+    ReplStr = case Replacement of
+		  [Ch|_] when is_integer(Ch) -> Replacement;
+		  _ when is_atom(Replacement) -> atom_to_list(Replacement);
+		  _ -> false
+	      end,
+    if ReplStr == false ->
+	    replace_names_in_node1(NodeStr,Ds);
+       true ->
+	    case re:replace(NodeStr,atom_to_list(Name),
+			    ReplStr,[{return,list}]) of
+		NodeStr ->			% no match, proceed
+		    replace_names_in_node1(NodeStr,Ds);
+		NodeStr1 ->
+		    replace_names_in_node1(NodeStr1,Defs)
+	    end
+    end;
+replace_names_in_node1(NodeStr,[]) ->
+    NodeStr.
+
+
+%% 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)]});
-get_global([_|Ts],Spec) -> get_global(Ts,Spec);
-get_global([],Spec) -> Spec.
+    get_global(Ts,Spec#testspec{nodes=[{Ref,Node} |
+				       lists:keydelete(Node,2,Refs)]});
 
-get_absfile(Callback, FullName,#testspec{spec_dir=SpecDir}) ->
+get_global([_|Ts],Spec) ->
+    get_global(Ts,Spec);
+get_global([],Spec=#testspec{nodes=Ns, alias=As}) ->
+    Spec#testspec{nodes=lists:reverse(Ns), alias=lists:reverse(As)}.
+
+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(),
@@ -329,29 +466,45 @@ get_absfile(FullName,#testspec{spec_dir=SpecDir}) ->
 get_absdir(Dir,#testspec{spec_dir=SpecDir}) ->
     get_absname(Dir,SpecDir).
 
-get_absname(TestDir,SpecDir) ->
-    AbsName = filename:absname(TestDir,SpecDir),
-    TestDirName = filename:basename(AbsName),
-    Path = filename:dirname(AbsName),
-    TopDir = filename:basename(Path),
-    Path1 =
-	case TopDir of
-	    "." ->
-		[_|Rev] = lists:reverse(filename:split(Path)),
-		filename:join(lists:reverse(Rev));
-	    ".." ->
-		[_,_|Rev] = lists:reverse(filename:split(Path)),
-		filename:join(lists:reverse(Rev));
-	    _ ->
-		Path
-	end,
-    filename:join(Path1,TestDirName).
+get_absname(Dir,SpecDir) ->
+    AbsName = filename:absname(Dir,SpecDir),
+    shorten_path(AbsName,SpecDir).
+
+shorten_path(Path,SpecDir) ->
+    case shorten_split_path(filename:split(Path),[]) of
+	[] ->
+	    [Root|_] = filename:split(SpecDir),
+	    Root;
+	Short ->	    
+	    filename:join(Short)
+    end.
+
+shorten_split_path([".."|Path],SoFar) ->
+    shorten_split_path(Path,tl(SoFar));
+shorten_split_path(["."|Path],SoFar) ->
+    shorten_split_path(Path,SoFar);
+shorten_split_path([Dir|Path],SoFar) ->
+    shorten_split_path(Path,[Dir|SoFar]);
+shorten_split_path([],SoFar) ->
+    lists:reverse(SoFar).
 
 %% go through all tests and register all nodes found
 get_all_nodes([{suites,Nodes,_,_}|Ts],Spec) when is_list(Nodes) ->
     get_all_nodes(Ts,save_nodes(Nodes,Spec));
 get_all_nodes([{suites,Node,_,_}|Ts],Spec) ->
     get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{groups,[Char|_],_,_,_}|Ts],Spec) when is_integer(Char) ->
+    get_all_nodes(Ts,Spec);
+get_all_nodes([{groups,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{groups,Nodes,_,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{groups,_,_,_,{cases,_}}|Ts],Spec) ->
+    get_all_nodes(Ts,Spec);
+get_all_nodes([{groups,Node,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{groups,Node,_,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
 get_all_nodes([{cases,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) ->
     get_all_nodes(Ts,save_nodes(Nodes,Spec));
 get_all_nodes([{cases,Node,_,_,_}|Ts],Spec) ->
@@ -360,74 +513,93 @@ get_all_nodes([{skip_suites,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) ->
     get_all_nodes(Ts,save_nodes(Nodes,Spec));
 get_all_nodes([{skip_suites,Node,_,_,_}|Ts],Spec) ->
     get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{skip_groups,[Char|_],_,_,_,_}|Ts],Spec) when is_integer(Char) ->
+    get_all_nodes(Ts,Spec);
+get_all_nodes([{skip_groups,Nodes,_,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{skip_groups,Node,_,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{skip_groups,Nodes,_,_,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{skip_groups,Node,_,_,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
 get_all_nodes([{skip_cases,Nodes,_,_,_,_}|Ts],Spec) when is_list(Nodes) ->
     get_all_nodes(Ts,save_nodes(Nodes,Spec));
 get_all_nodes([{skip_cases,Node,_,_,_,_}|Ts],Spec) ->
     get_all_nodes(Ts,save_nodes([Node],Spec));
-get_all_nodes([_|Ts],Spec) ->
+get_all_nodes([_Other|Ts],Spec) ->
     get_all_nodes(Ts,Spec);
 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, [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);
-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,
+filter_init_terms([{init,InitOptions}|Ts],NewTerms,Spec) ->
+    filter_init_terms([{init,list_nodes(Spec),InitOptions}|Ts],
+		      NewTerms,Spec);
+filter_init_terms([{init,all_nodes,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,[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);
+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,
     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, [], _}|Ts], NewTerms, Spec)->
-    filter_init_terms(Ts, NewTerms, Spec);
-filter_init_terms([Term|Ts], NewTerms, Spec)->
-    filter_init_terms(Ts, [Term|NewTerms], Spec);
-filter_init_terms([], NewTerms, Spec)->
-    {lists:reverse(NewTerms), Spec}.
-
-add_option({Key, Value}, Node, List, WarnIfExists) when is_list(Value)->
-    OldOptions = case lists:keyfind(Node, 1, List) of
-	{Node, Options}->
+    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,[],_}|Ts],NewTerms,Spec) ->
+    filter_init_terms(Ts,NewTerms,Spec);
+filter_init_terms([Term|Ts],NewTerms,Spec) ->
+    filter_init_terms(Ts,[Term|NewTerms],Spec);
+filter_init_terms([],NewTerms,Spec) ->
+    {lists:reverse(NewTerms),Spec}.
+
+add_option({Key,Value},Node,List,WarnIfExists) when is_list(Value) ->
+    OldOptions = case lists:keyfind(Node,1,List) of
+	{Node,Options}->
 	    Options;
 	false->
 	    []
     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",
-		[Key, OldOption, Node, Value]),
+    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",
+		[Key,OldOption,Node,Value]),
 	    OldOption;
-	{Key, OldOption}->
+	{Key,OldOption}->
 	    OldOption ++ Value;
 	false->
 	    Value
     end,
-    lists:keystore(Node, 1, List,
-	{Node, lists:keystore(Key, 1, OldOptions, {Key, NewOption})});
-add_option({Key, Value}, Node, List, WarnIfExists)->
-    add_option({Key, [Value]}, Node, List, WarnIfExists).
+    lists:keystore(Node,1,List,
+	{Node,lists:keystore(Key,1,OldOptions,{Key,NewOption})});
+add_option({Key,Value},Node,List,WarnIfExists) ->
+    add_option({Key,[Value]},Node,List,WarnIfExists).
 
 save_nodes(Nodes,Spec=#testspec{nodes=NodeRefs}) ->
     NodeRefs1 =
@@ -446,267 +618,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) ->
@@ -719,7 +642,7 @@ add_tests([{suites,Nodes,Dir,Ss}|Ts],Spec) when is_list(Nodes) ->
 add_tests([{suites,Node,Dir,Ss}|Ts],Spec) ->
     Tests = Spec#testspec.tests,
     Tests1 = insert_suites(ref2node(Node,Spec#testspec.nodes),
-			   ref2dir(Dir,Spec#testspec.alias),
+			   ref2dir(Dir,Spec),
 			   Ss,Tests, Spec#testspec.merge_tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
 
@@ -739,20 +662,22 @@ 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,
     Tests1 = insert_groups(ref2node(Node,Spec#testspec.nodes),
-			   ref2dir(Dir,Spec#testspec.alias),
+			   ref2dir(Dir,Spec),
 			   Suite,Gs,all,Tests,
 			   Spec#testspec.merge_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),
+			   ref2dir(Dir,Spec),
 			   Suite,Gs,TCs,Tests,
 			   Spec#testspec.merge_tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
@@ -768,7 +693,7 @@ add_tests([{cases,Nodes,Dir,Suite,Cs}|Ts],Spec) when is_list(Nodes) ->
 add_tests([{cases,Node,Dir,Suite,Cs}|Ts],Spec) ->
     Tests = Spec#testspec.tests,
     Tests1 = insert_cases(ref2node(Node,Spec#testspec.nodes),
-			  ref2dir(Dir,Spec#testspec.alias),
+			  ref2dir(Dir,Spec),
 			  Suite,Cs,Tests, Spec#testspec.merge_tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
 
@@ -783,7 +708,7 @@ add_tests([{skip_suites,Nodes,Dir,Ss,Cmt}|Ts],Spec) when is_list(Nodes) ->
 add_tests([{skip_suites,Node,Dir,Ss,Cmt}|Ts],Spec) ->
     Tests = Spec#testspec.tests,
     Tests1 = skip_suites(ref2node(Node,Spec#testspec.nodes),
-			 ref2dir(Dir,Spec#testspec.alias),
+			 ref2dir(Dir,Spec),
 			 Ss,Cmt,Tests,
 			 Spec#testspec.merge_tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
@@ -792,7 +717,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,20 +726,22 @@ 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,
     Tests1 = skip_groups(ref2node(Node,Spec#testspec.nodes),
-			 ref2dir(Dir,Spec#testspec.alias),
+			 ref2dir(Dir,Spec),
 			 Suite,Gs,all,Cmt,Tests,
 			 Spec#testspec.merge_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),
+			 ref2dir(Dir,Spec),
 			 Suite,Gs,TCs,Cmt,Tests,
 			 Spec#testspec.merge_tests),
     add_tests(Ts,Spec#testspec{tests=Tests1});
@@ -829,45 +757,101 @@ add_tests([{skip_cases,Nodes,Dir,Suite,Cs,Cmt}|Ts],Spec) when is_list(Nodes) ->
 add_tests([{skip_cases,Node,Dir,Suite,Cs,Cmt}|Ts],Spec) ->
     Tests = Spec#testspec.tests,
     Tests1 = skip_cases(ref2node(Node,Spec#testspec.nodes),
-			ref2dir(Dir,Spec#testspec.alias),
+			ref2dir(Dir,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([{define,_,_}|Ts],Spec) ->		% handled
+    add_tests(Ts,Spec);
+
 add_tests([{alias,_,_}|Ts],Spec) ->		% handled
     add_tests(Ts,Spec);
 
 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);
 
-%% 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),
-    case lists:keymember(Name,1,valid_terms()) of
-	true ->					% halt
-	    throw({error,{bad_term_in_spec,Other}});
-	false ->				% ignore
-	    case get(relaxed) of
-		true ->
-		    %% warn if name resembles a CT term
-		    case resembles_ct_term(Name,size(Other)) of
-			true ->
-			    io:format("~nSuspicious term, please check:~n"
-				      "~p~n", [Other]);
-			false ->
-			    ok
-		    end,
-		    add_tests(Ts,Spec);
-		false ->
-		    throw({error,{undefined_term_in_spec,Other}})
-	    end
+%%     --------------------------------------------------
+%%   /                                                    \
+%%  |  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) ->
+    case check_term(Term) of
+	valid ->
+	    Tests = [{Tag,Node,Data} ||	Node <- list_nodes(Spec),
+					should_be_added(Tag,Node,Data,Spec)],
+	    add_tests(Tests++Ts,Spec);
+	invalid ->				% ignore term
+	    add_tests(Ts,Spec)
     end;
-
+%% 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 ->
+	    case check_term(Term) of
+		valid ->
+		    Node = ref2node(NodeOrOther,Spec#testspec.nodes),
+		    NodeIxData =
+			update_recorded(Tag,Node,Spec) ++
+			handle_data(Tag,Node,Data,Spec),
+		    add_tests(Ts,mod_field(Spec,Tag,NodeIxData));
+		invalid ->			% ignore term
+		    add_tests(Ts,Spec)
+	    end;
+	false ->
+	    add_tests([{Tag,all_nodes,{NodeOrOther,Data}}|Ts],Spec)
+    end;
+%% this test should be added for all known nodes
+add_tests([Term={Tag,Data}|Ts],Spec) ->
+    case check_term(Term) of
+	valid ->
+	    add_tests([{Tag,all_nodes,Data}|Ts],Spec);
+	invalid ->
+	    add_tests(Ts,Spec)
+    end;
+%% some other data than a tuple
 add_tests([Other|Ts],Spec) ->	
     case get(relaxed) of
 	true ->		
@@ -879,6 +863,105 @@ add_tests([Other|Ts],Spec) ->
 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.
+check_term(Term) ->
+    Size = size(Term),
+    [Name|_] = tuple_to_list(Term),
+    Valid = valid_terms(),
+    case lists:member({Name,Size},Valid) of
+	true ->
+	    valid;
+	false ->
+	    case lists:keymember(Name,1,Valid) of
+		true ->					% halt
+		    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(Term)) of
+				true ->
+				    io:format("~nSuspicious term, "
+					      "please check:~n"
+					      "~p~n", [Term]),
+				    invalid;
+				false ->
+				    invalid
+			    end;
+			false ->
+			    throw({error,{undefined_term_in_spec,Term}})
+		    end
+	    end
+    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.
+
+%% 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 +969,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,...]},
@@ -1094,33 +1195,40 @@ ref2node(all_nodes,_Refs) ->
 ref2node(master,_Refs) ->
     master;
 ref2node(RefOrNode,Refs) ->
-    case string:chr(atom_to_list(RefOrNode),$@) of
-	0 ->					% a ref	    
+    case lists:member($@,atom_to_list(RefOrNode)) of
+	false ->				% a ref	    
 	    case lists:keysearch(RefOrNode,1,Refs) of
 		{value,{RefOrNode,Node}} ->
 		    Node;
 		false ->
 		    throw({error,{noderef_missing,RefOrNode}})
 	    end;
-	_ ->					% a node
+	true ->					% a node
 	    RefOrNode
     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.
-
-is_noderef(What,Nodes) when is_atom(What) ->
-    is_noderef([What],Nodes);
-is_noderef([master|_],_Nodes) ->
+ref2dir(Dir,_,Spec) when is_list(Dir) ->
+    get_absdir(Dir,Spec);
+ref2dir(What,_,_) ->
+    throw({error,{invalid_directory_name,What}}).
+
+is_node(What,Nodes) when is_atom(What) ->
+    is_node([What],Nodes);
+is_node([master|_],_Nodes) ->
     true;
-is_noderef([What|_],Nodes) ->
+is_node(What={N,H},Nodes) when is_atom(N), is_atom(H) ->
+    is_node([What],Nodes);
+is_node([What|_],Nodes) ->
     case lists:keymember(What,1,Nodes) or
 	 lists:keymember(What,2,Nodes) of
 	true ->					
@@ -1128,24 +1236,28 @@ is_noderef([What|_],Nodes) ->
 	false ->
 	    false
     end;
-is_noderef([],_) ->
+is_node([],_) ->
     false.
 
 valid_terms() ->
     [
+     {define,3},
      {node,3},
      {cover,2},
      {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 +1265,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},
@@ -1174,7 +1291,8 @@ valid_terms() ->
      {skip_groups,7},
      {skip_cases,5},
      {skip_cases,6},
-     {create_priv_dir,2}
+     {create_priv_dir,2},
+     {create_priv_dir,3}
     ].
 
 %% this function "guesses" if the user has misspelled a term name
diff --git a/lib/common_test/src/ct_util.hrl b/lib/common_test/src/ct_util.hrl
index 31341c7b55..297d7c665a 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=[],
diff --git a/lib/common_test/test/Makefile b/lib/common_test/test/Makefile
index 4d85b84b5b..74b6c16274 100644
--- a/lib/common_test/test/Makefile
+++ b/lib/common_test/test/Makefile
@@ -39,6 +39,7 @@ MODULES= \
 	ct_sequence_1_SUITE \
 	ct_repeat_1_SUITE \
 	ct_testspec_1_SUITE \
+	ct_testspec_2_SUITE \
 	ct_skip_SUITE \
 	ct_error_SUITE \
 	ct_test_server_if_1_SUITE \
@@ -46,7 +47,9 @@ MODULES= \
 	ct_master_SUITE \
 	ct_misc_1_SUITE \
 	ct_hooks_SUITE \
-	ct_netconfc_SUITE
+	ct_netconfc_SUITE \
+	ct_basic_html_SUITE \
+	ct_auto_compile_SUITE
 
 ERL_FILES= $(MODULES:%=%.erl)
 
diff --git a/lib/common_test/test/ct_auto_compile_SUITE.erl b/lib/common_test/test/ct_auto_compile_SUITE.erl
new file mode 100644
index 0000000000..cc546ed30d
--- /dev/null
+++ b/lib/common_test/test/ct_auto_compile_SUITE.erl
@@ -0,0 +1,187 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2012. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File: ct_auto_compile_SUITE
+%%%
+%%% Description: 
+%%% 
+%%%
+%%% The suites used for the test are located in the data directory.
+%%%-------------------------------------------------------------------
+-module(ct_auto_compile_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+-include_lib("common_test/include/ct_event.hrl").
+
+-define(eh, ct_test_support_eh).
+
+%%--------------------------------------------------------------------
+%% TEST SERVER CALLBACK FUNCTIONS
+%%--------------------------------------------------------------------
+
+%%--------------------------------------------------------------------
+%% Description: Since Common Test starts another Test Server
+%% instance, the tests need to be performed on a separate node (or
+%% there will be clashes with logging processes etc).
+%%--------------------------------------------------------------------
+init_per_suite(Config) ->
+    Config1 = ct_test_support:init_per_suite(Config),
+    Config1.
+
+end_per_suite(Config) ->
+    ct_test_support:end_per_suite(Config).
+
+init_per_testcase(TestCase, Config) ->
+    ct_test_support:init_per_testcase(TestCase, Config).
+
+end_per_testcase(TestCase, Config) ->
+    ct_test_support:end_per_testcase(TestCase, Config).
+
+suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() -> 
+    [ac_flag, ac_spec].
+
+groups() -> 
+    [].
+
+init_per_group(_GroupName, Config) ->
+    Config.
+
+end_per_group(_GroupName, Config) ->
+    Config.
+
+
+
+%%--------------------------------------------------------------------
+%% TEST CASES
+%%--------------------------------------------------------------------
+
+%%%-----------------------------------------------------------------
+%%% 
+ac_flag(Config) when is_list(Config) -> 
+    DataDir = ?config(data_dir, Config),
+    PrivDir = ?config(priv_dir, Config),
+    file:copy(filename:join(DataDir, "bad_SUITE.erl"),
+	      filename:join(PrivDir, "bad_SUITE.erl")), 
+    Suite = filename:join(DataDir, "dummy_SUITE"),
+    compile:file(Suite, [{outdir,PrivDir}]),
+    {Opts,ERPid} = setup([{dir,PrivDir},
+			  {auto_compile,false},
+			  {label,"ac_flag"}],
+			 Config),
+
+    ok = ct_test_support:run(Opts, Config),
+    Events = ct_test_support:get_events(ERPid, Config),
+
+    ct_test_support:log_events(ac_flag, 
+			       reformat(Events, ?eh),
+			       PrivDir,
+			       Opts),
+
+    TestEvents = events_to_check(ac_flag),
+    ok = ct_test_support:verify_events(TestEvents, Events, Config).
+
+%%%-----------------------------------------------------------------
+%%% 
+ac_spec(Config) when is_list(Config) -> 
+    DataDir = ?config(data_dir, Config),
+    PrivDir = ?config(priv_dir, Config),
+    file:copy(filename:join(DataDir, "bad_SUITE.erl"),
+	      filename:join(PrivDir, "bad_SUITE.erl")),
+    TestSpec = [{label,ac_spec},
+		{auto_compile,false},
+		{suites,PrivDir,all}],
+    FileName = filename:join(?config(priv_dir, Config),"ac_spec.spec"),
+    {ok,Dev} = file:open(FileName, [write]),
+    [io:format(Dev, "~p.~n", [Term]) || Term <- TestSpec],
+    file:close(Dev),
+
+    {Opts,ERPid} = setup([{spec,FileName}], Config),
+    ok = ct_test_support:run(Opts, Config),
+    Events = ct_test_support:get_events(ERPid, Config),
+
+    ct_test_support:log_events(ac_spec, 
+			       reformat(Events, ?eh),
+			       PrivDir,
+			       Opts),
+
+    TestEvents = events_to_check(ac_spec),
+    ok = ct_test_support:verify_events(TestEvents, Events, Config).
+
+
+%%%-----------------------------------------------------------------
+%%% HELP FUNCTIONS
+%%%-----------------------------------------------------------------
+
+setup(Test, Config) ->
+    Opts0 = ct_test_support:get_opts(Config),
+    Level = ?config(trace_level, Config),
+    EvHArgs = [{cbm,ct_test_support},{trace_level,Level}],
+    Opts = Opts0 ++ [{event_handler,{?eh,EvHArgs}}|Test],
+    ERPid = ct_test_support:start_event_receiver(Config),
+    {Opts,ERPid}.
+
+reformat(Events, EH) ->
+    ct_test_support:reformat(Events, EH).
+						%reformat(Events, _EH) ->
+						%    Events.
+
+%%%-----------------------------------------------------------------
+%%% TEST EVENTS
+%%%-----------------------------------------------------------------
+events_to_check(Test) ->
+    %% 2 tests (ct:run_test + script_start) is default
+    events_to_check(Test, 2).
+
+events_to_check(_, 0) ->
+    [];
+events_to_check(Test, N) ->
+    test_events(Test) ++ events_to_check(Test, N-1).
+
+test_events(ac_flag) ->
+    [
+     {ct_test_support_eh,start_logging,{'DEF','RUNDIR'}},
+     {ct_test_support_eh,test_start,{'DEF',{'START_TIME','LOGDIR'}}},
+     {ct_test_support_eh,start_info,{1,1,3}},
+     {ct_test_support_eh,tc_start,{dummy_SUITE,init_per_suite}},
+     {ct_test_support_eh,tc_done,{dummy_SUITE,init_per_suite,ok}},
+     {ct_test_support_eh,test_stats,{1,1,{1,0}}},
+     {ct_test_support_eh,tc_start,{dummy_SUITE,end_per_suite}},
+     {ct_test_support_eh,tc_done,{dummy_SUITE,end_per_suite,ok}},
+     {ct_test_support_eh,test_done,{'DEF','STOP_TIME'}},
+     {ct_test_support_eh,stop_logging,[]}
+    ];
+
+test_events(ac_spec) ->
+    [
+     {ct_test_support_eh,start_logging,{'DEF','RUNDIR'}},
+     {ct_test_support_eh,test_start,{'DEF',{'START_TIME','LOGDIR'}}},
+     {ct_test_support_eh,start_info,{1,1,3}},
+     {ct_test_support_eh,tc_start,{dummy_SUITE,init_per_suite}},
+     {ct_test_support_eh,tc_done,{dummy_SUITE,init_per_suite,ok}},
+     {ct_test_support_eh,test_stats,{1,1,{1,0}}},
+     {ct_test_support_eh,tc_start,{dummy_SUITE,end_per_suite}},
+     {ct_test_support_eh,tc_done,{dummy_SUITE,end_per_suite,ok}},
+     {ct_test_support_eh,test_done,{'DEF','STOP_TIME'}},
+     {ct_test_support_eh,stop_logging,[]}
+    ].
diff --git a/lib/common_test/test/ct_auto_compile_SUITE_data/bad_SUITE.erl b/lib/common_test/test/ct_auto_compile_SUITE_data/bad_SUITE.erl
new file mode 100644
index 0000000000..6ebcb3570e
--- /dev/null
+++ b/lib/common_test/test/ct_auto_compile_SUITE_data/bad_SUITE.erl
@@ -0,0 +1,23 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2010. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+
+-module(bad_SUITE).
+
+-compile(export_all).
+
+bad_bad_suite
diff --git a/lib/common_test/test/ct_auto_compile_SUITE_data/dummy_SUITE.erl b/lib/common_test/test/ct_auto_compile_SUITE_data/dummy_SUITE.erl
new file mode 100644
index 0000000000..0b1eafc31d
--- /dev/null
+++ b/lib/common_test/test/ct_auto_compile_SUITE_data/dummy_SUITE.erl
@@ -0,0 +1,130 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2010. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+
+-module(dummy_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+
+%%--------------------------------------------------------------------
+%% @spec suite() -> Info
+%% Info = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+suite() ->
+    [{timetrap,{seconds,30}}].
+
+%%--------------------------------------------------------------------
+%% @spec init_per_suite(Config0) ->
+%%     Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_suite(Config) ->
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_suite(Config0) -> void() | {save_config,Config1}
+%% Config0 = Config1 = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+end_per_suite(_Config) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec init_per_group(GroupName, Config0) ->
+%%               Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% GroupName = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_group(_GroupName, Config) ->
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_group(GroupName, Config0) ->
+%%               void() | {save_config,Config1}
+%% GroupName = atom()
+%% Config0 = Config1 = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+end_per_group(_GroupName, _Config) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec init_per_testcase(TestCase, Config0) ->
+%%               Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% TestCase = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_testcase(_TestCase, Config) ->
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_testcase(TestCase, Config0) ->
+%%               void() | {save_config,Config1} | {fail,Reason}
+%% TestCase = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+end_per_testcase(_TestCase, _Config) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec groups() -> [Group]
+%% Group = {GroupName,Properties,GroupsAndTestCases}
+%% GroupName = atom()
+%% Properties = [parallel | sequence | Shuffle | {RepeatType,N}]
+%% GroupsAndTestCases = [Group | {group,GroupName} | TestCase]
+%% TestCase = atom()
+%% Shuffle = shuffle | {shuffle,{integer(),integer(),integer()}}
+%% RepeatType = repeat | repeat_until_all_ok | repeat_until_all_fail |
+%%              repeat_until_any_ok | repeat_until_any_fail
+%% N = integer() | forever
+%% @end
+%%--------------------------------------------------------------------
+groups() ->
+    [].
+
+%%--------------------------------------------------------------------
+%% @spec all() -> GroupsAndTestCases | {skip,Reason}
+%% GroupsAndTestCases = [{group,GroupName} | TestCase]
+%% GroupName = atom()
+%% TestCase = atom()
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+all() -> 
+    [ok,fail,skip].
+
+
+ok(_Config) -> 
+    ok.
+
+fail(Config) ->
+    tuple_to_list(Config),
+    ok.
+
+skip(_Config) ->
+    {skip,"should be skipped"}.
diff --git a/lib/common_test/test/ct_basic_html_SUITE.erl b/lib/common_test/test/ct_basic_html_SUITE.erl
new file mode 100644
index 0000000000..a5f2e6197e
--- /dev/null
+++ b/lib/common_test/test/ct_basic_html_SUITE.erl
@@ -0,0 +1,180 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2012. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File: ct_basic_html_SUITE
+%%%
+%%% Description: 
+%%% 
+%%%
+%%% The suites used for the test are located in the data directory.
+%%%-------------------------------------------------------------------
+-module(ct_basic_html_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+-include_lib("common_test/include/ct_event.hrl").
+
+-define(eh, ct_test_support_eh).
+
+%%--------------------------------------------------------------------
+%% TEST SERVER CALLBACK FUNCTIONS
+%%--------------------------------------------------------------------
+
+%%--------------------------------------------------------------------
+%% Description: Since Common Test starts another Test Server
+%% instance, the tests need to be performed on a separate node (or
+%% there will be clashes with logging processes etc).
+%%--------------------------------------------------------------------
+init_per_suite(Config) ->
+    Config1 = ct_test_support:init_per_suite(Config),
+    Config1.
+
+end_per_suite(Config) ->
+    ct_test_support:end_per_suite(Config).
+
+init_per_testcase(TestCase, Config) ->
+    ct_test_support:init_per_testcase(TestCase, Config).
+
+end_per_testcase(TestCase, Config) ->
+    ct_test_support:end_per_testcase(TestCase, Config).
+
+suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() -> 
+    [basic_flag, basic_spec].
+
+groups() -> 
+    [].
+
+init_per_group(_GroupName, Config) ->
+    Config.
+
+end_per_group(_GroupName, Config) ->
+    Config.
+
+
+
+%%--------------------------------------------------------------------
+%% TEST CASES
+%%--------------------------------------------------------------------
+
+%%%-----------------------------------------------------------------
+%%% 
+basic_flag(Config) when is_list(Config) -> 
+    DataDir = ?config(data_dir, Config),
+    Suites = [filename:join(DataDir, "babbling_SUITE")],
+    {Opts,ERPid} = setup([{suite,Suites},
+			  {basic_html,true},
+			  {label,"basic_flag"}],
+			 Config),
+
+    ok = ct_test_support:run(Opts, Config),
+    Events = ct_test_support:get_events(ERPid, Config),
+
+    ct_test_support:log_events(basic_flag, 
+			       reformat(Events, ?eh),
+			       ?config(priv_dir, Config),
+			       Opts),
+
+    TestEvents = events_to_check(basic_flag),
+    ok = ct_test_support:verify_events(TestEvents, Events, Config).
+
+%%%-----------------------------------------------------------------
+%%% 
+basic_spec(Config) when is_list(Config) -> 
+    DataDir = ?config(data_dir, Config),
+    TestSpec = [{label,basic_spec},
+		{basic_html,true},
+		{suites,DataDir,babbling_SUITE}],
+    FileName = filename:join(?config(priv_dir, Config),"basic_spec.spec"),
+    {ok,Dev} = file:open(FileName, [write]),
+    [io:format(Dev, "~p.~n", [Term]) || Term <- TestSpec],
+    file:close(Dev),
+
+    {Opts,ERPid} = setup([{spec,FileName}], Config),
+    ok = ct_test_support:run(Opts, Config),
+    Events = ct_test_support:get_events(ERPid, Config),
+
+    ct_test_support:log_events(basic_spec, 
+			       reformat(Events, ?eh),
+			       ?config(priv_dir, Config),
+			       Opts),
+
+    TestEvents = events_to_check(basic_spec),
+    ok = ct_test_support:verify_events(TestEvents, Events, Config).
+
+
+%%%-----------------------------------------------------------------
+%%% HELP FUNCTIONS
+%%%-----------------------------------------------------------------
+
+setup(Test, Config) ->
+    Opts0 = ct_test_support:get_opts(Config),
+    Level = ?config(trace_level, Config),
+    EvHArgs = [{cbm,ct_test_support},{trace_level,Level}],
+    Opts = Opts0 ++ [{event_handler,{?eh,EvHArgs}}|Test],
+    ERPid = ct_test_support:start_event_receiver(Config),
+    {Opts,ERPid}.
+
+reformat(Events, EH) ->
+    ct_test_support:reformat(Events, EH).
+						%reformat(Events, _EH) ->
+						%    Events.
+
+%%%-----------------------------------------------------------------
+%%% TEST EVENTS
+%%%-----------------------------------------------------------------
+events_to_check(Test) ->
+    %% 2 tests (ct:run_test + script_start) is default
+    events_to_check(Test, 2).
+
+events_to_check(_, 0) ->
+    [];
+events_to_check(Test, N) ->
+    test_events(Test) ++ events_to_check(Test, N-1).
+
+test_events(basic_flag) ->
+    [
+     {ct_test_support_eh,start_logging,{'DEF','RUNDIR'}},
+     {ct_test_support_eh,test_start,{'DEF',{'START_TIME','LOGDIR'}}},
+     {ct_test_support_eh,start_info,{1,1,3}},
+     {ct_test_support_eh,tc_start,{babbling_SUITE,init_per_suite}},
+     {ct_test_support_eh,tc_done,{babbling_SUITE,init_per_suite,ok}},
+     {ct_test_support_eh,test_stats,{1,1,{1,0}}},
+     {ct_test_support_eh,tc_start,{babbling_SUITE,end_per_suite}},
+     {ct_test_support_eh,tc_done,{babbling_SUITE,end_per_suite,ok}},
+     {ct_test_support_eh,test_done,{'DEF','STOP_TIME'}},
+     {ct_test_support_eh,stop_logging,[]}
+    ];
+
+test_events(basic_spec) ->
+    [
+     {ct_test_support_eh,start_logging,{'DEF','RUNDIR'}},
+     {ct_test_support_eh,test_start,{'DEF',{'START_TIME','LOGDIR'}}},
+     {ct_test_support_eh,start_info,{1,1,3}},
+     {ct_test_support_eh,tc_start,{babbling_SUITE,init_per_suite}},
+     {ct_test_support_eh,tc_done,{babbling_SUITE,init_per_suite,ok}},
+     {ct_test_support_eh,test_stats,{1,1,{1,0}}},
+     {ct_test_support_eh,tc_start,{babbling_SUITE,end_per_suite}},
+     {ct_test_support_eh,tc_done,{babbling_SUITE,end_per_suite,ok}},
+     {ct_test_support_eh,test_done,{'DEF','STOP_TIME'}},
+     {ct_test_support_eh,stop_logging,[]}
+    ].
diff --git a/lib/common_test/test/ct_basic_html_SUITE_data/babbling_SUITE.erl b/lib/common_test/test/ct_basic_html_SUITE_data/babbling_SUITE.erl
new file mode 100644
index 0000000000..d67383c606
--- /dev/null
+++ b/lib/common_test/test/ct_basic_html_SUITE_data/babbling_SUITE.erl
@@ -0,0 +1,130 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2010. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+
+-module(babbling_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+
+%%--------------------------------------------------------------------
+%% @spec suite() -> Info
+%% Info = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+suite() ->
+    [{timetrap,{seconds,30}}].
+
+%%--------------------------------------------------------------------
+%% @spec init_per_suite(Config0) ->
+%%     Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_suite(Config) ->
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_suite(Config0) -> void() | {save_config,Config1}
+%% Config0 = Config1 = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+end_per_suite(_Config) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec init_per_group(GroupName, Config0) ->
+%%               Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% GroupName = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_group(_GroupName, Config) ->
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_group(GroupName, Config0) ->
+%%               void() | {save_config,Config1}
+%% GroupName = atom()
+%% Config0 = Config1 = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+end_per_group(_GroupName, _Config) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec init_per_testcase(TestCase, Config0) ->
+%%               Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% TestCase = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_testcase(_TestCase, Config) ->
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_testcase(TestCase, Config0) ->
+%%               void() | {save_config,Config1} | {fail,Reason}
+%% TestCase = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+end_per_testcase(_TestCase, _Config) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec groups() -> [Group]
+%% Group = {GroupName,Properties,GroupsAndTestCases}
+%% GroupName = atom()
+%% Properties = [parallel | sequence | Shuffle | {RepeatType,N}]
+%% GroupsAndTestCases = [Group | {group,GroupName} | TestCase]
+%% TestCase = atom()
+%% Shuffle = shuffle | {shuffle,{integer(),integer(),integer()}}
+%% RepeatType = repeat | repeat_until_all_ok | repeat_until_all_fail |
+%%              repeat_until_any_ok | repeat_until_any_fail
+%% N = integer() | forever
+%% @end
+%%--------------------------------------------------------------------
+groups() ->
+    [].
+
+%%--------------------------------------------------------------------
+%% @spec all() -> GroupsAndTestCases | {skip,Reason}
+%% GroupsAndTestCases = [{group,GroupName} | TestCase]
+%% GroupName = atom()
+%% TestCase = atom()
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+all() -> 
+    [ok,fail,skip].
+
+
+ok(_Config) -> 
+    ok.
+
+fail(Config) ->
+    tuple_to_list(Config),
+    ok.
+
+skip(_Config) ->
+    {skip,"should be skipped"}.
diff --git a/lib/common_test/test/ct_testspec_2_SUITE.erl b/lib/common_test/test/ct_testspec_2_SUITE.erl
new file mode 100644
index 0000000000..93f3520f95
--- /dev/null
+++ b/lib/common_test/test/ct_testspec_2_SUITE.erl
@@ -0,0 +1,751 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2011. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File: ct_testspec_2_SUITE
+%%%
+%%% Description:
+%%% Test test specifications
+%%%
+%%% The suites used for the test are located in the data directory.
+%%%-------------------------------------------------------------------
+-module(ct_testspec_2_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+-include_lib("common_test/src/ct_util.hrl").
+
+%%--------------------------------------------------------------------
+%% TEST SERVER CALLBACK FUNCTIONS
+%%--------------------------------------------------------------------
+
+init_per_suite(Config) ->
+    Config.
+
+end_per_suite(_Config) ->
+    ok.
+
+init_per_testcase(_TestCase, Config) ->
+    Config.
+
+end_per_testcase(_TestCase, _Config) ->
+    ok.
+
+%% suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() -> 
+    [basic_compatible_no_nodes,
+     basic_compatible_nodes,
+     unknown_terms,
+     no_merging,
+     multiple_specs,
+     misc_config_terms,
+     define_names_1].
+
+
+%%--------------------------------------------------------------------
+%% VALID TEST SPEC TERMS (R15B02):
+%%
+%% {node,3}
+%% {cover,2}
+%% {cover,3}
+%% {config,2}
+%% {config,3}
+%% {config,4}
+%% {userconfig,2}
+%% {userconfig,3}
+%% {alias,3}
+%% {merge_tests,2}
+%% {logdir,2}
+%% {logdir,3}
+%% {logopts,2}
+%% {logopts,3}
+%% {basic_html,2}
+%% {basic_html,3}
+%% {label,2}
+%% {label,3}
+%% {event_handler,2}
+%% {event_handler,3}
+%% {event_handler,4}
+%% {ct_hooks,2}
+%% {ct_hooks,3}
+%% {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}
+%% {groups,5}
+%% {groups,6}
+%% {cases,4}
+%% {cases,5}
+%% {skip_suites,4}
+%% {skip_suites,5}
+%% {skip_groups,5}
+%% {skip_groups,6}
+%% {skip_groups,7}
+%% {skip_cases,5}
+%% {skip_cases,6}
+%% {create_priv_dir,2}
+%%
+%%--------------------------------------------------------------------
+
+%%--------------------------------------------------------------------
+%% TEST CASES
+%%--------------------------------------------------------------------
+
+%%%-----------------------------------------------------------------
+%%%
+basic_compatible_no_nodes(_Config) ->
+
+    AliasDir1 = "../tests/to1",
+    AliasDir2 = "../tests/to2",
+    CfgDir1 = "../cfgs/to1/x.cfg",
+    CfgDir2 = ["../cfgs/to2/x.cfg","../cfgs/to2/y.cfg"],
+    LogDir = "../logs",
+    IncludeDir1 = "../../include",
+    IncludeDir2 = ["../tests/to1/include","../tests/to2/include"],
+
+    Spec =
+	[
+	 {label,"basic_compatible_no_nodes"},
+	 {alias,to1,AliasDir1},
+	 {alias,to2,AliasDir2},
+	 {config,CfgDir1},
+	 {config,CfgDir2},
+	 {userconfig,{?MODULE,"cfg_str1"}},
+	 {userconfig,{?MODULE,"cfg_str2"}},
+	 {logdir,LogDir},
+	 {logopts,[no_nl]},
+	 {event_handler,evh1,[1]},
+	 {event_handler,[evh2,evh3],[[2,3]]},
+	 {ct_hooks,[{cth_mod1,[]}]},
+	 {ct_hooks,[{cth_mod2,[]}]},
+	 {multiply_timetraps,2},
+	 {include,IncludeDir1},
+	 {include,IncludeDir2},
+	 {suites,to1,[x_SUITE]},
+	 {groups,to1,y_SUITE,[g1,g2]},
+	 {cases,to1,y_SUITE,[tc1,tc2]},
+	 {skip_suites,to1,z_SUITE,"skipped"},
+	 {suites,to2,[x_SUITE,y_SUITE]},
+	 {skip_groups,to2,x_SUITE,[g1,g2],"skipped"},
+	 {skip_cases,to2,y_SUITE,[tc1,tc2],"skipped"}
+	],
+    
+    {ok,SpecDir} = file:get_cwd(),
+    
+    ListResult = ct_testspec:collect_tests_from_list(Spec, false),
+    ct:pal("TESTSPEC RECORD FROM LIST:~n~p~n", [rec2proplist(ListResult)]),	
+    SpecFile = ct_test_support:write_testspec(Spec,SpecDir,
+					      "basic_compatible_no_nodes.spec"),
+    FileResult = ct_testspec:collect_tests_from_file([SpecFile], false),
+    ct:pal("TESTSPEC RECORD FROM FILE:~n~p~n", [rec2proplist(FileResult)]),
+    
+    Node = node(),
+    LogDirV = get_absdir(filename:join(SpecDir,"../logs")),
+    Alias1V = get_absdir(filename:join(SpecDir,AliasDir1)),
+    Alias2V = get_absdir(filename:join(SpecDir,AliasDir2)),
+    CFGs = [{Node,get_absdir(filename:join(SpecDir,CfgDir))} ||
+	       CfgDir <- [CfgDir1 | CfgDir2]],
+    Incls = [{Node,get_absdir(filename:join(SpecDir,IncludeDir))} ||
+		IncludeDir <- [IncludeDir1 | IncludeDir2]],
+    
+    Verify = #testspec{spec_dir = SpecDir,
+		       nodes = [{undefined,Node}],
+		       init = [],
+		       label = [{Node,"basic_compatible_no_nodes"}],
+		       logdir = [{Node,LogDirV},"."],
+		       logopts = [{Node,[no_nl]}],
+		       basic_html = [],
+		       cover = [],
+		       config = CFGs,
+		       userconfig = [{Node,{?MODULE,"cfg_str1"}},
+				     {Node,{?MODULE,"cfg_str2"}}],
+		       event_handler = [{Node,evh1,[1]},
+					{Node,evh2,[[2,3]]},
+					{Node,evh3,[[2,3]]}],
+		       ct_hooks = [{Node,{cth_mod1,[]}},
+				   {Node,{cth_mod2,[]}}],
+		       enable_builtin_hooks = true,
+		       noinput = false,
+		       include = Incls,
+		       auto_compile = [],
+		       stylesheet = [],
+		       multiply_timetraps = [{Node,2}],
+		       scale_timetraps = [],
+		       create_priv_dir = [],
+		       alias = [{to1,Alias1V},{to2,Alias2V}],			
+		       tests = [{{Node,Alias1V},
+				 [{x_SUITE,[all]},
+				  {y_SUITE,[{g1,all},{g2,all},tc1,tc2]},
+				  {z_SUITE,[{all,{skip,"skipped"}}]}]},
+				{{Node,Alias2V},
+				 [{x_SUITE,[all,
+					    {{g1,all},{skip,"skipped"}},
+					    {{g2,all},{skip,"skipped"}}]},
+				  {y_SUITE,[all,
+					    {tc1,{skip,"skipped"}},
+					    {tc2,{skip,"skipped"}}]}]}],
+		       merge_tests = true},
+
+    verify_result(Verify,ListResult,FileResult).
+
+%%%-----------------------------------------------------------------
+%%%
+basic_compatible_nodes(_Config) ->
+
+    Node1 = node1@host1,
+    Node2 = node2@host2,
+    TODir1 = "../tests/to1",
+    TODir2 = "../tests/to2",
+    CfgDir1 = "../cfgs/to1/x.cfg",
+    CfgDir2 = ["../cfgs/to2/x.cfg","../cfgs/to2/y.cfg"],
+    LogDir = "../logs",
+    MasterLogDir = "../master_logs",
+    IncludeDir1 = "../../include",
+    IncludeDir2 = ["../tests/to1/include","../tests/to2/include"],
+
+    Spec =
+	[
+	 {node,n1,Node1},
+	 {node,n2,Node2},
+	 {init,[n1],[{node_start,[{callback_module,cbm}]}]},
+	 {init,n2,[{node_start,[]}]},
+	 {init,all_nodes,{eval,{mod,func,[]}}},
+	 {label,"basic_compatible_nodes"},
+	 {label,n1,basic_compatible_nodes_1},
+	 {config,n1,CfgDir1},
+	 {config,n2,CfgDir2},
+	 {userconfig,{?MODULE,"cfg_str1"}},
+	 {userconfig,{?MODULE,"cfg_str2"}},
+	 {logdir,all_nodes,LogDir},
+	 {logdir,master,MasterLogDir},
+	 {logopts,node2@host2,[no_nl]},
+	 {event_handler,master,evh1,[1]},
+	 {event_handler,[n1,n2],[evh2,evh3],[[2,3]]},
+	 {ct_hooks,all_nodes,[{cth_mod1,[]}]},
+	 {ct_hooks,[{cth_mod2,[]}]},
+	 {multiply_timetraps,node1@host1,2},
+	 {include,n1,IncludeDir1},
+	 {include,[n1,n2],IncludeDir2},
+	 {suites,n1,TODir1,[x_SUITE]},
+	 {groups,n1,TODir1,y_SUITE,[g1,g2]},
+	 {cases,n1,TODir1,y_SUITE,[tc1,tc2]},
+	 {skip_suites,n1,TODir1,z_SUITE,"skipped"},
+	 {suites,n2,TODir2,[x_SUITE,y_SUITE]},
+	 {skip_groups,n2,TODir2,x_SUITE,[g1,g2],"skipped"},
+	 {skip_cases,n2,TODir2,y_SUITE,[tc1,tc2],"skipped"}
+	],
+    
+    {ok,SpecDir} = file:get_cwd(),
+    
+    ListResult = ct_testspec:collect_tests_from_list(Spec, false),
+    ct:pal("TESTSPEC RECORD FROM LIST:~n~p~n", [rec2proplist(ListResult)]),	
+    SpecFile = ct_test_support:write_testspec(Spec,SpecDir,
+					      "basic_compatible_nodes.spec"),
+    FileResult = ct_testspec:collect_tests_from_file([SpecFile], false),
+    ct:pal("TESTSPEC RECORD FROM FILE:~n~p~n", [rec2proplist(FileResult)]),
+    
+    Node = node(),
+    LogDirV = get_absdir(filename:join(SpecDir,"../logs")),
+    MasterLogDirV = get_absdir(filename:join(SpecDir,"../master_logs")),
+    TO1V = get_absdir(filename:join(SpecDir,TODir1)),
+    TO2V = get_absdir(filename:join(SpecDir,TODir2)),
+    CFGs = [{Node1,get_absdir(filename:join(SpecDir,CfgDir1))} |
+	    [{Node2,get_absdir(filename:join(SpecDir,CfgDir))} || CfgDir <- CfgDir2]],
+    Incls = [{Node1,get_absdir(filename:join(SpecDir,IncludeDir1))} |
+	     [{Node1,get_absdir(filename:join(SpecDir,IncludeDir))} ||
+		 IncludeDir <- IncludeDir2] ++
+	     [{Node2,get_absdir(filename:join(SpecDir,IncludeDir))} ||
+		 IncludeDir <- IncludeDir2]],
+    
+    Verify = #testspec{spec_dir = SpecDir,
+		       nodes = [{undefined,Node},{n1,Node1},{n2,Node2}],
+		       init = [{Node1,[{node_start,[{callback_module,cbm}]},
+				       {eval,[{mod,func,[]}]}]},
+			       {Node2,[{node_start,[{callback_module,ct_slave}]},
+				       {eval,[{mod,func,[]}]}]},
+			       {Node,[{node_start,[]},
+				      {eval,[{mod,func,[]}]}]}],
+		       label = [{Node,"basic_compatible_nodes"},
+				{Node2,"basic_compatible_nodes"},
+				{Node1,basic_compatible_nodes_1}],
+		       logdir = [{Node,LogDirV},{Node1,LogDirV},{Node2,LogDirV},
+				 {master,MasterLogDirV},"."],
+		       logopts = [{Node2,[no_nl]}],
+		       basic_html = [],
+		       cover = [],
+		       config = CFGs,
+		       userconfig = [{Node,{?MODULE,"cfg_str1"}},
+				     {Node1,{?MODULE,"cfg_str1"}},
+				     {Node2,{?MODULE,"cfg_str1"}},
+				     {Node,{?MODULE,"cfg_str2"}},
+				     {Node1,{?MODULE,"cfg_str2"}},
+				     {Node2,{?MODULE,"cfg_str2"}}],
+		       event_handler = [{master,evh1,[1]},
+					{Node1,evh2,[[2,3]]},
+					{Node1,evh3,[[2,3]]},
+					{Node2,evh2,[[2,3]]},
+					{Node2,evh3,[[2,3]]}],
+		       ct_hooks = [{Node,{cth_mod1,[]}},
+				   {Node1,{cth_mod1,[]}},
+				   {Node2,{cth_mod1,[]}},
+				   {Node,{cth_mod2,[]}},
+				   {Node1,{cth_mod2,[]}},
+				   {Node2,{cth_mod2,[]}}],
+		       enable_builtin_hooks = true,
+		       noinput = false,
+		       include = Incls,
+		       auto_compile = [],
+		       stylesheet = [],
+		       multiply_timetraps = [{Node1,2}],
+		       scale_timetraps = [],
+		       create_priv_dir = [],
+		       tests = [{{Node1,TO1V},
+				 [{x_SUITE,[all]},
+				  {y_SUITE,[{g1,all},{g2,all},tc1,tc2]},
+				  {z_SUITE,[{all,{skip,"skipped"}}]}]},
+				{{Node2,TO2V},
+				 [{x_SUITE,[all,
+					    {{g1,all},{skip,"skipped"}},
+					    {{g2,all},{skip,"skipped"}}]},
+				  {y_SUITE,[all,
+					    {tc1,{skip,"skipped"}},
+					    {tc2,{skip,"skipped"}}]}]}],
+		       merge_tests = true},
+
+    verify_result(Verify,ListResult,FileResult).
+
+%%%-----------------------------------------------------------------
+%%%
+unknown_terms(Config) ->
+    PrivDir = ?config(priv_dir, Config),
+
+    Spec1 = [{suites,PrivDir,all},
+	     {userdata,"I've got news for you"}],
+    {error,{undefined_term_in_spec,{userdata,_}}} =
+	(catch ct_testspec:collect_tests_from_list(Spec1, false)),
+    true = is_record(ct_testspec:collect_tests_from_list(Spec1, true),
+		      testspec),
+    
+    Spec2 = [{logdir,{logdir,PrivDir}}],
+    {error,{invalid_directory_name,_}} =
+	(catch ct_testspec:collect_tests_from_list(Spec2, false)),
+    
+    Spec3 = [{suite,PrivDir,all}],
+    {error,{undefined_term_in_spec,{suite,_,_}}} =
+	(catch ct_testspec:collect_tests_from_list(Spec3, false)),
+    true = is_record(ct_testspec:collect_tests_from_list(Spec3, true), testspec),
+    
+    Spec4 = [{suites,PrivDir,all},
+	     {skip_suites,PrivDir,x_SUITE}],
+    {error,{bad_term_in_spec,{skip_suites,_,_}}} =
+	(catch ct_testspec:collect_tests_from_list(Spec4, false)),
+    {error,{bad_term_in_spec,{skip_suites,_,_}}} =
+	(catch ct_testspec:collect_tests_from_list(Spec4, true)),
+
+    Spec5 = [{configs,all_nodes,PrivDir}],
+    {error,{undefined_term_in_spec,{configs,_,_}}} =
+	(catch ct_testspec:collect_tests_from_list(Spec5, false)),
+    true = is_record(ct_testspec:collect_tests_from_list(Spec5, true), testspec),
+  
+    ok.
+
+%%%-----------------------------------------------------------------
+%%%
+no_merging(_Config) ->    
+    Node1 = node1@host1,
+    Node2 = node2@host2,
+    TODir1 = "../tests/to1",
+    TODir2 = "../tests/to2",
+    Spec =
+	[
+	 {merge_tests,false},
+	 {node,n1,Node1},
+	 {node,n2,Node2},
+	 {suites,n1,TODir1,[x_SUITE]},
+	 {groups,n1,TODir1,y_SUITE,[g1,g2]},
+	 {cases,n1,TODir1,y_SUITE,[tc1,tc2]},
+	 {skip_suites,n1,TODir1,z_SUITE,"skipped"},
+	 {suites,n2,TODir2,[x_SUITE,y_SUITE]},
+	 {skip_groups,n2,TODir2,x_SUITE,[g1,g2],"skipped"},
+	 {skip_cases,n2,TODir2,y_SUITE,[tc1,tc2],"skipped"}
+	],
+    
+    {ok,SpecDir} = file:get_cwd(),
+    
+    ListResult = ct_testspec:collect_tests_from_list(Spec, false),
+    ct:pal("TESTSPEC RECORD FROM LIST:~n~p~n", [rec2proplist(ListResult)]),	
+    SpecFile = ct_test_support:write_testspec(Spec,SpecDir,
+					      "no_merging.spec"),
+    FileResult = ct_testspec:collect_tests_from_file([SpecFile], false),
+    ct:pal("TESTSPEC RECORD FROM FILE:~n~p~n", [rec2proplist(FileResult)]),
+    
+    Node = node(),
+    TO1V = get_absdir(filename:join(SpecDir,TODir1)),
+    TO2V = get_absdir(filename:join(SpecDir,TODir2)),
+    
+    Verify = #testspec{merge_tests = false,
+		       spec_dir = SpecDir,
+		       nodes = [{undefined,Node},{n1,Node1},{n2,Node2}],
+		       tests = [{{Node1,TO1V},
+				 [{x_SUITE,[all]}]},
+				{{Node1,TO1V},
+				 [{y_SUITE,[{g1,all},{g2,all}]}]},
+				{{Node1,TO1V},
+				 [{y_SUITE,[tc1,tc2]}]},
+				{{Node1,TO1V},
+				 [{z_SUITE,[{all,{skip,"skipped"}}]}]},
+				{{Node2,TO2V},
+				 [{x_SUITE,[all]}]},
+				{{Node2,TO2V},
+				 [{y_SUITE,[all]}]},
+				{{Node2,TO2V},
+				 [{x_SUITE,[{{g1,all},{skip,"skipped"}},
+					    {{g2,all},{skip,"skipped"}}]}]},
+				{{Node2,TO2V},
+				 [{y_SUITE,[{tc1,{skip,"skipped"}},
+					    {tc2,{skip,"skipped"}}]}]}]},
+		       
+    verify_result(Verify,ListResult,FileResult).
+
+%%%-----------------------------------------------------------------
+%%%
+multiple_specs(_Config) ->
+    Node1 = node1@host1,
+    Node2 = node2@host2,
+    TODir1 = "../tests/to1",
+    TODir2 = "../tests/to2",
+    CfgDir1 = "../cfgs/to1/x.cfg",
+    CfgDir2 = ["../cfgs/to2/x.cfg","../cfgs/to2/y.cfg"],
+    LogDir = "../logs",
+    Spec1 =
+	[
+	 {node,n1,Node1},
+	 {node,n2,Node2},
+	 {alias,to1,TODir1},
+	 {alias,to2,TODir2},
+	 {label,"multiple_specs1"},
+	 {config,n1,CfgDir1},
+	 {config,n2,CfgDir2},
+	 {logdir,all_nodes,LogDir}
+	],
+    Spec2 =
+	[
+	 {merge_tests,false},
+	 {label,"multiple_specs2"},
+	 {suites,n1,TODir1,[x_SUITE]},
+	 {groups,n1,TODir1,y_SUITE,[g1,g2]},
+	 {cases,n1,TODir1,y_SUITE,[tc1,tc2]},
+	 {skip_suites,n1,TODir1,z_SUITE,"skipped"},
+	 {suites,n2,TODir2,[x_SUITE,y_SUITE]},
+	 {skip_groups,n2,TODir2,x_SUITE,[g1,g2],"skipped"},
+	 {skip_cases,n2,TODir2,y_SUITE,[tc1,tc2],"skipped"}
+	],
+    
+    {ok,SpecDir} = file:get_cwd(),    
+    SpecFile1 = ct_test_support:write_testspec(Spec1,SpecDir,
+					      "multiple_specs.1.spec"),
+    SpecFile2 = ct_test_support:write_testspec(Spec2,SpecDir,
+					      "multiple_specs.2.spec"),
+    FileResult = ct_testspec:collect_tests_from_file([SpecFile1,SpecFile2],
+						     false),
+    ct:pal("TESTSPEC RECORD FROM FILE:~n~p~n", [rec2proplist(FileResult)]),
+    
+    Node = node(),
+    TO1V = get_absdir(filename:join(SpecDir,TODir1)),
+    TO2V = get_absdir(filename:join(SpecDir,TODir2)),
+    CFGs = [{Node1,get_absdir(filename:join(SpecDir,CfgDir1))} |
+	    [{Node2,get_absdir(filename:join(SpecDir,CfgDir))} || CfgDir <- CfgDir2]],
+    LogDirV = get_absdir(filename:join(SpecDir,"../logs")),
+
+    Verify = #testspec{merge_tests = false,
+		       spec_dir = SpecDir,
+		       nodes = [{undefined,Node},{n1,Node1},{n2,Node2}],
+		       alias = [{to1,TO1V},{to2,TO2V}],
+		       label = [{Node,"multiple_specs1"},
+				{Node1,"multiple_specs1"},
+				{Node2,"multiple_specs1"}],
+		       logdir = [{Node,LogDirV},{Node1,LogDirV},{Node2,LogDirV},"."],
+		       config = CFGs,
+		       tests = [{{Node1,TO1V},
+				 [{x_SUITE,[all]}]},
+				{{Node1,TO1V},
+				 [{y_SUITE,[{g1,all},{g2,all}]}]},
+				{{Node1,TO1V},
+				 [{y_SUITE,[tc1,tc2]}]},
+				{{Node1,TO1V},
+				 [{z_SUITE,[{all,{skip,"skipped"}}]}]},
+				{{Node2,TO2V},
+				 [{x_SUITE,[all]}]},
+				{{Node2,TO2V},
+				 [{y_SUITE,[all]}]},
+				{{Node2,TO2V},
+				 [{x_SUITE,[{{g1,all},{skip,"skipped"}},
+					    {{g2,all},{skip,"skipped"}}]}]},
+				{{Node2,TO2V},
+				 [{y_SUITE,[{tc1,{skip,"skipped"}},
+					    {tc2,{skip,"skipped"}}]}]}]},
+		       
+    verify_result(Verify,FileResult,FileResult).
+
+%%%-----------------------------------------------------------------
+%%% 
+misc_config_terms(_Config) ->
+    CfgDir = "../cfgs/to1",
+
+    Spec =
+	[{node,x,n1@h1},{node,y,n2@h2},
+
+	 {config,CfgDir,"a.cfg"},
+	 {config,n1@h1,CfgDir,"b.cfg"},
+	 {config,all_nodes,CfgDir,"c.cfg"},
+	 {config,all_nodes,filename:join(CfgDir,"d.cfg")},
+
+	 {basic_html,true},
+	 {basic_html,n1@h1,false},
+	 {basic_html,n2@h2,true},
+	 
+	 {enable_builtin_hooks,false},
+
+	 {noinput,true},
+
+	 {auto_compile,false},
+	 {auto_compile,n1@h1,true},
+	 {auto_compile,n2@h2,false},
+
+	 {stylesheet,"../css"},
+	 {stylesheet,n1@h1,"./n1/css"},
+	 {stylesheet,n2@h2,"./n2/css"},
+
+	 {create_priv_dir,[auto_per_tc]},
+	 {create_priv_dir,n1@h1,[manual_per_tc]},
+	 {create_priv_dir,n2@h2,[auto_per_run]}
+	],
+    
+    {ok,SpecDir} = file:get_cwd(),
+    
+    ListResult = ct_testspec:collect_tests_from_list(Spec, false),
+    ct:pal("TESTSPEC RECORD FROM LIST:~n~p~n", [rec2proplist(ListResult)]),	
+    SpecFile = ct_test_support:write_testspec(Spec,SpecDir,
+					      "misc_config_terms.spec"),
+    FileResult = ct_testspec:collect_tests_from_file([SpecFile], false),
+    ct:pal("TESTSPEC RECORD FROM FILE:~n~p~n", [rec2proplist(FileResult)]),
+    
+    Node = node(),
+    CfgA = get_absdir(filename:join(filename:join(SpecDir,CfgDir), "a.cfg")),
+    CfgB = get_absdir(filename:join(filename:join(SpecDir,CfgDir), "b.cfg")),
+    CfgC = get_absdir(filename:join(filename:join(SpecDir,CfgDir), "c.cfg")),
+    CfgD = get_absdir(filename:join(filename:join(SpecDir,CfgDir), "d.cfg")),
+    CSS = get_absdir(filename:join(SpecDir,"../css")),
+    CSS1 = get_absdir(filename:join(SpecDir,"./n1/css")),
+    CSS2 = get_absdir(filename:join(SpecDir,"./n2/css")),
+    
+    Verify = #testspec{spec_dir = SpecDir,
+		       nodes = [{undefined,Node},{x,n1@h1},{y,n2@h2}],
+		       basic_html = [{Node,true},{n1@h1,false},{n2@h2,true}],
+		       config = [{Node,CfgA},
+				 {n1@h1,CfgA},
+				 {n2@h2,CfgA},
+				 {n1@h1,CfgB},
+				 {Node,CfgC},
+				 {n1@h1,CfgC},
+				 {n2@h2,CfgC},
+				 {Node,CfgD},
+				 {n1@h1,CfgD},
+				 {n2@h2,CfgD}],
+		       enable_builtin_hooks = false,
+		       noinput = true,
+		       auto_compile = [{Node,false},
+				       {n1@h1,true},
+				       {n2@h2,false}],
+		       stylesheet = [{Node,CSS},
+				     {n1@h1,CSS1},
+				     {n2@h2,CSS2}],	       
+		       create_priv_dir = [{Node,[auto_per_tc]},
+					  {n1@h1,[manual_per_tc]},
+					  {n2@h2,[auto_per_run]}]
+		      },
+    
+    verify_result(Verify,ListResult,FileResult).
+
+%%%-----------------------------------------------------------------
+%%% 
+define_names_1(_Config) ->
+    Spec =
+	[
+	 {define,'HOST','eniac'},
+	 {define,'NODE1',testnode1},
+	 {define,'NODE2',testnode2},
+	 {define,'NODES',['NODE1@HOST',
+			  'NODE2@HOST']},
+	 {define,'TOPDIR',".."},
+	 {define,'TO1',"to1"},
+	 {define,'TO2',"to2"},
+	 {define,'LOGDIR',"'TOPDIR'/logdir"},
+	 {define,'LOGDIR1',"'TOPDIR'/logdir1"},
+	 {define,'LOGDIR2',"'TOPDIR'/logdir2"},
+	 {define,'CFGDIR',"'TOPDIR'/cfgs"},
+	 {define,'CFGFILES',["cfgX","cfgY"]},
+	 {define,'TESTDIR',"'TOPDIR'/test"},
+	 {define,'TO1DIR',"'TESTDIR'/'TO1'"},
+	 {define,'TO2DIR',"'TESTDIR'/'TO2'"},
+	 {define,'EXSUITE',ex_SUITE},
+	 {define,'EXGRS',[g1,g2]},
+
+	 {logdir,'LOGDIR'},
+	 {logdir,'NODE1@HOST','LOGDIR1'},
+	 {logdir,'NODE2@HOST','LOGDIR2'},
+
+	 {config,["a.cfg","b.cfg"]},
+	 {config,'NODES',"./'CFGDIR'/c.cfg"},
+	 {config,'CFGDIR',["d.cfg","e.cfg"]},
+	 {config,'NODE2@HOST','CFGDIR','CFGFILES'},
+
+	 {suites,'NODE1@HOST','TO1DIR',all},
+	 {suites,'NODES','TO2DIR',all},
+
+	 {groups,'TO1DIR','EXSUITE','EXGRS'}
+	],
+    
+    {ok,SpecDir} = file:get_cwd(),
+    
+    ListResult = ct_testspec:collect_tests_from_list(Spec, false),
+    ct:pal("TESTSPEC RECORD FROM LIST:~n~p~n", [rec2proplist(ListResult)]),	
+    SpecFile = ct_test_support:write_testspec(Spec,SpecDir,
+					      "define_names_1.spec"),
+    FileResult = ct_testspec:collect_tests_from_file([SpecFile], false),
+    ct:pal("TESTSPEC RECORD FROM FILE:~n~p~n", [rec2proplist(FileResult)]),
+    
+    N = node(),
+    N1 = testnode1@eniac,
+    N2 = testnode2@eniac,
+    Join = fun(Dir) -> shorten_path(filename:join(SpecDir,Dir),SpecDir) end,
+
+    Verify = #testspec{spec_dir = SpecDir,
+		       nodes = [{undefined,N2},
+				{undefined,N1},
+				{undefined,N}],
+		       config = [{N2,Join("a.cfg")},{N2,Join("b.cfg")},
+				 {N1,Join("a.cfg")},{N1,Join("b.cfg")},
+				 {N,Join("a.cfg")},{N,Join("b.cfg")},
+				 {N1,Join("../cfgs/c.cfg")},{N2,Join("../cfgs/c.cfg")},
+				 {N2,Join("../cfgs/d.cfg")},{N2,Join("../cfgs/e.cfg")},
+				 {N1,Join("../cfgs/d.cfg")},{N1,Join("../cfgs/e.cfg")},
+				 {N,Join("../cfgs/d.cfg")},{N,Join("../cfgs/e.cfg")},
+				 {N2,Join("../cfgs/cfgX")},{N2,Join("../cfgs/cfgY")}],
+		       logdir = [{N,Join("../logdir")},
+				 {N1,Join("../logdir1")},
+				 {N2,Join("../logdir2")},
+				 "."],
+		       tests = [{{N1,Join("../test/to1")},[{all,[all]}]},
+				{{N1,Join("../test/to2")},[{all,[all]}]},
+				{{N2,Join("../test/to2")},[{all,[all]}]},
+				{{N2,Join("../test/to1")},
+				 [{ex_SUITE,[{g1,all},{g2,all}]}]},
+				{{N,Join("../test/to1")},
+				 [{ex_SUITE,[{g1,all},{g2,all}]}]}]
+		      },    
+    verify_result(Verify,ListResult,FileResult).
+
+
+%%%-----------------------------------------------------------------
+%%% HELP FUNCTIONS
+%%%-----------------------------------------------------------------
+
+verify_result(Verify,ListResult,FileResult) ->
+    {_,TSLTuples} = rec2proplist(ListResult),
+    {_,TSFTuples} = rec2proplist(FileResult),
+    {_,VTuples} = rec2proplist(Verify),    
+    VResult =
+	(catch lists:foldl(fun({Tag,Val},{[{Tag,Val}|TSL],[{Tag,Val}|TSF]}) ->
+				   {TSL,TSF};
+			      ({Tag,Val},{[{_Tag,TSLVal}|_TSL],[{Tag,Val}|_TSF]}) ->
+				   exit({ts_list_mismatch,Tag,Val,TSLVal});
+			      ({Tag,Val},{[{Tag,Val}|_TSL],[{_Tag,TSFVal}|_TSF]}) ->
+				   exit({ts_file_mismatch,Tag,Val,TSFVal});
+			      ({Tag,Val},{_,[{_Tag,TSFVal}|_TSF]}) ->
+				   exit({ts_mismatch,Tag,Val,TSFVal})
+			   end, {TSLTuples,TSFTuples}, VTuples)),
+	       case VResult of
+		  {'EXIT',Reason} ->
+		      ct:fail(Reason);
+		  _ ->
+		      ok
+	       end,
+    ok.
+
+
+check_parameter(S="cfg_str1") ->
+    {ok,{config,S}};
+check_parameter(S="cfg_str2") ->
+    {ok,{config,S}}.
+read_config(S) ->
+    {ok,[{cfg,S}]}.
+
+rec2proplist(E={error,_What}) ->
+    exit({invalid_testspec_record,E});
+rec2proplist(Rec) ->
+    [RecName|RecList] = tuple_to_list(Rec),
+    FieldNames = 
+	if RecName == testspec ->
+		record_info(fields, testspec);
+	   true ->
+		undefined
+	end,
+    {RecName,combine_names_and_vals(FieldNames,RecList)}.
+
+combine_names_and_vals([FN|FNs], [V|Vs]) ->
+    [{FN,V} | combine_names_and_vals(FNs, Vs)];
+combine_names_and_vals([], []) ->
+    [];
+combine_names_and_vals(_, _) ->
+    [].
+
+get_absdir(Dir) ->
+    shorten_path(filename:absname(Dir),Dir).
+
+shorten_path(Path,SpecDir) ->
+    case shorten_split_path(filename:split(Path),[]) of
+	[] ->
+	    [Root|_] = filename:split(SpecDir),
+	    Root;
+	Short ->	    
+	    filename:join(Short)
+    end.
+
+shorten_split_path([".."|Path],SoFar) ->
+    shorten_split_path(Path,tl(SoFar));
+shorten_split_path(["."|Path],SoFar) ->
+    shorten_split_path(Path,SoFar);
+shorten_split_path([Dir|Path],SoFar) ->
+    shorten_split_path(Path,[Dir|SoFar]);
+shorten_split_path([],SoFar) ->
+    lists:reverse(SoFar).