Move 'node_start' and 'eval' terms into new 'init' term

node_start+eval -> init(node_start, eval)
Also include some documentation updates.

1 files changed, 57 insertions, 98 deletions

diff --git a/lib/common_test/src/ct_testspec.erl b/lib/common_test/src/ct_testspec.erl
index db3efb16e8..4e34c1513e 100644
--- a/lib/common_test/src/ct_testspec.erl
+++ b/lib/common_test/src/ct_testspec.erl
@@ -270,52 +270,8 @@ collect_tests(Terms,TestSpec,Relaxed) ->
     put(relaxed,Relaxed),
     TestSpec1 = get_global(Terms,TestSpec),
     TestSpec2 = get_all_nodes(Terms,TestSpec1),
-    % filter out node_start options and save them into the specification
-    {Terms2, TestSpec3} = filter_nodestart_specs(Terms, [], TestSpec2),
-    % only save the 'global' evals and evals for nodes which have no node_start
-    {Terms3, TestSpec4} = filter_evals(Terms2, [], TestSpec3),
-    % after evaluation, only valid terms exist in the specification list
-    Terms4 = case catch evaluate(Terms3, [], TestSpec4) of
-	{error,{Node,{M,F,A},Reason}} ->
-	    io:format("Error! Common Test failed to evaluate ~w:~w/~w on ~w. "
-		      "Reason: ~p~n~n", [M,F,A,Node,Reason]),
-	    Terms3;
-	NewTerms -> NewTerms
-    end,
-    add_tests(Terms4,TestSpec4).
-
-evaluate([{eval,Node,[{_,_,_}|_]=Mfas}|Ts],NewTerms,Spec)->
-    EvalTerms = lists:map(fun(Mfa)->
-	{eval, Node, Mfa}
-    end,
-    Mfas),
-    evaluate([EvalTerms|Ts], NewTerms, Spec);
-evaluate([{eval,[{_,_,_}|_]=Mfas}|Ts],NewTerms,Spec)->
-    EvalTerms = lists:map(fun(Mfa)->
-	{eval, Mfa}
-    end,
-    Mfas),
-    evaluate([EvalTerms|Ts], NewTerms, Spec);
-evaluate([{eval,Node,{M,F,Args}}|Ts],NewTerms,Spec) ->
-    case rpc:call(Node,M,F,Args) of
-	{badrpc,Reason} ->
-	    throw({error,{Node,{M,F,length(Args)},Reason}});
-	_ ->
-	    ok
-    end,
-    evaluate(Ts,NewTerms,Spec);
-evaluate([{eval,{M,F,Args}}|Ts],NewTerms,Spec) ->
-    case catch apply(M,F,Args) of
-	{'EXIT',Reason} ->
-	    throw({error,{node(),{M,F,length(Args)},Reason}});
-	_ ->
-	    ok
-    end,
-    evaluate(Ts,NewTerms,Spec);
-evaluate([Term|Ts], NewTerms, Spec)->
-    evaluate(Ts, [Term|NewTerms], Spec);
-evaluate([], NewTerms, _Spec) ->
-    NewTerms.
+    {Terms2, TestSpec3} = filter_init_terms(Terms, [], TestSpec2),
+    add_tests(Terms2,TestSpec3).
 
 get_global([{alias,Ref,Dir}|Ts],Spec=#testspec{alias=Refs}) ->
     get_global(Ts,Spec#testspec{alias=[{Ref,get_absdir(Dir,Spec)}|Refs]});
@@ -392,64 +348,67 @@ get_all_nodes([_|Ts],Spec) ->
 get_all_nodes([],Spec) ->
     Spec.
 
-filter_nodestart_specs([{node_start, Options}|Ts], NewTerms, Spec) ->
-    filter_nodestart_specs([{node_start, list_nodes(Spec), Options}|Ts], NewTerms, Spec);
-filter_nodestart_specs([{node_start, NodeRef, Options}|Ts], NewTerms, Spec) when is_atom(NodeRef) ->
-    filter_nodestart_specs([{node_start, [NodeRef], Options}|Ts], NewTerms, Spec);
-filter_nodestart_specs([{node_start, NodeRefs, Options}|Ts], NewTerms, Spec=#testspec{node_start=NodeStart})->
-    Options2 = case lists:keyfind(callback_module, 1, Options) of
+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->
-	    [{callback_module, ct_slave}|Options];
-	{callback_module, _Callback}->
-	    Options
+	    []
     end,
-    NSSAdder = fun(NodeRef, NodeStartAcc)->
-	Node=ref2node(NodeRef,Spec#testspec.nodes),
-        case lists:keyfind(Node, 1, NodeStartAcc) of
-	    false->
-		[{Node, Options2}|NodeStartAcc];
-	    {Node, OtherOptions}->
-		io:format("~nWarning: There are other options defined for node ~p:"
-			  "~n~w, skipping ~n~w...~n", [Node, OtherOptions, Options2]),
-		NodeStartAcc
-	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,
-    NodeStart2 = lists:foldl(NSSAdder, NodeStart, NodeRefs),
-    filter_nodestart_specs(Ts, NewTerms, Spec#testspec{node_start=NodeStart2});
-filter_nodestart_specs([Term|Ts], NewTerms, Spec)->
-    filter_nodestart_specs(Ts, [Term|NewTerms], Spec);
-filter_nodestart_specs([], NewTerms, Spec) ->
+    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)->
     {NewTerms, Spec}.
 
-filter_evals([{eval,NodeRefs,Mfa}|Ts], NewTerms, Spec) when is_list(NodeRefs)->
-    EvalTerms = lists:map(fun(NodeRef)->
-			      {eval, NodeRef, Mfa}
-			  end,
-			  NodeRefs),
-    filter_evals(EvalTerms++Ts, NewTerms, Spec);
-filter_evals([{eval,NodeRef,{_,_,_}=Mfa}|Ts],NewTerms,Spec)->
-    filter_evals([{eval,NodeRef,[Mfa]}|Ts],NewTerms,Spec);
-filter_evals([{eval,NodeRef,[{_,_,_}|_]=Mfas}=EvalTerm|Ts],
-	     NewTerms,Spec=#testspec{node_start=NodeStart})->
-    Node=ref2node(NodeRef,Spec#testspec.nodes),
-    case lists:keyfind(Node, 1, NodeStart) of
-	false->
-	    filter_evals(Ts, [EvalTerm|NewTerms], Spec);
+add_option([], _, List, _)->
+    List;
+add_option({Key, Value}, Node, List, WarnIfExists) when is_list(Value)->
+    OldOptions = case lists:keyfind(Node, 1, List) of
 	{Node, Options}->
-	    Options2 = case lists:keyfind(startup_functions, 1, Options) of
-		false->
-		     [{startup_functions, Mfas}|Options];
-		{startup_functions, StartupFunctions}->
-		     lists:keyreplace(startup_functions, 1, Options,
-			 {startup_functions, StartupFunctions ++ Mfas})
-	    end,
-	    NodeStart2 = lists:keyreplace(Node, 1, NodeStart, {Node, Options2}),
-	    filter_evals(Ts, NewTerms, Spec#testspec{node_start=NodeStart2})
-    end;
-filter_evals([Term|Ts], NewTerms, Spec)->
-    filter_evals(Ts, [Term|NewTerms], Spec);
-filter_evals([], NewTerms, Spec)->
-    {NewTerms, Spec}.
+	    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]),
+	    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).
 
 save_nodes(Nodes,Spec=#testspec{nodes=NodeRefs}) ->
     NodeRefs1 =