Merge branch 'egil/runtime_tools/modernize-tests'

* egil/runtime_tools/modernize-tests:
  Eliminate use of doc and suite clauses
  Replace ?t with test_server
  Replace use of test_server:format/2 with io:format/2
  Eliminate use of test_server:fail/0,1
  Eliminate use of ?config() macro
  Modernize use of timetraps
  Remove ?line macros

5 files changed, 628 insertions, 769 deletions

diff --git a/lib/runtime_tools/test/dbg_SUITE.erl b/lib/runtime_tools/test/dbg_SUITE.erl
index 17c04c0ed4..9c9d6ca352 100644
--- a/lib/runtime_tools/test/dbg_SUITE.erl
+++ b/lib/runtime_tools/test/dbg_SUITE.erl
@@ -20,31 +20,22 @@
 -module(dbg_SUITE).
 
 %% Test functions
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2, 
-	 big/1, tiny/1, simple/1, message/1, distributed/1, port/1,
-	 ip_port/1, file_port/1, file_port2/1, file_port_schedfix/1,
-	 ip_port_busy/1, wrap_port/1, wrap_port_time/1,
-	 with_seq_trace/1, dead_suspend/1, local_trace/1,
-	 saved_patterns/1, tracer_exit_on_stop/1,
+-export([all/0, suite/0,
+         big/1, tiny/1, simple/1, message/1, distributed/1, port/1,
+         ip_port/1, file_port/1, file_port2/1, file_port_schedfix/1,
+         ip_port_busy/1, wrap_port/1, wrap_port_time/1,
+         with_seq_trace/1, dead_suspend/1, local_trace/1,
+         saved_patterns/1, tracer_exit_on_stop/1,
          erl_tracer/1, distributed_erl_tracer/1]).
--export([init_per_testcase/2, end_per_testcase/2]).
 -export([tracee1/1, tracee2/1]).
 -export([dummy/0, exported/1]).
 -export([enabled/3, trace/6, load_nif/1]).
 
 -include_lib("common_test/include/ct.hrl").
--define(default_timeout, ?t:minutes(1)).
-
-init_per_testcase(_Case, Config) ->
-    ?line Dog=test_server:timetrap(?default_timeout),
-    [{watchdog, Dog}|Config].
-end_per_testcase(_Case, Config) ->
-    Dog=?config(watchdog, Config),
-    test_server:timetrap_cancel(Dog),
-    ok.
 
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap, {minutes, 1}}].
 
 all() -> 
     [big, tiny, simple, message, distributed, port, ip_port,
@@ -53,283 +44,248 @@ all() ->
      local_trace, saved_patterns, tracer_exit_on_stop,
      erl_tracer, distributed_erl_tracer].
 
-groups() -> 
-    [].
-
-init_per_suite(Config) ->
-    Config.
-
-end_per_suite(_Config) ->
-    ok.
-
-init_per_group(_GroupName, Config) ->
-    Config.
 
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-big(suite) -> [];
-big(doc) -> ["Rudimentary interface test"];
+%% Rudimentary interface test
 big(Config) when is_list(Config) ->
-	?line {ok,OldCurDir} = file:get_cwd(),
-	Datadir=?config(data_dir, Config),
-	Privdir=?config(priv_dir, Config),
-	?line ok=file:set_cwd(Privdir),
+    {ok,OldCurDir} = file:get_cwd(),
+    Datadir=proplists:get_value(data_dir, Config),
+    Privdir=proplists:get_value(priv_dir, Config),
+    ok=file:set_cwd(Privdir),
     try
-	%% make sure dbg is stopped (and returns correctly)
-	?line ok = dbg:stop(),
-
-	%% compile test module and make sure it is loaded.
-	?line {ok,Mod} = compile:file(Datadir++"/dbg_test",[trace]),
-	?line code:purge(dbg_test),
-	?line {module, Mod}=code:load_file(dbg_test),
-
-	%% run/debug a named test function.
-	?line Pid = spawn_link(dbg_test, loop, [Config]),
-	?line true = register(dbg_test_loop, Pid),
-	?line {ok,_} = dbg:tracer(),
-	?line {ok,[{matched, _node, 1}]} = dbg:p(dbg_test_loop, [m,p,c]),
-	?line ok = dbg:c(dbg_test, test, [Config]),
-	?line ok = dbg:i(),
-	?line dbg_test_loop ! {dbg_test, stop},
-	unregister(dbg_test_loop),
-	?line ok = dbg:stop(),
-
-	%% run/debug a Pid.
-	?line Pid2=spawn_link(dbg_test,loop,[Config]),
-	?line {ok,_} = dbg:tracer(),
-	?line {ok,[{matched, _node, 1}]} = dbg:p(Pid2,[s,r,p]),
-	?line ok = dbg:c(dbg_test, test, [Config]),
-	?line ok = dbg:i(),
-	?line Pid2 ! {dbg_test, stop},
-
-	?line ok=file:set_cwd(OldCurDir)
+        %% make sure dbg is stopped (and returns correctly)
+        ok = dbg:stop(),
+
+        %% compile test module and make sure it is loaded.
+        {ok,Mod} = compile:file(Datadir++"/dbg_test",[trace]),
+        code:purge(dbg_test),
+        {module, Mod}=code:load_file(dbg_test),
+
+        %% run/debug a named test function.
+        Pid = spawn_link(dbg_test, loop, [Config]),
+        true = register(dbg_test_loop, Pid),
+        {ok,_} = dbg:tracer(),
+        {ok,[{matched, _node, 1}]} = dbg:p(dbg_test_loop, [m,p,c]),
+        ok = dbg:c(dbg_test, test, [Config]),
+        ok = dbg:i(),
+        dbg_test_loop ! {dbg_test, stop},
+        unregister(dbg_test_loop),
+        ok = dbg:stop(),
+
+        %% run/debug a Pid.
+        Pid2=spawn_link(dbg_test,loop,[Config]),
+        {ok,_} = dbg:tracer(),
+        {ok,[{matched, _node, 1}]} = dbg:p(Pid2,[s,r,p]),
+        ok = dbg:c(dbg_test, test, [Config]),
+        ok = dbg:i(),
+        Pid2 ! {dbg_test, stop},
+
+        ok=file:set_cwd(OldCurDir)
     after
-	?line dbg:stop()
+        dbg:stop()
     end,
     ok.
 
 
-tiny(suite) -> [];
-tiny(doc) -> ["Rudimentary interface test"];
+%% Rudimentary interface test
 tiny(Config) when is_list(Config) ->
-    ?line {ok,OldCurDir} = file:get_cwd(),
-    Datadir=?config(data_dir, Config),
-    Privdir=?config(priv_dir, Config),
-    ?line ok=file:set_cwd(Privdir),
+    {ok,OldCurDir} = file:get_cwd(),
+    Datadir=proplists:get_value(data_dir, Config),
+    Privdir=proplists:get_value(priv_dir, Config),
+    ok=file:set_cwd(Privdir),
     try
-	%% compile test module and make sure it is loaded.
-	?line {ok, Mod} = compile:file(Datadir++"/dbg_test",[trace]),
-	?line code:purge(dbg_test),
-	?line {module, Mod}=code:load_file(dbg_test),
-
-	?line Pid=spawn_link(dbg_test,loop,[Config]),
-	if
-	    is_pid(Pid) ->
-		?line dbg:tracer(),
-		?line {ok,[{matched, _node, 1}]} = dbg:p(Pid,[s,r,m,p,c]),
-		?line ok = dbg:c(dbg_test,test,[Config]),
-		?line ok = dbg:i(),
-		?line Pid ! {dbg_test, stop};
-	    true ->
-		?line ok=file:set_cwd(OldCurDir),
-		?t:fail("Could not spawn external test process.~n"),
-		failure
-	end
+        %% compile test module and make sure it is loaded.
+        {ok, Mod} = compile:file(Datadir++"/dbg_test",[trace]),
+        code:purge(dbg_test),
+        {module, Mod}=code:load_file(dbg_test),
+
+        Pid=spawn_link(dbg_test,loop,[Config]),
+        if
+            is_pid(Pid) ->
+                dbg:tracer(),
+                {ok,[{matched, _node, 1}]} = dbg:p(Pid,[s,r,m,p,c]),
+                ok = dbg:c(dbg_test,test,[Config]),
+                ok = dbg:i(),
+                Pid ! {dbg_test, stop};
+            true ->
+                ok=file:set_cwd(OldCurDir),
+                ct:fail("Could not spawn external test process.~n"),
+                failure
+        end
     after
-	?line ok = dbg:stop(),
-        ?line ok = file:set_cwd(OldCurDir)
+        ok = dbg:stop(),
+        ok = file:set_cwd(OldCurDir)
     end,
     ok.
 
-simple(suite) ->
-    [];
-simple(doc) ->
-    ["Simple interface test with own handler"];
+%% Simple interface test with own handler
 simple(Config) when is_list(Config) ->
     try
-	?line start(),
-	?line dbg:p(self(),call),
-	?line dbg:tp(dbg,ltp,[]),
-	?line dbg:ltp(),
-	?line stop(),
-	?line S = self(),
-	?line [{trace,S,call,{dbg,ltp,[]}}] = flush()
+        start(),
+        dbg:p(self(),call),
+        dbg:tp(dbg,ltp,[]),
+        dbg:ltp(),
+        stop(),
+        S = self(),
+        [{trace,S,call,{dbg,ltp,[]}}] = flush()
     after
-	?line dbg:stop()
+        dbg:stop()
     end,
     ok.
 
-message(suite) ->
-    [];
-message(doc) ->
-    ["Simple interface test with pam code that appends a message"];
+%% Simple interface test with pam code that appends a message
 message(Config) when is_list(Config) ->
