aboutsummaryrefslogtreecommitdiffstats
path: root/lib/test_server/src/ts_run.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/test_server/src/ts_run.erl')
-rw-r--r--lib/test_server/src/ts_run.erl746
1 files changed, 746 insertions, 0 deletions
diff --git a/lib/test_server/src/ts_run.erl b/lib/test_server/src/ts_run.erl
new file mode 100644
index 0000000000..3461e1383c
--- /dev/null
+++ b/lib/test_server/src/ts_run.erl
@@ -0,0 +1,746 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. 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%
+%%
+
+%%% Purpose : Supervises running of test cases.
+
+-module(ts_run).
+
+-export([run/4]).
+
+-define(DEFAULT_MAKE_TIMETRAP_MINUTES, 60).
+-define(DEFAULT_UNMAKE_TIMETRAP_MINUTES, 15).
+
+-include("ts.hrl").
+
+-import(lists, [map/2,member/2,filter/2,reverse/1]).
+
+-record(state,
+ {file, % File given.
+ mod, % Module to run.
+ test_server_args, % Arguments to test server.
+ command, % Command to run.
+ test_dir, % Directory for test suite.
+ makefiles, % List of all makefiles.
+ makefile, % Current makefile.
+ batch, % Are we running in batch mode?
+ data_wc, % Wildcard for data dirs.
+ topcase, % Top case specification.
+ all % Set if we have all_SUITE_data
+ }).
+
+-define(tracefile,"traceinfo").
+
+%% Options is a slightly modified version of the options given to
+%% ts:run. Vars0 are from the variables file.
+run(File, Args0, Options, Vars0) ->
+ Vars=
+ case lists:keysearch(vars, 1, Options) of
+ {value, {vars, Vars1}} ->
+ Vars1++Vars0;
+ _ ->
+ Vars0
+ end,
+ {Batch,Runner} =
+ case {member(interactive, Options), member(batch, Options)} of
+ {false, true} ->
+ {true, fun run_batch/3};
+ _ ->
+ {false, fun run_interactive/3}
+ end,
+ HandleTopcase = case member(keep_topcase, Options) of
+ true -> [fun copy_topcase/3];
+ false -> [fun remove_original_topcase/3,
+ fun init_topcase/3]
+ end,
+ MakefileHooks = [fun make_make/3,
+ fun add_make_testcase/3],
+ MakeLoop = fun(V, Sp, St) -> make_loop(MakefileHooks, V, Sp, St) end,
+ Hooks = [fun init_state/3,
+ fun read_spec_file/3] ++
+ HandleTopcase ++
+ [fun run_preinits/3,
+ fun find_makefiles/3,
+ MakeLoop,
+ fun make_test_suite/3,
+ fun add_topcase_to_spec/3,
+ fun write_spec_file/3,
+ fun make_command/3,
+ Runner],
+ Args = make_test_server_args(Args0,Options,Vars),
+ St = #state{file=File,test_server_args=Args,batch=Batch},
+ R = execute(Hooks, Vars, [], St),
+ case Batch of
+ true -> ts_reports:make_index();
+ false -> ok % ts_reports:make_index() is run on the test_server node
+ end,
+ case R of
+ {ok,_,_,_} -> ok;
+ Error -> Error
+ end.
+
+make_loop(Hooks, Vars0, Spec0, St0) ->
+ case St0#state.makefiles of
+ [Makefile|Rest] ->
+ case execute(Hooks, Vars0, Spec0, St0#state{makefile=Makefile}) of
+ {error, Reason} ->
+ {error, Reason};
+ {ok, Vars, Spec, St} ->
+ make_loop(Hooks, Vars, Spec, St#state{makefiles=Rest})
+ end;
+ [] ->
+ {ok, Vars0, Spec0, St0}
+ end.
+
+execute([Hook|Rest], Vars0, Spec0, St0) ->
+ case Hook(Vars0, Spec0, St0) of
+ ok ->
+ execute(Rest, Vars0, Spec0, St0);
+ {ok, Vars, Spec, St} ->
+ execute(Rest, Vars, Spec, St);
+ Error ->
+ Error
+ end;
+execute([], Vars, Spec, St) ->
+ {ok, Vars, Spec, St}.
+
+%%
+%% Deletes File from Files when File is on the form .../<SUITE>_data/<file>
+%% when all of <SUITE> has been skipped in Spec, i.e. there
+%% exists a {skip, {<SUITE>, _}} tuple in Spec.
+%%
+del_skipped_suite_data_dir(Files, Spec) ->
+ SkipDirNames = lists:foldl(fun ({skip, {SS, _C}}, SSs) ->
+ [atom_to_list(SS) ++ "_data" | SSs];
+ (_, SSs) ->
+ SSs
+ end,
+ [],
+ Spec),
+ filter(fun (File) ->
+ not member(filename:basename(filename:dirname(File)),
+ SkipDirNames)
+ end,
+ Files).
+
+%% Initialize our internal state.
+
+init_state(Vars, [], St0) ->
+ {FileBase,Wc0,Mod} =
+ case St0#state.file of
+ {Fil,Mod0} -> {Fil, atom_to_list(Mod0) ++ "*_data",Mod0};
+ Fil -> {Fil,"*_SUITE_data",[]}
+ end,
+ {ok,Cwd} = file:get_cwd(),
+ TestDir = filename:join(filename:dirname(Cwd), FileBase++"_test"),
+ case filelib:is_dir(TestDir) of
+ true ->
+ Wc = filename:join(TestDir, Wc0),
+ {ok,Vars,[],St0#state{file=FileBase,mod=Mod,
+ test_dir=TestDir,data_wc=Wc}};
+ false ->
+ {error,{no_test_directory,TestDir}}
+ end.
+
+%% Read the spec file for the test suite.
+
+read_spec_file(Vars, _, St) ->
+ TestDir = St#state.test_dir,
+ File = St#state.file,
+ {SpecFile,Res} = get_spec_filename(Vars, TestDir, File),
+ case Res of
+ {ok,Spec} ->
+ {ok,Vars,Spec,St};
+ {error,Atom} when is_atom(Atom) ->
+ {error,{no_spec,SpecFile}};
+ {error,Reason} ->
+ {error,{bad_spec,lists:flatten(file:format_error(Reason))}}
+ end.
+
+get_spec_filename(Vars, TestDir, File) ->
+ DynSpec = filename:join(TestDir, File ++ ".dynspec"),
+ case filelib:is_file(DynSpec) of
+ true ->
+ Bs0 = erl_eval:new_bindings(),
+ Bs1 = erl_eval:add_binding('Target', ts_lib:var(target, Vars), Bs0),
+ Bs2 = erl_eval:add_binding('Os', ts_lib:var(os, Vars), Bs1),
+ TCCStr = ts_lib:var(test_c_compiler, Vars),
+ TCC = try
+ {ok, Toks, _} = erl_scan:string(TCCStr ++ "."),
+ {ok, Tcc} = erl_parse:parse_term(Toks),
+ Tcc
+ catch
+ _:_ -> undefined
+ end,
+ Bs = erl_eval:add_binding('TestCCompiler', TCC, Bs2),
+ {DynSpec,file:script(DynSpec, Bs)};
+ false ->
+ SpecFile = get_spec_filename_1(Vars, TestDir, File),
+ {SpecFile,file:consult(SpecFile)}
+ end.
+
+get_spec_filename_1(Vars, TestDir, File) ->
+ case ts_lib:var(os, Vars) of
+ "VxWorks" ->
+ check_spec_filename(TestDir, File, ".spec.vxworks");
+ "OSE" ->
+ check_spec_filename(TestDir, File, ".spec.ose");
+ "Windows"++_ ->
+ check_spec_filename(TestDir, File, ".spec.win");
+ _Other ->
+ filename:join(TestDir, File ++ ".spec")
+ end.
+
+check_spec_filename(TestDir, File, Ext) ->
+ Spec = filename:join(TestDir, File ++ Ext),
+ case filelib:is_file(Spec) of
+ true -> Spec;
+ false -> filename:join(TestDir, File ++ ".spec")
+ end.
+
+%% Remove the top case from the spec file. We will add our own
+%% top case later.
+
+remove_original_topcase(Vars, Spec, St) ->
+ {ok,Vars,filter(fun ({topcase,_}) -> false;
+ (_Other) -> true end, Spec),St}.
+
+%% Initialize our new top case. We'll keep in it the state to be
+%% able to add more to it.
+
+init_topcase(Vars, Spec, St) ->
+ TestDir = St#state.test_dir,
+ TopCase =
+ case St#state.mod of
+ Mod when is_atom(Mod) ->
+ ModStr = atom_to_list(Mod),
+ case filelib:is_file(filename:join(TestDir,ModStr++".erl")) of
+ true -> [{Mod,all}];
+ false ->
+ Wc = filename:join(TestDir, ModStr ++ "*_SUITE.erl"),
+ [{list_to_atom(filename:basename(M, ".erl")),all} ||
+ M <- filelib:wildcard(Wc)]
+ end;
+ _Other ->
+ %% Here we used to return {dir,TestDir}. Now we instead
+ %% list all suites in TestDir, so we can add make testcases
+ %% around it later (see add_make_testcase) without getting
+ %% duplicates of the suite. (test_server_ctrl does no longer
+ %% check for duplicates of testcases)
+ Wc = filename:join(TestDir, "*_SUITE.erl"),
+ [{list_to_atom(filename:basename(M, ".erl")),all} ||
+ M <- filelib:wildcard(Wc)]
+ end,
+ {ok,Vars,Spec,St#state{topcase=TopCase}}.
+
+%% Or if option keep_topcase was given, eh... keep the topcase
+copy_topcase(Vars, Spec, St) ->
+ {value,{topcase,Tc}} = lists:keysearch(topcase,1,Spec),
+ {ok, Vars, lists:keydelete(topcase,1,Spec),St#state{topcase=Tc}}.
+
+
+%% Run any "Makefile.first" files first.
+%% XXX We should fake a failing test case if the make fails.
+
+run_preinits(Vars, Spec, St) ->
+ Wc = filename:join(St#state.data_wc, "Makefile.first"),
+ run_pre_makefiles(del_skipped_suite_data_dir(filelib:wildcard(Wc), Spec),
+ Vars, Spec, St),
+ {ok,Vars,Spec,St}.
+
+run_pre_makefiles([Makefile|Ms], Vars0, Spec0, St0) ->
+ Hooks = [fun run_pre_makefile/3],
+ case execute(Hooks, Vars0, Spec0, St0#state{makefile=Makefile}) of
+ {error,_Reason}=Error -> Error;
+ {ok,Vars,Spec,St} -> run_pre_makefiles(Ms, Vars, Spec, St)
+ end;
+run_pre_makefiles([], Vars, Spec, St) -> {ok,Vars,Spec,St}.
+
+run_pre_makefile(Vars, Spec, St) ->
+ Makefile = St#state.makefile,
+ Shortname = filename:basename(Makefile),
+ DataDir = filename:dirname(Makefile),
+ Make = ts_lib:var(make_command, Vars),
+ case ts_make:make(Make,DataDir, Shortname) of
+ ok -> {ok,Vars,Spec,St};
+ {error,_Reason}=Error -> Error
+ end.
+
+%% Search for `Makefile.src' in each *_SUITE_data directory.
+
+find_makefiles(Vars, Spec, St) ->
+ Wc = filename:join(St#state.data_wc, "Makefile.src"),
+ Makefiles = reverse(del_skipped_suite_data_dir(filelib:wildcard(Wc), Spec)),
+ {ok,Vars,Spec,St#state{makefiles=Makefiles}}.
+
+%% Create "Makefile" from "Makefile.src".
+
+make_make(Vars, Spec, State) ->
+ Src = State#state.makefile,
+ Dest = filename:rootname(Src),
+ ts_lib:progress(Vars, 1, "Making ~s...\n", [Dest]),
+ case ts_lib:subst_file(Src, Dest, Vars) of
+ ok ->
+ {ok, Vars, Spec, State#state{makefile=Dest}};
+ {error, Reason} ->
+ {error, {Src, Reason}}
+ end.
+
+%% Add a testcase which will do the making of the stuff in the data directory.
+
+add_make_testcase(Vars, Spec, St) ->
+ Makefile = St#state.makefile,
+ Dir = filename:dirname(Makefile),
+ case ts_lib:var(os, Vars) of
+ "OSE" ->
+ %% For OSE, C code in datadir must be linked in the image file,
+ %% and erlang code is sent as binaries from test_server_ctrl
+ %% Making erlang code here because the Makefile.src probably won't
+ %% work.
+ Erl_flags=[{i, "../../test_server"}|ts_lib:var(erl_flags,Vars)],
+ {ok, Cwd} = file:get_cwd(),
+ ok = file:set_cwd(Dir),
+ Result = (catch make:all(Erl_flags)),
+ ok = file:set_cwd(Cwd),
+ case Result of
+ up_to_date -> {ok, Vars, Spec, St};
+ _error -> {error, {erlang_make_failed,Dir}}
+ end;
+ _ ->
+ Shortname = filename:basename(Makefile),
+ Suite = filename:basename(Dir, "_data"),
+ Config = [{data_dir,Dir},{makefile,Shortname}],
+ MakeModule = Suite ++ "_make",
+ MakeModuleSrc = filename:join(filename:dirname(Dir),
+ MakeModule ++ ".erl"),
+ MakeMod = list_to_atom(MakeModule),
+ case filelib:is_file(MakeModuleSrc) of
+ true -> ok;
+ false -> generate_make_module(ts_lib:var(make_command, Vars),
+ MakeModuleSrc,
+ MakeModule)
+ end,
+ case Suite of
+ "all_SUITE" ->
+ {ok,Vars,Spec,St#state{all={MakeMod,Config}}};
+ _ ->
+ %% Avoid duplicates of testcases. There is no longer
+ %% a check for this in test_server_ctrl.
+ TestCase = {list_to_atom(Suite),all},
+ TopCase0 = case St#state.topcase of
+ List when is_list(List) ->
+ List -- [TestCase];
+ Top ->
+ [Top] -- [TestCase]
+ end,
+ TopCase = [{make,{MakeMod,make,[Config]},
+ TestCase,
+ {MakeMod,unmake,[Config]}}|TopCase0],
+ {ok,Vars,Spec,St#state{topcase=TopCase}}
+ end
+ end.
+
+generate_make_module(MakeCmd, Name, ModuleString) ->
+ {ok,Host} = inet:gethostname(),
+ file:write_file(Name,
+ ["-module(",ModuleString,").\n",
+ "\n",
+ "-export([make/1,unmake/1]).\n",
+ "\n",
+ "make(Config) when is_list(Config) ->\n",
+ " Mins = " ++ integer_to_list(?DEFAULT_MAKE_TIMETRAP_MINUTES) ++ ",\n"
+ " test_server:format(\"=== Setting timetrap to ~p minutes ===~n\", [Mins]),\n"
+ " TimeTrap = test_server:timetrap(test_server:minutes(Mins)),\n"
+ " Res = ts_make:make([{make_command, \""++MakeCmd++"\"},{cross_node,\'ts@" ++ Host ++ "\'}|Config]),\n",
+ " test_server:timetrap_cancel(TimeTrap),\n"
+ " Res.\n"
+ "\n",
+ "unmake(Config) when is_list(Config) ->\n",
+ " Mins = " ++ integer_to_list(?DEFAULT_UNMAKE_TIMETRAP_MINUTES) ++ ",\n"
+ " test_server:format(\"=== Setting timetrap to ~p minutes ===~n\", [Mins]),\n"
+ " TimeTrap = test_server:timetrap(test_server:minutes(Mins)),\n"
+ " Res = ts_make:unmake([{make_command, \""++MakeCmd++"\"}|Config]),\n"
+ " test_server:timetrap_cancel(TimeTrap),\n"
+ " Res.\n"
+ "\n"]).
+
+
+make_test_suite(Vars, _Spec, State) ->
+ TestDir = State#state.test_dir,
+
+ Erl_flags=[{i, "../test_server"}|ts_lib:var(erl_flags,Vars)],
+
+ case code:is_loaded(test_server_line) of
+ false -> code:load_file(test_server_line);
+ _ -> ok
+ end,
+
+ {ok, Cwd} = file:get_cwd(),
+ ok = file:set_cwd(TestDir),
+ Result = (catch make:all(Erl_flags)),
+ ok = file:set_cwd(Cwd),
+ case Result of
+ up_to_date ->
+ ok;
+ {'EXIT', Reason} ->
+ %% If I return an error here, the test will be stopped
+ %% and it will not show up in the top index page. Instead
+ %% I return ok - the test will run for all existing suites.
+ %% It might be that there are old suites that are run, but
+ %% at least one suite is missing, and that is reported on the
+ %% top index page.
+ io:format("~s: {error,{make_crashed,~p}\n",
+ [State#state.file,Reason]),
+ ok;
+ error ->
+ %% See comment above
+ io:format("~s: {error,make_of_test_suite_failed}\n",
+ [State#state.file]),
+ ok
+ end.
+
+%% Add topcase to spec.
+
+add_topcase_to_spec(Vars, Spec, St) ->
+ Tc = case St#state.all of
+ {MakeMod,Config} ->
+ [{make,{MakeMod,make,[Config]},
+ St#state.topcase,
+ {MakeMod,unmake,[Config]}}];
+ undefined -> St#state.topcase
+ end,
+ {ok,Vars,Spec++[{topcase,Tc}],St}.
+
+%% Writes the (possibly transformed) spec file.
+
+write_spec_file(Vars, Spec, _State) ->
+ F = fun(Term) -> io_lib:format("~p.~n", [Term]) end,
+ SpecFile = map(F, Spec),
+ Hosts =
+ case lists:keysearch(hosts, 1, Vars) of
+ false ->
+ [];
+ {value, {hosts, HostList}} ->
+ io_lib:format("{hosts,~p}.~n",[HostList])
+ end,
+ DiskLess =
+ case lists:keysearch(diskless, 1, Vars) of
+ false ->
+ [];
+ {value, {diskless, How}} ->
+ io_lib:format("{diskless, ~p}.~n",[How])
+ end,
+ Conf = consult_config(),
+ MoreConfig = io_lib:format("~p.\n", [{config,Conf}]),
+ file:write_file("current.spec", [DiskLess,Hosts,MoreConfig,SpecFile]).
+
+consult_config() ->
+ {ok,Conf} = file:consult("ts.config"),
+ case os:type() of
+ {unix,_} -> consult_config("ts.unix.config", Conf);
+ {win32,_} -> consult_config("ts.win32.config", Conf);
+ vxworks -> consult_config("ts.vxworks.config", Conf);
+ _ -> Conf
+ end.
+
+consult_config(File, Conf0) ->
+ case file:consult(File) of
+ {ok,Conf} -> Conf++Conf0;
+ {error,enoent} -> Conf0
+ end.
+
+%% Makes the command to start up the Erlang node to run the tests.
+
+backslashify([$\\, $" | T]) ->
+ [$\\, $" | backslashify(T)];
+backslashify([$" | T]) ->
+ [$\\, $" | backslashify(T)];
+backslashify([H | T]) ->
+ [H | backslashify(T)];
+backslashify([]) ->
+ [].
+
+make_command(Vars, Spec, State) ->
+ TestDir = State#state.test_dir,
+ TestPath = filename:nativename(TestDir),
+ Erl = case os:getenv("TS_RUN_VALGRIND") of
+ false ->
+ atom_to_list(lib:progname());
+ _ ->
+ case State#state.file of
+ Dir when is_list(Dir) ->
+ os:putenv("VALGRIND_LOGFILE_PREFIX", Dir++"-");
+ _ ->
+ ok
+ end,
+ "cerl -valgrind" ++
+ case erlang:system_info(smp_support) of
+ true -> " -smp";
+ false -> ""
+ end
+ end,
+ Naming =
+ case ts_lib:var(longnames, Vars) of
+ true ->
+ " -name ";
+ false ->
+ " -sname "
+ end,
+ ExtraArgs =
+ case lists:keysearch(erl_start_args,1,Vars) of
+ {value,{erl_start_args,Args}} -> Args;
+ false -> ""
+ end,
+ CrashFile = State#state.file ++ "_erl_crash.dump",
+ case filelib:is_file(CrashFile) of
+ true ->
+ io:format("ts_run: Deleting dump: ~s\n",[CrashFile]),
+ file:delete(CrashFile);
+ false ->
+ ok
+ end,
+ Cmd = [Erl, Naming, "test_server -pa ", $", TestPath, $",
+ " -rsh ", ts_lib:var(rsh_name, Vars),
+ " -env PATH \"",
+ backslashify(lists:flatten([TestPath, path_separator(),
+ remove_path_spaces()])),
+ "\"",
+ " -env ERL_CRASH_DUMP ", CrashFile,
+ %% uncomment the line below to disable exception formatting
+ %% " -test_server_format_exception false",
+ " -boot start_sasl -sasl errlog_type error",
+ " -s test_server_ctrl run_test ", State#state.test_server_args,
+ " ",
+ ExtraArgs],
+ {ok, Vars, Spec, State#state{command=lists:flatten(Cmd)}}.
+
+run_batch(Vars, _Spec, State) ->
+ process_flag(trap_exit, true),
+ Command = State#state.command ++ " -noinput -s erlang halt",
+ ts_lib:progress(Vars, 1, "Command: ~s~n", [Command]),
+ Port = open_port({spawn, Command}, [stream, in, eof]),
+ tricky_print_data(Port).
+
+tricky_print_data(Port) ->
+ receive
+ {Port, {data, Bytes}} ->
+ io:put_chars(Bytes),
+ tricky_print_data(Port);
+ {Port, eof} ->
+ Port ! {self(), close},
+ receive
+ {Port, closed} ->
+ true
+ end,
+ receive
+ {'EXIT', Port, _} ->
+ ok
+ after 1 -> % force context switch
+ ok
+ end
+ after 30000 ->
+ case erl_epmd:names() of
+ {ok,Names} ->
+ case is_testnode_dead(Names) of
+ true ->
+ io:put_chars("WARNING: No EOF, but "
+ "test_server node is down!\n");
+ false ->
+ tricky_print_data(Port)
+ end;
+ _ ->
+ tricky_print_data(Port)
+ end
+ end.
+
+is_testnode_dead([]) -> true;
+is_testnode_dead([{"test_server",_}|_]) -> false;
+is_testnode_dead([_|T]) -> is_testnode_dead(T).
+
+run_interactive(Vars, _Spec, State) ->
+ Command = State#state.command ++ " -s ts_reports make_index",
+ ts_lib:progress(Vars, 1, "Command: ~s~n", [Command]),
+ case ts_lib:var(os, Vars) of
+ "Windows 95" ->
+ %% Windows 95 strikes again! We must redirect standard
+ %% input and output for the `start' command, to force
+ %% standard input and output to the Erlang shell to be
+ %% connected to the newly started console.
+ %% Without these redirections, the Erlang shell would be
+ %% connected to the pipes provided by the port program
+ %% and there would be an inactive console window.
+ os:cmd("start < nul > nul w" ++ Command),
+ ok;
+ "Windows 98" ->
+ os:cmd("start < nul > nul w" ++ Command),
+ ok;
+ "Windows"++_ ->
+ os:cmd("start w" ++ Command),
+ ok;
+ _Other ->
+ %% Assuming ts and controller always run on solaris
+ start_xterm(Command)
+ end.
+
+start_xterm(Command) ->
+ case os:find_executable("xterm") of
+ false ->
+ io:format("The `xterm' program was not found.\n"),
+ {error, no_xterm};
+ _Xterm ->
+ case os:getenv("DISPLAY") of
+ false ->
+ io:format("DISPLAY is not set.\n"),
+ {error, display_not_set};
+ Display ->
+ io:format("Starting xterm (DISPLAY=~s)...\n",
+ [Display]),
+ os:cmd("xterm -sl 10000 -e " ++ Command ++ "&"),
+ ok
+ end
+ end.
+
+path_separator() ->
+ case os:type() of
+ {win32, _} -> ";";
+ {unix, _} -> ":";
+ vxworks -> ":"
+ end.
+
+
+make_test_server_args(Args0,Options,Vars) ->
+ Parameters =
+ case ts_lib:var(os, Vars) of
+ "VxWorks" ->
+ F = write_parameterfile(vxworks,Vars),
+ " PARAMETERS " ++ F;
+ "OSE" ->
+ F = write_parameterfile(ose,Vars),
+ " PARAMETERS " ++ F;
+ _ ->
+ ""
+ end,
+ Trace =
+ case lists:keysearch(trace,1,Options) of
+ {value,{trace,TI}} when is_tuple(TI); is_tuple(hd(TI)) ->
+ ok = file:write_file(?tracefile,io_lib:format("~p.~n",[TI])),
+ " TRACE " ++ ?tracefile;
+ {value,{trace,TIFile}} when is_atom(TIFile) ->
+ " TRACE " ++ atom_to_list(TIFile);
+ {value,{trace,TIFile}} ->
+ " TRACE " ++ TIFile;
+ false ->
+ ""
+ end,
+ Cover =
+ case lists:keysearch(cover,1,Options) of
+ {value,{cover,App,File,Analyse}} ->
+ " COVER " ++ to_list(App) ++ " " ++ to_list(File) ++ " " ++
+ to_list(Analyse);
+ false ->
+ ""
+ end,
+ TCCallback =
+ case ts_lib:var(ts_testcase_callback, Vars) of
+ "" ->
+ "";
+ {Mod,Func} ->
+ io:format("Function ~w:~w/4 will be called before and "
+ "after each test case.\n", [Mod,Func]),
+ " TESTCASE_CALLBACK " ++ to_list(Mod) ++ " " ++ to_list(Func);
+ ModFunc when is_list(ModFunc) ->
+ [Mod,Func]=string:tokens(ModFunc," "),
+ io:format("Function ~s:~s/4 will be called before and "
+ "after each test case.\n", [Mod,Func]),
+ " TESTCASE_CALLBACK " ++ ModFunc;
+ _ ->
+ ""
+ end,
+ Args0 ++ Parameters ++ Trace ++ Cover ++ TCCallback.
+
+to_list(X) when is_atom(X) ->
+ atom_to_list(X);
+to_list(X) when is_list(X) ->
+ X.
+
+write_parameterfile(Type,Vars) ->
+ Cross_host = ts_lib:var(target_host, Vars),
+ SlaveTargets = case lists:keysearch(slavetargets,1,Vars) of
+ {value, ST} ->
+ [ST];
+ _ ->
+ []
+ end,
+ Master = case lists:keysearch(master,1,Vars) of
+ {value,M} -> [M];
+ false -> []
+ end,
+ ToWrite = [{type,Type},
+ {target, list_to_atom(Cross_host)}] ++ SlaveTargets ++ Master,
+
+ Crossfile = atom_to_list(Type) ++ "parameters" ++ os:getpid(),
+ ok = file:write_file(Crossfile,io_lib:format("~p.~n", [ToWrite])),
+ Crossfile.
+
+%%
+%% Paths and spaces handling for w2k and XP
+%%
+remove_path_spaces() ->
+ Path = os:getenv("PATH"),
+ case os:type() of
+ {win32,nt} ->
+ remove_path_spaces(Path);
+ _ ->
+ Path
+ end.
+
+remove_path_spaces(Path) ->
+ SPath = split_path(Path),
+ [NSHead|NSTail] = lists:map(fun(X) -> filename:nativename(
+ filename:join(
+ translate_path(split_one(X))))
+ end,
+ SPath),
+ NSHead ++ lists:flatten([[$;|X] || X <- NSTail]).
+
+translate_path(PList) ->
+ %io:format("translate_path([~p|~p]~n",[Base,PList]),
+ translate_path(PList,[]).
+
+
+translate_path([],_) ->
+ [];
+translate_path([PC | T],BaseList) ->
+ FullPath = filename:nativename(filename:join(BaseList ++ [PC])),
+ NewPC = case catch file:altname(FullPath) of
+ {ok,X} ->
+ X;
+ _ ->
+ PC
+ end,
+ %io:format("NewPC:~s, DirList:~p~n",[NewPC,DirList]),
+ NewBase = BaseList ++ [NewPC],
+ [NewPC | translate_path(T,NewBase)].
+
+split_one(Path) ->
+ filename:split(Path).
+
+split_path(Path) ->
+ string:tokens(Path,";").
+
+