-    ?line {ok, _} = start(),
+    {ok, _} = start(),
     try
-	?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	?line {ok, X} = dbg:tp(dbg,ltp,[{'_',[],[{message, {self}}]}]),
-	?line {value, {saved, Saved}} = lists:keysearch(saved, 1, X),
-	?line {ok, Y} = dbg:tp(dbg,ln,Saved),
-	?line {value, {saved, Saved}} = lists:keysearch(saved, 1, Y),
-	?line ok = dbg:ltp(),
-	?line ok = dbg:ln()
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        {ok, X} = dbg:tp(dbg,ltp,[{'_',[],[{message, {self}}]}]),
+        {value, {saved, Saved}} = lists:keysearch(saved, 1, X),
+        {ok, Y} = dbg:tp(dbg,ln,Saved),
+        {value, {saved, Saved}} = lists:keysearch(saved, 1, Y),
+        ok = dbg:ltp(),
+        ok = dbg:ln()
     after
-	?line stop()
+        stop()
     end,
-    ?line S = self(),
-    ?line [{trace,S,call,{dbg,ltp,[]},S},
-	   {trace,S,call,{dbg,ln,[]},S}] = flush(),
+    S = self(),
+    [{trace,S,call,{dbg,ltp,[]},S},
+     {trace,S,call,{dbg,ln,[]},S}] = flush(),
     ok.
 
-distributed(suite) ->
-    [];
-distributed(doc) ->
-    ["Simple test of distributed tracing"];
+%% Simple test of distributed tracing
 distributed(Config) when is_list(Config) ->
-    ?line {ok, _} = start(),
-    ?line Node = start_slave(),
+    {ok, _} = start(),
+    Node = start_slave(),
     try
-	?line RexPid = rpc:call(Node, erlang, whereis, [rex]),
-	?line RexPidList = pid_to_list(RexPid),
-	?line {ok, Node} = dbg:n(Node),
-	?line {ok, X} = dbg:p(all,call),
-	?line {value, {matched, Node, _}} = lists:keysearch(Node, 2, X),
-	?line {ok, Y} = dbg:p(RexPidList, s),
-	?line {value, {matched, Node, 1}} = lists:keysearch(Node, 2, Y),
-	?line {ok, Z} = dbg:tp(dbg,ltp,[]),
-	?line {value, {matched, Node, 1}} = lists:keysearch(Node, 2, Z),
-	?line dbg:cn(Node),
-	?line dbg:tp(dbg,ln,[]),
-	?line ok = rpc:call(Node, dbg, ltp, []),
-	?line ok = rpc:call(Node, dbg, ln, []),
-	?line ok = dbg:ln(),
-	?line S = self(),
-	?line {TraceSend, TraceCall} =
-	lists:partition(fun ({trace,RP,send,_,_}) when RP =:= RexPid -> true;
-			    (_) -> false end,
-			flush()),
-	?line [_|_] = TraceSend,
-	?line [{trace,Pid,call,{dbg,ltp,[]}},
-	       {trace,S,call,{dbg,ln,[]}}] = TraceCall,
-	?line Node = node(Pid),
-	%%
-	?line stop()
+        RexPid = rpc:call(Node, erlang, whereis, [rex]),
+        RexPidList = pid_to_list(RexPid),
+        {ok, Node} = dbg:n(Node),
+        {ok, X} = dbg:p(all,call),
+        {value, {matched, Node, _}} = lists:keysearch(Node, 2, X),
+        {ok, Y} = dbg:p(RexPidList, s),
+        {value, {matched, Node, 1}} = lists:keysearch(Node, 2, Y),
+        {ok, Z} = dbg:tp(dbg,ltp,[]),
+        {value, {matched, Node, 1}} = lists:keysearch(Node, 2, Z),
+        dbg:cn(Node),
+        dbg:tp(dbg,ln,[]),
+        ok = rpc:call(Node, dbg, ltp, []),
+        ok = rpc:call(Node, dbg, ln, []),
+        ok = dbg:ln(),
+        S = self(),
+        {TraceSend, TraceCall} =
+        lists:partition(fun ({trace,RP,send,_,_}) when RP =:= RexPid -> true;
+                            (_) -> false end,
+                        flush()),
+        [_|_] = TraceSend,
+        [{trace,Pid,call,{dbg,ltp,[]}},
+         {trace,S,call,{dbg,ln,[]}}] = TraceCall,
+        Node = node(Pid),
+        %%
+        stop()
     after
-	?line stop_slave(Node),
-        ?line stop()
+        stop_slave(Node),
+        stop()
     end,
     ok.
 
 
-local_trace(suite) ->
-    [];
-local_trace(doc) ->
-    ["Tests tracing of local function calls."];
+%% Tests tracing of local function calls.
 local_trace(Config) when is_list(Config) ->
-    ?line {ok, _} = start(),
+    {ok, _} = start(),
     try
-	?line S = self(),
-	?line %% Split "<X.Y.Z>" into {X, Y, Z}
-	?line "<"++L1 = L = pid_to_list(S),
-	?line NoDot = fun ($.) -> false; (_) -> true end,
-	?line {LX,"."++L2} = lists:splitwith(NoDot, L1),
-	?line {LY,"."++L3} = lists:splitwith(NoDot, L2),
-	?line ">"++L4 = lists:reverse(L3),
-	?line LZ = lists:reverse(L4),
-	?line X = 0 = list_to_integer(LX),
-	?line Y = list_to_integer(LY),
-	?line Z = list_to_integer(LZ),
-	?line XYZ = {X, Y, Z},
-	?line io:format("Self = ~w = ~w~n", [S,XYZ]),
-	?line {ok, [{matched, _node, 1}]} = dbg:p(S,call),
-	?line {ok, [{matched, _node, 1}]} = dbg:p(XYZ,call),
-	if Z =:= 0 ->
-		?line {ok, [{matched, _node, 1}]} = dbg:p(Y,call);
-	   true -> ok
-	end,
-	?line {ok, [{matched, _node, 1}]} = dbg:p(L,call),
-	?line {ok, _} = dbg:tpl(?MODULE,not_exported,[]),
-	?line 4 = not_exported(2),
-	?line [{trace,S,call,{?MODULE,not_exported,[2]}}] = flush(),
-	?line {ok, _} = dbg:tp(?MODULE,exported,[]),
-	?line 4 = ?MODULE:exported(2),
-	?line [{trace,S,call,{?MODULE,exported,[2]}},
-	       {trace,S,call,{?MODULE,not_exported,[2]}}] = flush(),
-	?line {ok, _} = dbg:ctpl(?MODULE),
-	?line 4 = ?MODULE:exported(2),
-	?line [{trace,S,call,{?MODULE,exported,[2]}}] = flush(),
-	?line {ok, _} = dbg:tpl(?MODULE,not_exported,[]),
-	?line {ok, _} = dbg:ctp(?MODULE),
-	?line 4 = ?MODULE:exported(2),
-	?line [] = flush(),
-	?line {ok, _} = dbg:tpl(?MODULE,not_exported,x),
-	?line catch ?MODULE:exported(x),
-	?line [{trace,S,call,{dbg_SUITE,not_exported,[x]}},
-	       {trace,S,exception_from,
-		{dbg_SUITE,not_exported,1},
-		{error,badarith}}] = flush()
+        S = self(),
+        %% Split "<X.Y.Z>" into {X, Y, Z}
+        "<"++L1 = L = pid_to_list(S),
+        NoDot = fun ($.) -> false; (_) -> true end,
+        {LX,"."++L2} = lists:splitwith(NoDot, L1),
+        {LY,"."++L3} = lists:splitwith(NoDot, L2),
+        ">"++L4 = lists:reverse(L3),
+        LZ = lists:reverse(L4),
+        X = 0 = list_to_integer(LX),
+        Y = list_to_integer(LY),
+        Z = list_to_integer(LZ),
+        XYZ = {X, Y, Z},
+        io:format("Self = ~w = ~w~n", [S,XYZ]),
+        {ok, [{matched, _node, 1}]} = dbg:p(S,call),
+        {ok, [{matched, _node, 1}]} = dbg:p(XYZ,call),
+        if Z =:= 0 ->
+               {ok, [{matched, _node, 1}]} = dbg:p(Y,call);
+           true -> ok
+        end,
+        {ok, [{matched, _node, 1}]} = dbg:p(L,call),
+        {ok, _} = dbg:tpl(?MODULE,not_exported,[]),
+        4 = not_exported(2),
+        [{trace,S,call,{?MODULE,not_exported,[2]}}] = flush(),
+        {ok, _} = dbg:tp(?MODULE,exported,[]),
+        4 = ?MODULE:exported(2),
+        [{trace,S,call,{?MODULE,exported,[2]}},
+         {trace,S,call,{?MODULE,not_exported,[2]}}] = flush(),
+        {ok, _} = dbg:ctpl(?MODULE),
+        4 = ?MODULE:exported(2),
+        [{trace,S,call,{?MODULE,exported,[2]}}] = flush(),
+        {ok, _} = dbg:tpl(?MODULE,not_exported,[]),
+        {ok, _} = dbg:ctp(?MODULE),
+        4 = ?MODULE:exported(2),
+        [] = flush(),
+        {ok, _} = dbg:tpl(?MODULE,not_exported,x),
+        catch ?MODULE:exported(x),
+        [{trace,S,call,{dbg_SUITE,not_exported,[x]}},
+         {trace,S,exception_from,
+          {dbg_SUITE,not_exported,1},
+          {error,badarith}}] = flush()
     after
-	?line stop()
+        stop()
     end,
     ok.
 
-port(suite) ->
-    [];
-port(doc) ->
-    ["Test that tracing on port works"];
+%% Test that tracing on port works
 port(Config) when is_list(Config) ->
     try
         S = self(),
-	start(),
+        start(),
         TestFile = filename:join(proplists:get_value(priv_dir, Config),"port_test"),
         Fun = dbg:trace_port(file, TestFile),
 
         %% Do a run to get rid of all extra port operations
         port_close(Fun()),
 
-	dbg:p(new,ports),
+        dbg:p(new,ports),
         Port = Fun(),
         port_close(Port),
-	stop(),
+        stop(),
 
         TraceFileDrv = list_to_atom(lists:flatten(["trace_file_drv n ",TestFile])),
-	[{trace,Port,open,S,TraceFileDrv},
+        [{trace,Port,open,S,TraceFileDrv},
          {trace,Port,getting_linked,S},
          {trace,Port,closed,normal},
          {trace,Port,unlink,S}] = flush()
     after
-	dbg:stop()
+        dbg:stop()
     end,
     ok.
 
-saved_patterns(suite) ->
-    [];
-saved_patterns(doc) ->
-    ["Tests saving of match_spec's."];
+%% Tests saving of match_spec's.
 saved_patterns(Config) when is_list(Config) ->
-    ?line dbg:stop(),
-    ?line {ok,[{saved,1}]} =
-	dbg:tp(dbg,ctp,1,[{'_',[],[{message, blahonga}]}]),
-    ?line {ok,[{saved,2}]} =
-	dbg:tp(dbg,ctp,1,[{['_'],[],[{message, blahonga}]}]),
-    ?line Privdir=?config(priv_dir, Config),
-    ?line file:make_dir(Privdir),
-    ?line File = filename:join([Privdir, "blahonga.ms"]),
-    ?line dbg:wtp(File),
-    ?line dbg:stop(),
-    ?line dbg:ctp('_','_','_'),
-    ?line {ok, _} = start(),
+    dbg:stop(),
+    {ok,[{saved,1}]} =
+    dbg:tp(dbg,ctp,1,[{'_',[],[{message, blahonga}]}]),
+    {ok,[{saved,2}]} =
+    dbg:tp(dbg,ctp,1,[{['_'],[],[{message, blahonga}]}]),
+    Privdir=proplists:get_value(priv_dir, Config),
+    file:make_dir(Privdir),
+    File = filename:join([Privdir, "blahonga.ms"]),
+    dbg:wtp(File),
+    dbg:stop(),
+    dbg:ctp('_','_','_'),
+    {ok, _} = start(),
     try
-	?line dbg:rtp(File),
-	?line {ok,[{matched,_node,1},{saved,1}]} = dbg:tp(dbg,ltp,0,1),
-	?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	?line dbg:ltp(),
-	?line S = self(),
-	?line [{trace,S,call,{dbg,ltp,[]},blahonga}] = flush()
+        dbg:rtp(File),
+        {ok,[{matched,_node,1},{saved,1}]} = dbg:tp(dbg,ltp,0,1),
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        dbg:ltp(),
+        S = self(),
+        [{trace,S,call,{dbg,ltp,[]},blahonga}] = flush()
     after
-	?line stop()
+        stop()
     end,
     ok.
 
@@ -341,148 +297,132 @@ not_exported(N) ->
 exported(N) ->
     not_exported(N).
 
-ip_port(suite) ->
-    [];
-ip_port(doc) ->
-    ["Test tracing to IP port"];
+%% Test tracing to IP port
 ip_port(Config) when is_list(Config) ->
-    ?line stop(),
-    ?line Port = dbg:trace_port(ip, 0),
-    ?line {ok, _} = dbg:tracer(port, Port),
+    stop(),
+    Port = dbg:trace_port(ip, 0),
+    {ok, _} = dbg:tracer(port, Port),
     try
-	?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	?line {ok, X} = dbg:tp(dbg, ltp,[{'_',[],[{message, {self}}]}]),
-	?line {value, {saved, _Saved}} = lists:keysearch(saved, 1, X),
-	?line {ok, Y} = dbg:tp(dbg, ln, [{'_',[],[{message, hej}]}]),
-	?line {value, {saved, _}} = lists:keysearch(saved, 1, Y),
-	?line ok = dbg:ltp(),
-	?line ok = dbg:ln(),
-	?line {ok, IpPort} = dbg:trace_port_control(get_listen_port),
-	?line io:format("IpPort = ~p~n", [IpPort]),
-	?line dbg:trace_client(ip, IpPort, {fun myhandler/2, self()}),
-	?line S = self(),
-	?line [{trace,S,call,{dbg,ltp,[]},S},
-	       {trace,S,call,{dbg,ln,[]},hej}] = flush()
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        {ok, X} = dbg:tp(dbg, ltp,[{'_',[],[{message, {self}}]}]),
+        {value, {saved, _Saved}} = lists:keysearch(saved, 1, X),
+        {ok, Y} = dbg:tp(dbg, ln, [{'_',[],[{message, hej}]}]),
+        {value, {saved, _}} = lists:keysearch(saved, 1, Y),
+        ok = dbg:ltp(),
+        ok = dbg:ln(),
+        {ok, IpPort} = dbg:trace_port_control(get_listen_port),
+        io:format("IpPort = ~p~n", [IpPort]),
+        dbg:trace_client(ip, IpPort, {fun myhandler/2, self()}),
+        S = self(),
+        [{trace,S,call,{dbg,ltp,[]},S},
+         {trace,S,call,{dbg,ln,[]},hej}] = flush()
     after
-	?line stop()
+        stop()
     end,
     ok.
 
 
 
-ip_port_busy(suite) ->
-    [];
-ip_port_busy(doc) ->
-    ["Test that the dbg server does not hang if the tracer don't start ",
-     "(OTP-3592)"];
+%% Test that the dbg server does not hang if the tracer don't start (OTP-3592)
 ip_port_busy(Config) when is_list(Config) ->
-    ?line stop(),
-    ?line Tracer = dbg:trace_port(ip, 4745),
-    ?line Port = Tracer(),
-    ?line {error, Reason} = dbg:tracer(port, Tracer),
+    stop(),
+    Tracer = dbg:trace_port(ip, 4745),
+    Port = Tracer(),
+    {error, Reason} = dbg:tracer(port, Tracer),
     try
-	?line io:format("Error reason = ~p~n", [Reason]),
-	?line true = port_close(Port)
+        io:format("Error reason = ~p~n", [Reason]),
+        true = port_close(Port)
     after
-	?line dbg:stop()
+        dbg:stop()
     end,
-    ?line ok.
+    ok.
 
 
 
-file_port(suite) ->
-    [];
-file_port(doc) ->
-    ["Test tracing to file port (simple)"];
+%% Test tracing to file port (simple)
 file_port(Config) when is_list(Config) ->
-    ?line stop(),
-    ?line {A,B,C} = erlang:now(),
-    ?line FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++ "-" ++
-	integer_to_list(B) ++ "-" ++ integer_to_list(C),
-    ?line FName = filename:join([?config(data_dir, Config), FTMP]),
-    ?line Port = dbg:trace_port(file, FName),
-    ?line {ok, _} = dbg:tracer(port, Port),
+    stop(),
+    {A,B,C} = erlang:now(),
+    FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++ "-" ++
+    integer_to_list(B) ++ "-" ++ integer_to_list(C),
+    FName = filename:join([proplists:get_value(data_dir, Config), FTMP]),
+    Port = dbg:trace_port(file, FName),
+    {ok, _} = dbg:tracer(port, Port),
     try
-	?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	?line {ok, X} = dbg:tp(dbg, ltp,[{'_',[],[{message, {self}}]}]),
-	?line {value, {saved, _Saved}} = lists:keysearch(saved, 1, X),
-	?line {ok, Y} = dbg:tp(dbg, ln, [{'_',[],[{message, hej}]}]),
-	?line {value, {saved, _}} = lists:keysearch(saved, 1, Y),
-	?line ok = dbg:ltp(),
-	?line ok = dbg:ln(),
-	?line stop(),
-	?line dbg:trace_client(file, FName, {fun myhandler/2, self()}),
-	?line S = self(),
-	?line [{trace,S,call,{dbg,ltp,[]},S},
-	       {trace,S,call,{dbg,ln,[]},hej},
-	       end_of_trace] = flush()
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        {ok, X} = dbg:tp(dbg, ltp,[{'_',[],[{message, {self}}]}]),
+        {value, {saved, _Saved}} = lists:keysearch(saved, 1, X),
+        {ok, Y} = dbg:tp(dbg, ln, [{'_',[],[{message, hej}]}]),
+        {value, {saved, _}} = lists:keysearch(saved, 1, Y),
+        ok = dbg:ltp(),
+        ok = dbg:ln(),
+        stop(),
+        dbg:trace_client(file, FName, {fun myhandler/2, self()}),
+        S = self(),
+        [{trace,S,call,{dbg,ltp,[]},S},
+         {trace,S,call,{dbg,ln,[]},hej},
+         end_of_trace] = flush()
     after
-	?line stop(),
-        ?line file:delete(FName)
+        stop(),
+        file:delete(FName)
     end,
     ok.
 
-file_port2(suite) ->
-    [];
-file_port2(doc) ->
-    ["Test tracing to file port with 'follow_file'"];
+%% Test tracing to file port with 'follow_file'
 file_port2(Config) when is_list(Config) ->
     stop(),
     {A,B,C} = erlang:now(),
     FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++
-	"-" ++ integer_to_list(B) ++ "-" ++ integer_to_list(C),
-    FName = filename:join([?config(data_dir, Config), FTMP]),
+    "-" ++ integer_to_list(B) ++ "-" ++ integer_to_list(C),
+    FName = filename:join([proplists:get_value(data_dir, Config), FTMP]),
     %% Ok, lets try with flush and follow_file, not a chance on VxWorks
     %% with NFS caching...
     Port2 = dbg:trace_port(file, FName),
     {ok, _} = dbg:tracer(port, Port2),
     try
-	{ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	{ok, _} = dbg:tp(dbg, ltp,[{'_',[],[{message, {self}}]}]),
-	{ok, _} = dbg:tp(dbg, ln, [{'_',[],[{message, hej}]}]),
-	ok = dbg:ltp(),
-	ok = dbg:flush_trace_port(),
-	dbg:trace_client(follow_file, FName,
-	  	       {fun myhandler/2, self()}),
-	S = self(),
-	[{trace,S,call,{dbg,ltp,[]},S}] = flush(),
-	ok = dbg:ln(),
-	ok = dbg:flush_trace_port(),
-	receive after 1000 -> ok end, %% Polls every second...
-	[{trace,S,call,{dbg,ln,[]},hej}] = flush(),
-	stop(),
-	[] = flush()
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        {ok, _} = dbg:tp(dbg, ltp,[{'_',[],[{message, {self}}]}]),
+        {ok, _} = dbg:tp(dbg, ln, [{'_',[],[{message, hej}]}]),
+        ok = dbg:ltp(),
+        ok = dbg:flush_trace_port(),
+        dbg:trace_client(follow_file, FName,
+                         {fun myhandler/2, self()}),
+        S = self(),
+        [{trace,S,call,{dbg,ltp,[]},S}] = flush(),
+        ok = dbg:ln(),
+        ok = dbg:flush_trace_port(),
+        receive after 1000 -> ok end, %% Polls every second...
+        [{trace,S,call,{dbg,ln,[]},hej}] = flush(),
+        stop(),
+        [] = flush()
     after
-	stop(),
-	file:delete(FName)
+        stop(),
+        file:delete(FName)
     end,
     ok.
 
-file_port_schedfix(suite) ->
-    [];
-file_port_schedfix(doc) ->
-    ["Test that the scheduling timestamp fix for trace flag 'running' works."];
+%% Test that the scheduling timestamp fix for trace flag 'running' works.
 file_port_schedfix(Config) when is_list(Config) ->
-    ?line case (catch erlang:system_info(smp_support)) of
-	      true ->
-		  {skip, "No schedule fix on SMP"};
-	      _ ->
-		  try
-		      file_port_schedfix1(Config)
-		  after
-		      dbg:stop()
-		  end
-	  end.
+    case (catch erlang:system_info(smp_support)) of
+        true ->
+            {skip, "No schedule fix on SMP"};
+        _ ->
+            try
+                file_port_schedfix1(Config)
+            after
+                dbg:stop()
+            end
+    end.
 file_port_schedfix1(Config) when is_list(Config) ->
-    ?line stop(),
-    ?line {A,B,C} = erlang:now(),
-    ?line FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++
-	"-" ++ integer_to_list(B) ++ "-" ++ integer_to_list(C),
-    ?line FName = filename:join([?config(data_dir, Config), FTMP]),
+    stop(),
+    {A,B,C} = erlang:now(),
+    FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++
+    "-" ++ integer_to_list(B) ++ "-" ++ integer_to_list(C),
+    FName = filename:join([proplists:get_value(data_dir, Config), FTMP]),
     %%
-    ?line Port = dbg:trace_port(file, {FName, wrap, ".wraplog", 8*1024, 4}),
-    ?line {ok, _} = dbg:tracer(port, Port),
-    ?line {ok,[{matched,_node,0}]} = dbg:p(new,[running,procs,send,timestamp]),
+    Port = dbg:trace_port(file, {FName, wrap, ".wraplog", 8*1024, 4}),
+    {ok, _} = dbg:tracer(port, Port),
+    {ok,[{matched,_node,0}]} = dbg:p(new,[running,procs,send,timestamp]),
     %%
     %% Generate the trace data
     %%
@@ -503,146 +443,143 @@ file_port_schedfix1(Config) when is_list(Config) ->
     %% execution time. Wallclock. A normal result is about 10 times more
     %% without schedule in - schedule out compensation (OTP-3938).
     %%
-    ?line ok = token_volleyball(3, 4, 8),
+    ok = token_volleyball(3, 4, 8),
     %%
-    ?line {ok,[{matched,_,_}]} = dbg:p(all, [clear]),
-    ?line stop(),
+    {ok,[{matched,_,_}]} = dbg:p(all, [clear]),
+    stop(),
     % Some debug code to run on all platforms, for finding the fault on genny
     % Dont touch please /PaN
-    ?line io:format("Trace dump by PaN BEGIN~n"),
-    ?line dbg:trace_client(file,{FName, wrap, ".wraplog"},{fun(end_of_trace,Pid)-> Pid ! done; (Mesg,Pid) -> io:format("~w~n",[Mesg]),Pid end,self()}),
+    io:format("Trace dump by PaN BEGIN~n"),
+    dbg:trace_client(file,{FName, wrap, ".wraplog"},{fun(end_of_trace,Pid)-> Pid ! done; (Mesg,Pid) -> io:format("~w~n",[Mesg]),Pid end,self()}),
     receive done -> ok end,
-    ?line io:format("Trace dump by PaN END~n"),
-      %%
+    io:format("Trace dump by PaN END~n"),
+    %%
     %% Get the trace result
     %%
-    ?line Tag = make_ref(),
-    ?line dbg:trace_client(file, {FName, wrap, ".wraplog"},
-			   {fun schedstat_handler/2, {self(), Tag, []}}),
-    ?line Result =
-	receive
-	    {Tag, D} ->
-		lists:map(
-		  fun({Pid, {A1, B1, C1}}) ->
-			  {Pid, C1/1000000 + B1 + A1*1000000}
-		  end,
-		  D)
-	end,
-    ?line ok = io:format("Result=~p", [Result]),
-%    erlang:display({?MODULE, ?LINE, Result}),
+    Tag = make_ref(),
+    dbg:trace_client(file, {FName, wrap, ".wraplog"},
+                     {fun schedstat_handler/2, {self(), Tag, []}}),
+    Result =
+    receive
+        {Tag, D} ->
+            lists:map(
+              fun({Pid, {A1, B1, C1}}) ->
+                      {Pid, C1/1000000 + B1 + A1*1000000}
+              end,
+              D)
+    end,
+    ok = io:format("Result=~p", [Result]),
+    %    erlang:display({?MODULE, ?LINE, Result}),
     %%
     %% Analyze the result
     %%
-    ?line {Min, Max} =
-	lists:foldl(
-	  fun({_Pid, M}, {Mi, Ma}) ->
-		  {if M < Mi -> M; true -> Mi end,
-		   if M > Ma -> M; true -> Ma end}
-	  end,
-	  {void, 0},
-	  Result),
+    {Min, Max} =
+    lists:foldl(
+      fun({_Pid, M}, {Mi, Ma}) ->
+              {if M < Mi -> M; true -> Mi end,
+               if M > Ma -> M; true -> Ma end}
+      end,
+      {void, 0},
+      Result),
     % More PaN debug
-    ?line io:format("Min = ~f, Max = ~f~n",[Min,Max]),
+    io:format("Min = ~f, Max = ~f~n",[Min,Max]),
     %%
     %% Cleanup
     %%
-    ?line ToBeDeleted = filelib:wildcard(FName++"*"++".wraplog"),
-    ?line lists:map(fun file:delete/1, ToBeDeleted),
-%    io:format("ToBeDeleted=~p", [ToBeDeleted]),
+    ToBeDeleted = filelib:wildcard(FName++"*"++".wraplog"),
+    lists:map(fun file:delete/1, ToBeDeleted),
+    %    io:format("ToBeDeleted=~p", [ToBeDeleted]),
     %%
     %% Present the result
     %%
     P = (Max / Min - 1) * 100,
     BottomLine = lists:flatten(io_lib:format("~.2f %", [P])),
     if P > 100 ->
-	    Reason = {BottomLine, '>', "100%"},
-	    erlang:display({file_port_schedfix, fail, Reason}),
-	    test_server:fail(Reason);
+           Reason = {BottomLine, '>', "100%"},
+           erlang:display({file_port_schedfix, fail, Reason}),
+           ct:fail(Reason);
        true ->
-	    {comment, BottomLine}
+           {comment, BottomLine}
     end.
 
-wrap_port(suite) ->
-    [];
-wrap_port(doc) ->
-    ["Test tracing to wrapping file port"];
+%% Test tracing to wrapping file port
 wrap_port(Config) when is_list(Config) ->
-    ?line Self = self(),
-    ?line stop(),
-    ?line {A,B,C} = erlang:now(),
-    ?line FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++ "-" ++
-	integer_to_list(B) ++ "-" ++ integer_to_list(C) ++ "-",
-    ?line FName = filename:join([?config(data_dir, Config), FTMP]),
-    ?line FNameWildcard = FName++"*"++".trace",
+    Self = self(),
+    stop(),
+    {A,B,C} = erlang:now(),
+    FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++ "-" ++
+    integer_to_list(B) ++ "-" ++ integer_to_list(C) ++ "-",
+    FName = filename:join([proplists:get_value(data_dir, Config), FTMP]),
+    FNameWildcard = FName++"*"++".trace",
     %% WrapSize=0 and WrapCnt=11 will force the trace to wrap after
     %% every trace message, and to contain only the last 10 entries
     %% after trace stop since the last file will be empty waiting
     %% for its first trace message.
-    ?line WrapSize = 0,
-    ?line WrapCnt = 11,
-    ?line WrapFilesSpec = {FName, wrap, ".trace", WrapSize, WrapCnt},
-    ?line wrap_port_init(WrapFilesSpec),
+    WrapSize = 0,
+    WrapCnt = 11,
+    WrapFilesSpec = {FName, wrap, ".trace", WrapSize, WrapCnt},
+    wrap_port_init(WrapFilesSpec),
     %% The number of iterations, N, is tested to place wrap the log,
     %% giving a gap in the filename sequence at index 3.
     %% This should be a difficult case for
     %% the trace_client file sorting functionality.
     N = 7,
-    ?line lists:foreach(
-	    fun(Cnt) ->
-		    ?MODULE:tracee1(Cnt),
-		    ?MODULE:tracee2(Cnt)
-	    end,
-	    lists:seq(1, N)),
-    ?line stop(),
+    lists:foreach(
+      fun(Cnt) ->
+              ?MODULE:tracee1(Cnt),
+              ?MODULE:tracee2(Cnt)
+      end,
+      lists:seq(1, N)),
+    stop(),
     try
-	?line Files1 = filelib:wildcard(FNameWildcard),
-	?line io:format("~p~n", [Files1]),
-	?line Tc1 = dbg:trace_client(file, WrapFilesSpec,
-				     {fun myhandler/2, {wait_for_go,Self}}),
-	?line Tref1 = erlang:monitor(process, Tc1),
-	Tc1 ! {go,Self},
-	?line [{'DOWN',Tref1,_,_,normal},
-	       end_of_trace
-	       |Result] = lists:reverse(flush()),
-	?line M = N - (WrapCnt-1) div 2,
-	?line M = wrap_port_result(Result, Self, N),
-	%%
-	%% Start a new wrap log with the same name to verify that
-	%% all files are cleared at wrap log start. Only produce
-	%% two trace messages to also place the gap at index 3,
-	%% so the trace log will be misinterpreted.
-	%%
-	?line wrap_port_init(WrapFilesSpec),
-	?line Files2 = filelib:wildcard(FNameWildcard),
-	?line io:format("~p~n", [Files2]),
-	?line -1 = ?MODULE:tracee1(-1),
-	?line -1 = ?MODULE:tracee2(-1),
-	?line stop(),
-	?line Files = filelib:wildcard(FNameWildcard),
-	?line io:format("~p~n", [Files]),
-	?line Tc2 = dbg:trace_client(file, WrapFilesSpec,
-				     {fun myhandler/2, {wait_for_go,Self}}),
-	?line Tref2 = erlang:monitor(process, Tc2),
-	Tc2 ! {go,Self},
-	?line [{trace,Self,call,{?MODULE,tracee1,[-1]},Self},
-	       {trace,Self,call,{?MODULE,tracee2,[-1]},hej},
-	       end_of_trace,
-	       {'DOWN',Tref2,_,_,normal}] = flush(),
-	%%
-	?line lists:map(fun(F) -> file:delete(F) end, Files)
+        Files1 = filelib:wildcard(FNameWildcard),
+        io:format("~p~n", [Files1]),
+        Tc1 = dbg:trace_client(file, WrapFilesSpec,
+                               {fun myhandler/2, {wait_for_go,Self}}),
+        Tref1 = erlang:monitor(process, Tc1),
+        Tc1 ! {go,Self},
+        [{'DOWN',Tref1,_,_,normal},
+         end_of_trace
+         |Result] = lists:reverse(flush()),
+        M = N - (WrapCnt-1) div 2,
+        M = wrap_port_result(Result, Self, N),
+        %%
+        %% Start a new wrap log with the same name to verify that
+        %% all files are cleared at wrap log start. Only produce
+        %% two trace messages to also place the gap at index 3,
+        %% so the trace log will be misinterpreted.
+        %%
+        wrap_port_init(WrapFilesSpec),
+        Files2 = filelib:wildcard(FNameWildcard),
+        io:format("~p~n", [Files2]),
+        -1 = ?MODULE:tracee1(-1),
+        -1 = ?MODULE:tracee2(-1),
+        stop(),
+        Files = filelib:wildcard(FNameWildcard),
+        io:format("~p~n", [Files]),
+        Tc2 = dbg:trace_client(file, WrapFilesSpec,
+                               {fun myhandler/2, {wait_for_go,Self}}),
+        Tref2 = erlang:monitor(process, Tc2),
+        Tc2 ! {go,Self},
+        [{trace,Self,call,{?MODULE,tracee1,[-1]},Self},
+         {trace,Self,call,{?MODULE,tracee2,[-1]},hej},
+         end_of_trace,
+         {'DOWN',Tref2,_,_,normal}] = flush(),
+        %%
+        lists:map(fun(F) -> file:delete(F) end, Files)
     after
-	?line stop()
+        stop()
     end,
     ok.
 
 wrap_port_init(WrapFilesSpec) ->
-    ?line Port = dbg:trace_port(file, WrapFilesSpec),
-    ?line {ok, _} = dbg:tracer(port, Port),
-    ?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-    ?line {ok, X} = dbg:tp(?MODULE, tracee1,[{'_',[],[{message, {self}}]}]),
-    ?line {value, {saved, _Saved}} = lists:keysearch(saved, 1, X),
-    ?line {ok, Y} = dbg:tp(?MODULE, tracee2, [{'_',[],[{message, hej}]}]),
-    ?line {value, {saved, _}} = lists:keysearch(saved, 1, Y),
+    Port = dbg:trace_port(file, WrapFilesSpec),
+    {ok, _} = dbg:tracer(port, Port),
+    {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+    {ok, X} = dbg:tp(?MODULE, tracee1,[{'_',[],[{message, {self}}]}]),
+    {value, {saved, _Saved}} = lists:keysearch(saved, 1, X),
+    {ok, Y} = dbg:tp(?MODULE, tracee2, [{'_',[],[{message, hej}]}]),
+    {value, {saved, _}} = lists:keysearch(saved, 1, Y),
     ok.
 
 tracee1(X) ->
@@ -654,106 +591,96 @@ tracee2(X) ->
 wrap_port_result([], _S, M) ->
     M;
 wrap_port_result([{trace, S, call, {?MODULE, tracee2, [M]}, hej},
-		  {trace, S, call, {?MODULE, tracee1, [M]}, S} | Tail],
-		 S,
-		 M) ->
+                  {trace, S, call, {?MODULE, tracee1, [M]}, S} | Tail],
+                 S,
+                 M) ->
     wrap_port_result(Tail, S, M-1).
 
 
-wrap_port_time(suite) ->
-    [];
-wrap_port_time(doc) ->
-    ["Test tracing to time limited wrapping file port"];
+%% Test tracing to time limited wrapping file port
 wrap_port_time(Config) when is_list(Config) ->
-    ?line stop(),
-    ?line {A,B,C} = erlang:now(),
-    ?line FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++ "-" ++
-	integer_to_list(B) ++ "-" ++ integer_to_list(C) ++ "-",
-    ?line FName = filename:join([?config(data_dir, Config), FTMP]),
+    stop(),
+    {A,B,C} = erlang:now(),
+    FTMP =  atom_to_list(?MODULE) ++ integer_to_list(A) ++ "-" ++
+    integer_to_list(B) ++ "-" ++ integer_to_list(C) ++ "-",
+    FName = filename:join([proplists:get_value(data_dir, Config), FTMP]),
     %% WrapTime=2 and WrapCnt=4 will force the trace to wrap after
     %% every 2 seconds, and to contain between 3*2 and 4*2 seconds
     %% of trace entries.
-    ?line WrapFilesSpec = {FName, wrap, ".trace", {time, 2000}, 4},
-    ?line Port = dbg:trace_port(file, WrapFilesSpec),
-    ?line {ok, _} = dbg:tracer(port, Port),
+    WrapFilesSpec = {FName, wrap, ".trace", {time, 2000}, 4},
+    Port = dbg:trace_port(file, WrapFilesSpec),
+    {ok, _} = dbg:tracer(port, Port),
     try
-	?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	?line {ok, X} = dbg:tp(?MODULE, tracee1,[{'_',[],[{message, {self}}]}]),
-	?line {value, {saved, _Saved1}} = lists:keysearch(saved, 1, X),
-	?line {ok, Y} = dbg:tp(?MODULE, tracee2, [{'_',[],[{message, hej}]}]),
-	?line {value, {saved, _Saved2}} = lists:keysearch(saved, 1, Y),
-	%% The delays in the iterations places two trace messages in each
-	%% trace file, but the last which is empty waiting for its first
-	%% trace message. The number of iterations is chosen so that
-	%% one trace file has been wasted, and therefore the first pair
-	%% of trace messages.
-	?line lists:foreach(
-		fun(Cnt) ->
-			receive after 1000 -> ok end,
-			?MODULE:tracee1(Cnt),
-			?MODULE:tracee2(Cnt),
-			receive after 1100 -> ok end
-		end,
-		lists:seq(1, 4)),
-	?line stop(),
-	?line Files = filelib:wildcard(FName ++ "*" ++ ".trace"),
-	?line io:format("~p~n", [Files]),
-	?line dbg:trace_client(file, WrapFilesSpec, {fun myhandler/2, self()}),
-	?line S = self(),
-	?line [{trace, S, call, {?MODULE, tracee1, [2]}, S},
-	       {trace, S, call, {?MODULE, tracee2, [2]}, hej},
-	       {trace, S, call, {?MODULE, tracee1, [3]}, S},
-	       {trace, S, call, {?MODULE, tracee2, [3]}, hej},
-	       {trace, S, call, {?MODULE, tracee1, [4]}, S},
-	       {trace, S, call, {?MODULE, tracee2, [4]}, hej},
-	       end_of_trace] = flush(),
-	?line lists:map(fun(F) -> file:delete(F) end, Files)
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        {ok, X} = dbg:tp(?MODULE, tracee1,[{'_',[],[{message, {self}}]}]),
+        {value, {saved, _Saved1}} = lists:keysearch(saved, 1, X),
+        {ok, Y} = dbg:tp(?MODULE, tracee2, [{'_',[],[{message, hej}]}]),
+        {value, {saved, _Saved2}} = lists:keysearch(saved, 1, Y),
+        %% The delays in the iterations places two trace messages in each
+        %% trace file, but the last which is empty waiting for its first
+        %% trace message. The number of iterations is chosen so that
+        %% one trace file has been wasted, and therefore the first pair
+        %% of trace messages.
+        lists:foreach(
+          fun(Cnt) ->
+                  receive after 1000 -> ok end,
+                  ?MODULE:tracee1(Cnt),
+                  ?MODULE:tracee2(Cnt),
+                  receive after 1100 -> ok end
+          end,
+          lists:seq(1, 4)),
+        stop(),
+        Files = filelib:wildcard(FName ++ "*" ++ ".trace"),
+        io:format("~p~n", [Files]),
+        dbg:trace_client(file, WrapFilesSpec, {fun myhandler/2, self()}),
+        S = self(),
+        [{trace, S, call, {?MODULE, tracee1, [2]}, S},
+         {trace, S, call, {?MODULE, tracee2, [2]}, hej},
+         {trace, S, call, {?MODULE, tracee1, [3]}, S},
+         {trace, S, call, {?MODULE, tracee2, [3]}, hej},
+         {trace, S, call, {?MODULE, tracee1, [4]}, S},
+         {trace, S, call, {?MODULE, tracee2, [4]}, hej},
+         end_of_trace] = flush(),
+        lists:map(fun(F) -> file:delete(F) end, Files)
     after
-	?line stop()
+        stop()
     end,
     ok.
 
-with_seq_trace(suite) ->
-    [];
-with_seq_trace(doc) ->
-    ["Test ordinary tracing combined with seq_trace"];
+%% Test ordinary tracing combined with seq_trace
 with_seq_trace(Config) when is_list(Config) ->
     try
-	?line {ok, Server} = start(),
-	?line {ok, Tracer} = dbg:get_tracer(),
-	?line {ok, X} = dbg:tp(dbg, get_tracer, [{[],[],
-						  [{set_seq_token, send, true}]}]),
-	?line {value, {saved, _}} = lists:keysearch(saved, 1, X),
-	?line {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
-	?line seq_trace:set_system_tracer(Tracer),
-	?line dbg:get_tracer(),
-	receive
-	    after 1 ->
-		    ok
-	    end,
-	?line S = self(),
-	?line ThisNode = node(),
-	?line [{trace,S,call,{dbg,get_tracer,[]}},
-	       {seq_trace,0,{send,_,S,Server,{S,{get_tracer,ThisNode}}}},
-	       {seq_trace,0,{send,_,Server,S,{dbg,{ok,Tracer}}}}] =
-	flush()
+        {ok, Server} = start(),
+        {ok, Tracer} = dbg:get_tracer(),
+        {ok, X} = dbg:tp(dbg, get_tracer, [{[],[],
+                                            [{set_seq_token, send, true}]}]),
+        {value, {saved, _}} = lists:keysearch(saved, 1, X),
+        {ok, [{matched, _node, 1}]} = dbg:p(self(),call),
+        seq_trace:set_system_tracer(Tracer),
+        dbg:get_tracer(),
+        receive
+        after 1 ->
+                  ok
+        end,
+        S = self(),
+        ThisNode = node(),
+        [{trace,S,call,{dbg,get_tracer,[]}},
+         {seq_trace,0,{send,_,S,Server,{S,{get_tracer,ThisNode}}}},
+         {seq_trace,0,{send,_,Server,S,{dbg,{ok,Tracer}}}}] =
+        flush()
     after
-	?line stop()
+        stop()
     end,
     ok.
 
-dead_suspend(suite) ->
-    [];
-dead_suspend(doc) ->
-    ["Test that trace messages concerning a now dead process does "
-     "not crash dbg."];
 
+%% Test that trace messages concerning a now dead process does not crash dbg.
 dead_suspend(Config) when is_list(Config) ->
-    ?line start(),
+    start(),
     try
-	survived = run_dead_suspend()
+        survived = run_dead_suspend()
     after
-	?line stop()
+        stop()
     end.
 
 run_dead_suspend() ->
@@ -766,10 +693,10 @@ run_dead_suspend() ->
     spawn(?MODULE, dummy, []),
     receive after 1000 -> ok end,
     case whereis(dbg) of
-	undefined ->
-	    died;
-	_ ->
-	    survived
+        undefined ->
+            died;
+        _ ->
+            survived
     end.
 
 dummy() ->
@@ -781,10 +708,10 @@ tracer_exit_on_stop(_) ->
     %% Tracer blocks waiting for fun to complete so that the trace message and
     %% the exit signal message from the dbg process are in its message queue.
     Fun = fun() ->
-	    ?MODULE:dummy(),
-	    Ref = erlang:trace_delivered(self()),
-	    receive {trace_delivered, _, Ref} -> stop() end
-	end,
+                  ?MODULE:dummy(),
+                  Ref = erlang:trace_delivered(self()),
+                  receive {trace_delivered, _, Ref} -> stop() end
+          end,
     {ok, _} = dbg:tracer(process, {fun spawn_once_handler/2, {self(), Fun}}),
     {ok, Tracer} = dbg:get_tracer(),
     MRef = monitor(process, Tracer),
@@ -803,9 +730,9 @@ spawn_once_handler(Event, {Pid, done} = State) ->
 spawn_once_handler(Event, {Pid, Fun}) ->
     {_, Ref} = spawn_monitor(Fun),
     receive
-	{'DOWN', Ref, _, _, _} ->
-	    Pid ! Event,
-	    {Pid, done}
+        {'DOWN', Ref, _, _, _} ->
+            Pid ! Event,
+            {Pid, done}
     end.
 
 %% Test that erl_tracer modules work correctly
@@ -898,38 +825,38 @@ wait_node(_,0) ->
     no;
 wait_node(Node, N) ->
     case net_adm:ping(Node) of
-	pong ->
-	    ok;
-	pang ->
-	    receive
-	    after 1000 ->
-		    ok
-	    end,
-	    wait_node(Node, N - 1)
+        pong ->
+            ok;
+        pang ->
+            receive
+            after 1000 ->
+                      ok
+            end,
+            wait_node(Node, N - 1)
     end.
 
 myhandler(Message, {wait_for_go,Pid}) ->
     receive
-	{go,Pid} ->
-	    myhandler(Message, Pid)
+        {go,Pid} ->
+            myhandler(Message, Pid)
     end;
 myhandler(Message, Relay) ->
     Relay ! Message,
     case Message of
-	end_of_trace ->
-	    ok;
-	_ ->
-	    Relay
+        end_of_trace ->
+            ok;
+        _ ->
+            Relay
     end.
 
 flush() ->
     flush([]).
 flush(Acc) ->
     receive
-	X ->
-	    flush(Acc ++ [X])
+        X ->
+            flush(Acc ++ [X])
     after 1000 ->
-	    Acc
+              Acc
     end.
 
 start() ->
@@ -943,88 +870,88 @@ stop() ->
 
 schedstat_handler(TraceMsg, {Parent, Tag, Data} = State) ->
     case TraceMsg of
-	{trace_ts, Pid, in, _, Ts} ->
-	    NewData =
-		case lists:keysearch(Pid, 1, Data) of
-		    {value, {Pid, Acc}} ->
-			[{Pid, Acc, Ts} | lists:keydelete(Pid, 1, Data)];
-		    false ->
-			[{Pid, {0, 0, 0}, Ts} | Data];
-		    Other ->
-			exit(Parent, {?MODULE, ?LINE, Other}),
-			erlang:display({?MODULE, ?LINE, Other}),
-			Data
-		end,
-	    {Parent, Tag, NewData};
-	{trace_ts, Pid, out, _, {A3, B3, C3}} ->
-	    NewData =
-		case lists:keysearch(Pid, 1, Data) of
-		    {value, {Pid, {A1, B1, C1}, {A2, B2, C2}}} ->
-			[{Pid, {A3-A2+A1, B3-B2+B1, C3-C2+C1}} |
-			 lists:keydelete(Pid, 1, Data)];
-		    Other ->
-			exit(Parent, {?MODULE, ?LINE, Other}),
-			erlang:display({?MODULE, ?LINE, Other}),
-			Data
-		end,
-	    {Parent, Tag, NewData};
-	{trace_ts, Pid, exit, normal, {A3, B3, C3}} ->
-	    NewData =
-		case lists:keysearch(Pid, 1, Data) of
-		    {value, {Pid, {A1, B1, C1}, {A2, B2, C2}}} ->
-			[{Pid, {A3-A2+A1, B3-B2+B1, C3-C2+C1}} |
-			 lists:keydelete(Pid, 1, Data)];
-		    {value, {Pid, _Acc}} ->
-			Data;
-		    false ->
-			[{Pid, {0, 0, 0}} | Data];
-		    Other ->
-			exit(Parent, {?MODULE, ?LINE, Other}),
-			erlang:display({?MODULE, ?LINE, Other}),
-			Data
-		end,
-	    {Parent, Tag, NewData};
-	{trace_ts, _Pid, send, _Msg, _OtherPid, _Ts} ->
-	    State;
-	end_of_trace ->
-	    Parent ! {Tag, Data},
-	    State
+        {trace_ts, Pid, in, _, Ts} ->
+            NewData =
+            case lists:keysearch(Pid, 1, Data) of
+                {value, {Pid, Acc}} ->
+                    [{Pid, Acc, Ts} | lists:keydelete(Pid, 1, Data)];
+                false ->
+                    [{Pid, {0, 0, 0}, Ts} | Data];
+                Other ->
+                    exit(Parent, {?MODULE, ?LINE, Other}),
+                    erlang:display({?MODULE, ?LINE, Other}),
+                    Data
+            end,
+            {Parent, Tag, NewData};
+        {trace_ts, Pid, out, _, {A3, B3, C3}} ->
+            NewData =
+            case lists:keysearch(Pid, 1, Data) of
+                {value, {Pid, {A1, B1, C1}, {A2, B2, C2}}} ->
+                    [{Pid, {A3-A2+A1, B3-B2+B1, C3-C2+C1}} |
+                     lists:keydelete(Pid, 1, Data)];
+                Other ->
+                    exit(Parent, {?MODULE, ?LINE, Other}),
+                    erlang:display({?MODULE, ?LINE, Other}),
+                    Data
+            end,
+            {Parent, Tag, NewData};
+        {trace_ts, Pid, exit, normal, {A3, B3, C3}} ->
+            NewData =
+            case lists:keysearch(Pid, 1, Data) of
+                {value, {Pid, {A1, B1, C1}, {A2, B2, C2}}} ->
+                    [{Pid, {A3-A2+A1, B3-B2+B1, C3-C2+C1}} |
+                     lists:keydelete(Pid, 1, Data)];
+                {value, {Pid, _Acc}} ->
+                    Data;
+                false ->
+                    [{Pid, {0, 0, 0}} | Data];
+                Other ->
+                    exit(Parent, {?MODULE, ?LINE, Other}),
+                    erlang:display({?MODULE, ?LINE, Other}),
+                    Data
+            end,
+            {Parent, Tag, NewData};
+        {trace_ts, _Pid, send, _Msg, _OtherPid, _Ts} ->
+            State;
+        end_of_trace ->
+            Parent ! {Tag, Data},
+            State
     end.
 
 
 
 pass_token(Token, Next, Loops) ->
     receive
-	{Token, 1} = Msg ->
-	    sendloop(Loops),
-	    Next ! Msg;
-	{Token, _Cnt} = Msg->
-	    sendloop(Loops),
-	    Next ! Msg,
-	    pass_token(Token, Next, Loops)
+        {Token, 1} = Msg ->
+            sendloop(Loops),
+            Next ! Msg;
+        {Token, _Cnt} = Msg->
+            sendloop(Loops),
+            Next ! Msg,
+            pass_token(Token, Next, Loops)
     end.
 
 pass_token(Token, Final, Cnt, Loops) ->
     receive
-	{Token, start, Next} ->
-	    sendloop(Loops),
-	    Msg = {Token, Cnt},
-	    Next ! Msg,
-	    pass_token(Token, Final, Next, Cnt, Loops)
+        {Token, start, Next} ->
+            sendloop(Loops),
+            Msg = {Token, Cnt},
+            Next ! Msg,
+            pass_token(Token, Final, Next, Cnt, Loops)
     end.
 
 pass_token(Token, Final, Next, Cnt, Loops) ->
     receive
-	{Token, 1} ->
-	    sendloop(Loops),
-	    Msg = {Token, done},
-	    Final ! Msg;
-	{Token, Cnt} ->
-	    sendloop(Loops),
-	    NextCnt = Cnt-1,
-	    Msg = {Token, NextCnt},
-	    Next ! Msg,
-	    pass_token(Token, Final, Next, NextCnt, Loops)
+        {Token, 1} ->
+            sendloop(Loops),
+            Msg = {Token, done},
+            Final ! Msg;
+        {Token, Cnt} ->
+            sendloop(Loops),
+            NextCnt = Cnt-1,
+            Msg = {Token, NextCnt},
+            Next ! Msg,
+            pass_token(Token, Final, Next, NextCnt, Loops)
     end.
 
 sendloop(Loops) ->
diff --git a/lib/runtime_tools/test/dyntrace_SUITE.erl b/lib/runtime_tools/test/dyntrace_SUITE.erl
index f3c1cce8f8..7be2f49a8b 100644
--- a/lib/runtime_tools/test/dyntrace_SUITE.erl
+++ b/lib/runtime_tools/test/dyntrace_SUITE.erl
@@ -20,26 +20,14 @@
 -module(dyntrace_SUITE).
 -include_lib("common_test/include/ct.hrl").
 
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1,
-	 init_per_group/2,end_per_group/2]).
--export([init_per_testcase/2, end_per_testcase/2]).
+-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1]).
 
 %% Test cases
 -export([smoke/1,process/1]).
 
-%% Default timetrap timeout (set in init_per_testcase)
--define(default_timeout, ?t:minutes(1)).
-
-init_per_testcase(_Case, Config) ->
-    Dog = test_server:timetrap(?default_timeout),
-    [{watchdog,Dog}|Config].
-
-end_per_testcase(_Case, Config) ->
-    Dog = ?config(watchdog, Config),
-    ?t:timetrap_cancel(Dog),
-    ok.
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap, {minutes, 1}}].
 
 all() ->
     case erlang:system_info(dynamic_trace) of
@@ -73,14 +61,8 @@ init_per_suite(Config) ->
 end_per_suite(_Config) ->
     ok.
 
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
 smoke(Config) ->
-    Emu = ?t:lookup_config(emu_name, Config),
+    Emu = test_server:lookup_config(emu_name, Config),
     BinEmu = list_to_binary(Emu),
     case erlang:system_info(dynamic_trace) of
 	dtrace ->
@@ -107,8 +89,7 @@ process(_Config) ->
 	      {probe,"process-hibernate"},
 	      {action,[{printf,["hibernate %s %s\n",{arg,0},{arg,1}]}]},
 	      {probe,"process-exit"},
-	      {action,[{printf,["exit %s %s\n",{arg,0},{arg,1}]}]}
-	     ],
+	      {action,[{printf,["exit %s %s\n",{arg,0},{arg,1}]}]}],
     F = fun() ->
 		{Pid,Ref} = spawn_monitor(fun my_process/0),
 		Pid ! hibernate,
diff --git a/lib/runtime_tools/test/erts_alloc_config_SUITE.erl b/lib/runtime_tools/test/erts_alloc_config_SUITE.erl
index 4fb96a0c1b..6ae51d9a26 100644
--- a/lib/runtime_tools/test/erts_alloc_config_SUITE.erl
+++ b/lib/runtime_tools/test/erts_alloc_config_SUITE.erl
@@ -25,9 +25,7 @@
 -include_lib("common_test/include/ct.hrl").
 
 %-compile(export_all).
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2, 
-	 init_per_testcase/2, end_per_testcase/2]).
+-export([all/0, suite/0, init_per_testcase/2, end_per_testcase/2]).
 
 %% Testcases
 -export([basic/1]).
@@ -35,83 +33,63 @@
 %% internal export
 -export([make_basic_config/1]).
 
--define(DEFAULT_TIMEOUT, ?t:minutes(2)).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap, {minutes, 2}}].
 
 all() -> 
     [basic].
 
-groups() -> 
-    [].
-
-init_per_suite(Config) ->
-    Config.
-
-end_per_suite(_Config) ->
-    ok.
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
 init_per_testcase(Case, Config) when is_list(Config) ->
     [{testcase, Case},
-     {watchdog, ?t:timetrap(?DEFAULT_TIMEOUT)},
      {erl_flags_env, save_env()} | Config].
 
 end_per_testcase(_Case, Config) when is_list(Config) ->
-    ?t:timetrap_cancel(?config(watchdog, Config)),
-    restore_env(?config(erl_flags_env, Config)),
+    restore_env(proplists:get_value(erl_flags_env, Config)),
     ok.
 
 %%%
 %%% The test cases ------------------------------------------------------------
 %%%
 
-basic(doc) -> [];
-basic(suite) -> [];
 basic(Config) when is_list(Config) ->
-    ?line ErtsAllocConfig = privfile("generated", Config),
+    ErtsAllocConfig = privfile("generated", Config),
 
     SbctMod = " +MBsbct 1024 +MHsbct 4096",
 
     %% Make sure we have enabled allocators
     ZFlgs = os:getenv("ERL_ZFLAGS", "") ++ " +Mea max +Mea config",
 
-    ?line os:putenv("ERL_ZFLAGS", ZFlgs ++ SbctMod),
+    os:putenv("ERL_ZFLAGS", ZFlgs ++ SbctMod),
 
-    ?line {ok, Node1} = start_node(Config),
-    ?line ok = rpc:call(Node1, ?MODULE, make_basic_config, [ErtsAllocConfig]),
-    ?line stop_node(Node1),
+    {ok, Node1} = start_node(Config),
+    ok = rpc:call(Node1, ?MODULE, make_basic_config, [ErtsAllocConfig]),
+    stop_node(Node1),
 
-    ?line display_file(ErtsAllocConfig),
+    display_file(ErtsAllocConfig),
 
-    ?line ManualConfig = privfile("manual", Config),
-    ?line {ok, IOD} = file:open(ManualConfig, [write]),
-    ?line io:format(IOD, "~s", ["+MBsbct 2048"]),
-    ?line file:close(IOD),
-    ?line display_file(ManualConfig),
+    ManualConfig = privfile("manual", Config),
+    {ok, IOD} = file:open(ManualConfig, [write]),
+    io:format(IOD, "~s", ["+MBsbct 2048"]),
+    file:close(IOD),
+    display_file(ManualConfig),
 
-    ?line os:putenv("ERL_ZFLAGS", ZFlgs),
+    os:putenv("ERL_ZFLAGS", ZFlgs),
 
-    ?line {ok, Node2} = start_node(Config,
-				   "-args_file " ++ ErtsAllocConfig
-				   ++ " -args_file " ++ ManualConfig),
+    {ok, Node2} = start_node(Config,
+                             "-args_file " ++ ErtsAllocConfig
+                             ++ " -args_file " ++ ManualConfig),
 
-    ?line {_, _, _, Cfg} = rpc:call(Node2, erlang, system_info, [allocator]),
+    {_, _, _, Cfg} = rpc:call(Node2, erlang, system_info, [allocator]),
 
-    ?line stop_node(Node2),
+    stop_node(Node2),
 
-    ?line {value,{binary_alloc, BCfg}} = lists:keysearch(binary_alloc, 1, Cfg),
-    ?line {value,{sbct, 2097152}} = lists:keysearch(sbct, 1, BCfg),
-    ?line {value,{eheap_alloc, HCfg}} = lists:keysearch(eheap_alloc, 1, Cfg),
-    ?line {value,{sbct, 4194304}} = lists:keysearch(sbct, 1, HCfg),
+    {value,{binary_alloc, BCfg}} = lists:keysearch(binary_alloc, 1, Cfg),
+    {value,{sbct, 2097152}} = lists:keysearch(sbct, 1, BCfg),
+    {value,{eheap_alloc, HCfg}} = lists:keysearch(eheap_alloc, 1, Cfg),
+    {value,{sbct, 4194304}} = lists:keysearch(sbct, 1, HCfg),
 
-    ?line ok.
+    ok.
 
 make_basic_config(ErtsAllocConfig) ->
     %% Save some different scenarios
@@ -119,35 +97,35 @@ make_basic_config(ErtsAllocConfig) ->
     SSBegun = make_ref(),
     SSDone = make_ref(),
     SSFun = fun (F) ->
-		    receive
-			SSDone ->
-			    ok = erts_alloc_config:save_scenario(),
-			    Tester ! SSDone
-		    after 500 ->
-			    ok = erts_alloc_config:save_scenario(),
-			    F(F)
-		    end
-	    end,
+                    receive
+                        SSDone ->
+                            ok = erts_alloc_config:save_scenario(),
+                            Tester ! SSDone
+                    after 500 ->
+                              ok = erts_alloc_config:save_scenario(),
+                              F(F)
+                    end
+            end,
     SS = spawn_link(fun () ->
-			    ok = erts_alloc_config:save_scenario(),
-			    Tester ! SSBegun,
-			    SSFun(SSFun)
-		    end),
+                            ok = erts_alloc_config:save_scenario(),
+                            Tester ! SSBegun,
+                            SSFun(SSFun)
+                    end),
     receive SSBegun -> ok end,
     Ref = make_ref(),
     Tab = ets:new(?MODULE, [bag, public]),
     Ps = lists:map(
-	   fun (_) ->
-		   spawn_link(
-		     fun () ->
-			     ets:insert(Tab,
-					{self(),
-					 lists:seq(1, 1000)}),
-			     receive after 1000 -> ok end,
-			     Tester ! {Ref, self()}
-		     end)
-	   end,
-	   lists:seq(1, 10000)),
+           fun (_) ->
+                   spawn_link(
+                     fun () ->
+                             ets:insert(Tab,
+                                        {self(),
+                                         lists:seq(1, 1000)}),
+                             receive after 1000 -> ok end,
+                             Tester ! {Ref, self()}
+                     end)
+           end,
+           lists:seq(1, 10000)),
     lists:foreach(fun (P) -> receive {Ref, P} -> ok end end, Ps),
     ets:delete(Tab),
     SS ! SSDone,
@@ -162,35 +140,35 @@ make_basic_config(ErtsAllocConfig) ->
 %%
 
 display_file(FileName) ->
-    ?t:format("filename: ~s~n", [FileName]),
+    io:format("filename: ~s~n", [FileName]),
     {ok, Bin} = file:read_file(FileName),
     io:format("~s", [binary_to_list(Bin)]),
-    ?t:format("eof: ~s~n", [FileName]),
+    io:format("eof: ~s~n", [FileName]),
     ok.
 
 mk_name(Config) when is_list(Config) ->
     {A, B, C} = now(),
     list_to_atom(atom_to_list(?MODULE)
-		 ++ "-" ++ atom_to_list(?config(testcase, Config))
-		 ++ "-" ++ integer_to_list(A)
-		 ++ "-" ++ integer_to_list(B)
-		 ++ "-" ++ integer_to_list(C)).
+                 ++ "-" ++ atom_to_list(proplists:get_value(testcase, Config))
+                 ++ "-" ++ integer_to_list(A)
+                 ++ "-" ++ integer_to_list(B)
+                 ++ "-" ++ integer_to_list(C)).
 
 start_node(Config) ->
     start_node(Config, "").
 
 start_node(Config, Args) ->
-    ?line Pa = filename:dirname(code:which(?MODULE)),
-    ?line ?t:start_node(mk_name(Config),
-			slave,
-			[{args, "-pa " ++ Pa ++ " " ++ Args}]).
+    Pa = filename:dirname(code:which(?MODULE)),
+    test_server:start_node(mk_name(Config),
+                           slave,
+                           [{args, "-pa " ++ Pa ++ " " ++ Args}]).
 
 stop_node(Node) ->
-    ?line true = ?t:stop_node(Node).
+    true = test_server:stop_node(Node).
 
 privfile(Name, Config) ->
-    filename:join([?config(priv_dir, Config),
-		   atom_to_list(?config(testcase, Config)) ++ "." ++ Name]).
+    filename:join([proplists:get_value(priv_dir, Config),
+                   atom_to_list(proplists:get_value(testcase, Config)) ++ "." ++ Name]).
 
 save_env() ->
     {erl_flags,
@@ -203,15 +181,15 @@ restore_env(EVar, false) when is_list(EVar) ->
     restore_env(EVar, "");
 restore_env(EVar, "") when is_list(EVar) ->
     case os:getenv(EVar) of
-	false -> ok;
-	"" -> ok;
-	" " -> ok;
-	_ -> os:putenv(EVar, " ")
+        false -> ok;
+        "" -> ok;
+        " " -> ok;
+        _ -> os:putenv(EVar, " ")
     end;
 restore_env(EVar, Value) when is_list(EVar), is_list(Value) ->
     case os:getenv(EVar) of
-	Value -> ok;
-	_ -> os:putenv(EVar, Value)
+        Value -> ok;
+        _ -> os:putenv(EVar, Value)
     end.
 
 restore_env({erl_flags, AFlgs, Flgs, RFlgs, ZFlgs}) ->
diff --git a/lib/runtime_tools/test/runtime_tools_SUITE.erl b/lib/runtime_tools/test/runtime_tools_SUITE.erl
index 374d7f6694..6877e1a379 100644
--- a/lib/runtime_tools/test/runtime_tools_SUITE.erl
+++ b/lib/runtime_tools/test/runtime_tools_SUITE.erl
@@ -21,54 +21,27 @@
 -include_lib("common_test/include/ct.hrl").
 
 %% Test server specific exports
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2]).
--export([init_per_testcase/2, end_per_testcase/2]).
+-export([all/0, suite/0]).
 
 %% Test cases
 -export([app_file/1, appup_file/1, start_stop_app/1]).
 
-%% Default timetrap timeout (set in init_per_testcase)
--define(default_timeout, ?t:minutes(1)).
-
-init_per_testcase(_Case, Config) ->
-    Dog = test_server:timetrap(?default_timeout),
-    [{watchdog, Dog} | Config].
-
-end_per_testcase(_Case, Config) ->
-    Dog = ?config(watchdog, Config),
-    ?t:timetrap_cancel(Dog),
-    ok.
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap, {minutes, 1}}].
 
 all() -> 
     [app_file,
      appup_file,
      start_stop_app].
 
-groups() -> 
-    [].
-
-init_per_suite(Config) ->
-    Config.
-
-end_per_suite(_Config) ->
-    ok.
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
 
 app_file(_Config) ->
-    ?line ok = ?t:app_test(runtime_tools),
+    ok = test_server:app_test(runtime_tools),
     ok.
 
 appup_file(_Config) ->
-    ok = ?t:appup_test(runtime_tools).
+    ok = test_server:appup_test(runtime_tools).
 
 start_stop_app(_Config) ->
     ok = application:start(runtime_tools),
diff --git a/lib/runtime_tools/test/system_information_SUITE.erl b/lib/runtime_tools/test/system_information_SUITE.erl
index 5e2e0d17ac..a5a025a1cf 100644
--- a/lib/runtime_tools/test/system_information_SUITE.erl
+++ b/lib/runtime_tools/test/system_information_SUITE.erl
@@ -230,19 +230,19 @@ api_report(_Config) ->
     ok.
 
 api_to_file(Config) ->
-    DataDir  = ?config(data_dir, Config),
+    DataDir  = proplists:get_value(data_dir, Config),
     Filename = filename:join([DataDir, "system_information_report_1.dat"]),
     ok      = system_information:to_file(Filename),
     {ok, _} = file:consult(Filename),
     {save_config, [{report_name, Filename}]}.
 
 api_from_file(Config) ->
-    {api_to_file, Saved} = ?config(saved_config, Config),
-    DataDir = ?config(data_dir, Config),
+    {api_to_file, Saved} = proplists:get_value(saved_config, Config),
+    DataDir = proplists:get_value(data_dir, Config),
     Fname1  = filename:join([DataDir, "information_test_report.dat"]),
     Report1 = system_information:from_file(Fname1),
     ok      = validate_report(Report1),
-    Fname2  = ?config(report_name, Saved),
+    Fname2  = proplists:get_value(report_name, Saved),
     Report2 = system_information:from_file(Fname2),
     ok      = validate_report(Report2),
     ok.
@@ -253,7 +253,7 @@ api_start_stop(_Config) ->
     ok.
 
 validate_server_interface(Config) ->
-    DataDir = ?config(data_dir, Config),
+    DataDir = proplists:get_value(data_dir, Config),
     Fname1  = filename:join([DataDir, "information_test_report.dat"]),
     %% load old report
     ok = system_information:load_report(file, Fname1),