File 1693-emulator-replace-test_server-start-node-wi... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1693-emulator-replace-test_server-start-node-with-CT_PEER.patch of Package erlang (Revision 3e585b5159e575cdaf8b197320891957)

Currently displaying revision 3e585b5159e575cdaf8b197320891957 , Show latest

From e2adc35ede8c48293511616c0db8582988b456db Mon Sep 17 00:00:00 2001
From: Maxim Fedorov <maximfca@gmail.com>
Date: Fri, 17 Sep 2021 17:48:40 -0700
Subject: [PATCH 3/7] emulator: replace test_server:start node with ?CT_PEER

Cleanup emulator application, sweep duplicate code that
was adding code path to the test suite module, make peer
node naming uniform, protect from rogue nodes left when
test case fails.
---
 erts/emulator/test/alloc_SUITE.erl            | 171 ++---
 erts/emulator/test/bif_SUITE.erl              |  38 +-
 erts/emulator/test/binary_SUITE.erl           |  27 +-
 erts/emulator/test/code_SUITE.erl             |   4 +-
 erts/emulator/test/dirty_bif_SUITE.erl        |  37 +-
 erts/emulator/test/dirty_nif_SUITE.erl        |  41 +-
 erts/emulator/test/distribution_SUITE.erl     | 615 ++++++------------
 .../test/distribution_SUITE_data/run.erl      |   2 +-
 erts/emulator/test/driver_SUITE.erl           | 127 +---
 erts/emulator/test/dump_SUITE.erl             |  20 +-
 erts/emulator/test/efile_SUITE.erl            |   6 +-
 erts/emulator/test/erl_link_SUITE.erl         | 105 +--
 erts/emulator/test/erts_debug_SUITE.erl       |  18 +-
 erts/emulator/test/exception_SUITE.erl        |   4 +-
 erts/emulator/test/float_SUITE.erl            |  19 +-
 erts/emulator/test/fun_SUITE.erl              |  16 +-
 erts/emulator/test/hash_SUITE.erl             |  34 +-
 .../test/hash_property_test_SUITE.erl         |  28 +-
 erts/emulator/test/list_bif_SUITE.erl         |   4 +-
 erts/emulator/test/lttng_SUITE.erl            |  22 +-
 erts/emulator/test/map_SUITE.erl              |   6 +-
 erts/emulator/test/match_spec_SUITE.erl       |  21 +-
 .../test/message_queue_data_SUITE.erl         |  22 +-
 erts/emulator/test/monitor_SUITE.erl          |  74 +--
 erts/emulator/test/node_container_SUITE.erl   |  52 +-
 erts/emulator/test/persistent_term_SUITE.erl  |   4 +-
 erts/emulator/test/port_SUITE.erl             |  24 +-
 erts/emulator/test/process_SUITE.erl          | 271 ++++----
 erts/emulator/test/ref_SUITE.erl              |  26 +-
 erts/emulator/test/scheduler_SUITE.erl        | 278 ++++----
 erts/emulator/test/send_term_SUITE.erl        |  13 +-
 erts/emulator/test/signal_SUITE.erl           |  20 +-
 erts/emulator/test/smoke_test_SUITE.erl       | 161 ++---
 erts/emulator/test/system_info_SUITE.erl      |  76 +--
 erts/emulator/test/time_SUITE.erl             |  52 +-
 erts/emulator/test/timer_bif_SUITE.erl        |  27 +-
 erts/emulator/test/trace_SUITE.erl            |  27 +-
 erts/emulator/test/unique_SUITE.erl           |  23 +-
 38 files changed, 817 insertions(+), 1698 deletions(-)

diff --git a/erts/emulator/test/alloc_SUITE.erl b/erts/emulator/test/alloc_SUITE.erl
index ebc60b3cc2..e0548b9412 100644
--- a/erts/emulator/test/alloc_SUITE.erl
+++ b/erts/emulator/test/alloc_SUITE.erl
@@ -35,6 +35,9 @@
 	 migration/1,
          cpool_opt/1]).
 
+%% Internal export
+-export([run_drv_case/2]).
+
 -include_lib("common_test/include/ct.hrl").
 
 suite() ->
@@ -60,7 +63,7 @@ end_per_suite(_Config) ->
     ok.
 
 init_per_testcase(Case, Config) when is_list(Config) ->
-    [{testcase, Case},{debug,false}|Config].
+    [{testcase, Case}|Config].
 
 end_per_testcase(_Case, Config) when is_list(Config) ->
     ok.
@@ -84,47 +87,41 @@ migration(Cfg) ->
     %% Enable test_alloc.
     %% Disable driver_alloc to avoid recursive alloc_util calls
     %% through enif_mutex_create() in my_creating_mbc().
-    drv_case(Cfg, concurrent, "+MZe true +MRe false"),
-    drv_case(Cfg, concurrent, "+MZe true +MRe false +MZas ageffcbf"),
-    drv_case(Cfg, concurrent, "+MZe true +MRe false +MZas chaosff").
+    drv_case(Cfg, concurrent, ["+MZe", "true", "+MRe", "false"]),
+    drv_case(Cfg, concurrent, ["+MZe", "true", "+MRe", "false", "+MZas", "ageffcbf"]),
+    drv_case(Cfg, concurrent, ["+MZe", "true", "+MRe", "false", "+MZas", "chaosff"]).
 
 cpool_opt(Config) when is_list(Config) ->
-    OldEnv = clear_env(),
-    try
-        {ok, NodeA} = start_node(Config, "+Mue true +Mut true +Muacul de +Mucp @", []),
-        {cp, '@'} = get_cp_opt(NodeA, binary_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, std_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, ets_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, fix_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, eheap_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, ll_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, driver_alloc),
-        {cp, '@'} = get_cp_opt(NodeA, sl_alloc),
-        stop_node(NodeA),
-        {ok, NodeB} = start_node(Config, "+Mue true +Mut true +Muacul de +Mucp :", []),
-        {cp, 'B'} = get_cp_opt(NodeB, binary_alloc),
-        {cp, 'D'} = get_cp_opt(NodeB, std_alloc),
-        {cp, 'E'} = get_cp_opt(NodeB, ets_alloc),
-        {cp, 'F'} = get_cp_opt(NodeB, fix_alloc),
-        {cp, 'H'} = get_cp_opt(NodeB, eheap_alloc),
-        {cp, 'L'} = get_cp_opt(NodeB, ll_alloc),
-        {cp, 'R'} = get_cp_opt(NodeB, driver_alloc),
-        {cp, 'S'} = get_cp_opt(NodeB, sl_alloc),
-        stop_node(NodeB),
-        {ok, NodeC} = start_node(Config, "+Mue true +Mut true +Muacul de +Mucp : +MEcp H", []),
-        {cp, 'B'} = get_cp_opt(NodeC, binary_alloc),
-        {cp, 'D'} = get_cp_opt(NodeC, std_alloc),
-        {cp, 'H'} = get_cp_opt(NodeC, ets_alloc),
-        {cp, 'F'} = get_cp_opt(NodeC, fix_alloc),
-        {cp, 'H'} = get_cp_opt(NodeC, eheap_alloc),
-        {cp, 'L'} = get_cp_opt(NodeC, ll_alloc),
-        {cp, 'R'} = get_cp_opt(NodeC, driver_alloc),
-        {cp, 'S'} = get_cp_opt(NodeC, sl_alloc),
-        stop_node(NodeC)
-    after
-        restore_env(OldEnv)
-    end,
-    ok.
+    {ok, PeerA, NodeA} = ?CT_PEER(["+Mue", "true", "+Mut", "true", "+Muacul", "de", "+Mucp", "@"]),
+    {cp, '@'} = get_cp_opt(NodeA, binary_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, std_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, ets_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, fix_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, eheap_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, ll_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, driver_alloc),
+    {cp, '@'} = get_cp_opt(NodeA, sl_alloc),
+    peer:stop(PeerA),
+    {ok, PeerB, NodeB} = ?CT_PEER(["+Mue", "true", "+Mut", "true", "+Muacul", "de", "+Mucp", ":"]),
+    {cp, 'B'} = get_cp_opt(NodeB, binary_alloc),
+    {cp, 'D'} = get_cp_opt(NodeB, std_alloc),
+    {cp, 'E'} = get_cp_opt(NodeB, ets_alloc),
+    {cp, 'F'} = get_cp_opt(NodeB, fix_alloc),
+    {cp, 'H'} = get_cp_opt(NodeB, eheap_alloc),
+    {cp, 'L'} = get_cp_opt(NodeB, ll_alloc),
+    {cp, 'R'} = get_cp_opt(NodeB, driver_alloc),
+    {cp, 'S'} = get_cp_opt(NodeB, sl_alloc),
+    peer:stop(PeerB),
+    {ok, PeerC, NodeC} = ?CT_PEER(["+Mue", "true", "+Mut", "true", "+Muacul", "de", "+Mucp", ":", "+MEcp", "H"]),
+    {cp, 'B'} = get_cp_opt(NodeC, binary_alloc),
+    {cp, 'D'} = get_cp_opt(NodeC, std_alloc),
+    {cp, 'H'} = get_cp_opt(NodeC, ets_alloc),
+    {cp, 'F'} = get_cp_opt(NodeC, fix_alloc),
+    {cp, 'H'} = get_cp_opt(NodeC, eheap_alloc),
+    {cp, 'L'} = get_cp_opt(NodeC, ll_alloc),
+    {cp, 'R'} = get_cp_opt(NodeC, driver_alloc),
+    {cp, 'S'} = get_cp_opt(NodeC, sl_alloc),
+    peer:stop(PeerC).
 
 get_cp_opt(Node, Alloc) ->
     AInfo = rpc:call(Node, erlang, system_info, [{allocator,Alloc}]),
@@ -136,7 +133,7 @@ get_cp_opt(Node, Alloc) ->
 erts_mmap(Config) when is_list(Config) ->
     case {os:type(), mmsc_flags()} of
 	{{unix,_}, false} ->
-	    [erts_mmap_do(Config, SCO, SCRPM, SCRFSD)
+	    [erts_mmap_do(SCO, SCRPM, SCRFSD)
 	     || SCO <-[true,false], SCRFSD <-[1234,0], SCRPM <- [true,false]];
 	{{unix,_}, Flags} ->
 	    {skipped, Flags};
@@ -162,23 +159,21 @@ mmsc_flags(Env) ->
             end
     end.
 
-erts_mmap_do(Config, SCO, SCRPM, SCRFSD) ->
+erts_mmap_do(SCO, SCRPM, SCRFSD) ->
     %% We use the number of schedulers + 1 * approx main carriers size
     %% to calculate how large the super carrier has to be
     %% and then use a minimum of 100 for systems with a low amount of
     %% schedulers
     Schldr = erlang:system_info(schedulers_online)+1,
     SCS = max(round((262144 * 6 + 3 * 1048576) * Schldr / 1024 / 1024),100),
-    O1 = "+MMscs" ++ integer_to_list(SCS)
-	++ " +MMsco" ++ atom_to_list(SCO)
-	++ " +MMscrpm" ++ atom_to_list(SCRPM),
+    O1 = ["+MMscs" ++ integer_to_list(SCS),
+	"+MMsco" ++ atom_to_list(SCO),
+	"+MMscrpm" ++ atom_to_list(SCRPM)],
     Opts = case SCRFSD of
 	       0 -> O1;
-	       _ -> O1 ++ " +MMscrfsd"++integer_to_list(SCRFSD)
+	       _ -> O1 ++ ["+MMscrfsd"++integer_to_list(SCRFSD)]
 	   end,
-    {ok, Node} = start_node(Config, Opts, []),
-    Self = self(),
-    Ref = make_ref(),
+    {ok, Peer, Node} = ?CT_PEER(Opts),
     F = fun() ->
                 SI = erlang:system_info({allocator,erts_mmap}),
                 {default_mmap,EM} = lists:keyfind(default_mmap, 1, SI),
@@ -202,7 +197,7 @@ erts_mmap_do(Config, SCO, SCRPM, SCRFSD) ->
 
     {Pid, MRef} = spawn_monitor(Node, F),
     Result = receive {'DOWN', MRef, process, Pid, Rslt} -> Rslt end,
-    stop_node(Node),
+    peer:stop(Peer),
     Result.
 
 
@@ -293,18 +288,11 @@ drv_case(Config) ->
 drv_case(Config, Mode, NodeOpts) when is_list(Config) ->
     case os:type() of
 	{Family, _} when Family == unix; Family == win32 ->
-            %%Prog = {prog,"/my/own/otp/bin/cerl -debug"},
-            Prog = [],
-	    {ok, Node} = start_node(Config, NodeOpts, Prog),
-	    Self = self(),
-	    Ref = make_ref(),
-	    spawn_link(Node,
-			     fun () ->
-				     Res = run_drv_case(Config, Mode),
-				     Self ! {Ref, Res}
-			     end),
-	    Result = receive {Ref, Rslt} -> Rslt end,
-	    stop_node(Node),
+            %% ?CT_PEER(#{exec => {"/usr/local/bin/erl", ["-emu_type", "debug"]}})
+            TC = proplists:get_value(testcase, Config),
+	    {ok, Peer, Node} = ?CT_PEER(#{name => ?CT_PEER_NAME(TC), args => NodeOpts}),
+            Result = erpc:call(Node, ?MODULE, run_drv_case, [Config, Mode]),
+	    peer:stop(Peer),
 	    Result;
 	SkipOs ->
 	    {skipped,
@@ -493,31 +481,6 @@ handle_result(_State, Result0) ->
 	    continue
     end.
 
-start_node(Config, Opts, Prog) when is_list(Config), is_list(Opts) ->
-    case proplists:get_value(debug,Config) of
-	true -> {ok, node()};
-	_ -> start_node_1(Config, Opts, Prog)
-    end.
-
-start_node_1(Config, Opts, Prog) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-"
-			++ integer_to_list(erlang:system_time(second))
-			++ "-"
-			++ integer_to_list(erlang:unique_integer([positive]))),
-    ErlArg = case Prog of
-                 [] -> [];
-                 _ -> [{erl,[Prog]}]
-             end,
-    test_server:start_node(Name, slave, [{args, Opts++" -pa "++Pa} | ErlArg]).
-
-stop_node(Node) when Node =:= node() -> ok;
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 free_memory() ->
     %% Free memory in MB.
     try
@@ -538,39 +501,5 @@ free_memory() ->
 	    ct:fail({"os_mon not built"})
     end.
 
-clear_env() ->
-    ErlRelFlagsName =
-        "ERL_OTP"
-        ++ erlang:system_info(otp_release)
-        ++ "_FLAGS",
-    ErlFlags = os:getenv("ERL_FLAGS"),
-    os:unsetenv("ERL_FLAGS"),
-    ErlAFlags = os:getenv("ERL_AFLAGS"),
-    os:unsetenv("ERL_AFLAGS"),
-    ErlZFlags = os:getenv("ERL_ZFLAGS"),
-    os:unsetenv("ERL_ZFLAGS"),
-    ErlRelFlags = os:getenv(ErlRelFlagsName),
-    os:unsetenv(ErlRelFlagsName),
-    {ErlFlags, ErlAFlags, ErlZFlags, ErlRelFlags}.
-
-restore_env({ErlFlags, ErlAFlags, ErlZFlags, ErlRelFlags}) ->
-    if ErlFlags == false -> ok;
-       true -> os:putenv("ERL_FLAGS", ErlFlags)
-    end,
-    if ErlAFlags == false -> ok;
-       true -> os:putenv("ERL_AFLAGS", ErlAFlags)
-    end,
-    if ErlZFlags == false -> ok;
-       true -> os:putenv("ERL_ZFLAGS", ErlZFlags)
-    end,
-    if ErlRelFlags == false -> ok;
-       true ->
-            ErlRelFlagsName =
-                "ERL_OTP"
-                ++ erlang:system_info(otp_release)
-                ++ "_FLAGS",
-            os:putenv(ErlRelFlagsName, ErlRelFlags)
-    end,
-    ok.
 
 
diff --git a/erts/emulator/test/bif_SUITE.erl b/erts/emulator/test/bif_SUITE.erl
index 5923038eb6..344476dc6c 100644
--- a/erts/emulator/test/bif_SUITE.erl
+++ b/erts/emulator/test/bif_SUITE.erl
@@ -85,11 +85,9 @@ skip_missing_erl_bif_types(Config) ->
 
 %% Uses erlang:display to test that erts_printf does not do deep recursion
 display(Config) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    {ok, Node} = test_server:start_node(display_huge_term,peer,
-					[{args, "-pa \""++Pa++"\""}]),
+    {ok, Peer, Node} = ?CT_PEER(),
     true = rpc:call(Node,?MODULE,display_huge,[]),
-    test_server:stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 display_huge() ->
@@ -777,33 +775,32 @@ erlang_halt(Config) when is_list(Config) ->
     try halt(0, [{flush,true,undefined}]) of
 	_-> ct:fail({halt,{0,[{flush,true,undefined}]}})
     catch error:badarg -> ok end,
-    H = hostname(),
-    {ok,N1} = slave:start(H, halt_node1),
+    {ok, _, N1} = ?CT_PEER(),
     {badrpc,nodedown} = rpc:call(N1, erlang, halt, []),
-    {ok,N2} = slave:start(H, halt_node2),
+    {ok, _, N2} = ?CT_PEER(),
     {badrpc,nodedown} = rpc:call(N2, erlang, halt, [0]),
-    {ok,N3} = slave:start(H, halt_node3),
+    {ok, _, N3} = ?CT_PEER(),
     {badrpc,nodedown} = rpc:call(N3, erlang, halt, [0,[]]),
-    {ok,N4} = slave:start(H, halt_node4),
+    {ok, _, N4} = ?CT_PEER(),
     {badrpc,nodedown} = rpc:call(N4, erlang, halt, [lists:duplicate(300,$x)]),
     %% Test unicode slogan
-    {ok,N4} = slave:start(H, halt_node4),
-    {badrpc,nodedown} = rpc:call(N4, erlang, halt, [[339,338,254,230,198,295,167,223,32,12507,12531,12480]]),
+    {ok, _, N5} = ?CT_PEER(),
+    {badrpc,nodedown} = rpc:call(N5, erlang, halt, [[339,338,254,230,198,295,167,223,32,12507,12531,12480]]),
 
     % This test triggers a segfault when dumping a crash dump
     % to make sure that we can handle it properly.
 
     %% Prevent address sanitizer from catching SEGV in slave node
     AsanOpts = add_asan_opt("handle_segv=0"),
-    {ok,N4} = slave:start(H, halt_node4),
+    {ok, _, N6} = ?CT_PEER(),
     reset_asan_opts(AsanOpts),
 
     CrashDump = filename:join(proplists:get_value(priv_dir,Config),
                               "segfault_erl_crash.dump"),
-    true = rpc:call(N4, os, putenv, ["ERL_CRASH_DUMP",CrashDump]),
-    false = rpc:call(N4, erts_debug, set_internal_state,
+    true = rpc:call(N6, os, putenv, ["ERL_CRASH_DUMP",CrashDump]),
+    false = rpc:call(N6, erts_debug, set_internal_state,
                      [available_internal_state, true]),
-    {badrpc,nodedown} = rpc:call(N4, erts_debug, set_internal_state,
+    {badrpc,nodedown} = rpc:call(N6, erts_debug, set_internal_state,
                                  [broken_halt, "Validate correct crash dump"]),
     {ok,_} = wait_until_stable_size(CrashDump,-1),
     {ok, Bin} = file:read_file(CrashDump),
@@ -860,8 +857,7 @@ erl_crash_dump_bytes(Config) when is_list(Config) ->
     ok.
 
 do_limited_crash_dump(Config, Bytes) ->
-    H = hostname(),
-    {ok,N} = slave:start(H, halt_node),
+    {ok, _, N} = ?CT_PEER(),
     BytesStr = integer_to_list(Bytes),
     CrashDump = filename:join(proplists:get_value(priv_dir,Config),
                               "erl_crash." ++ BytesStr ++ ".dump"),
@@ -1432,14 +1428,6 @@ extract_abstract(Mod, Path) ->
     {Mod,Abstr}.
 
 
-hostname() ->
-    hostname(atom_to_list(node())).
-
-hostname([$@ | Hostname]) ->
-    list_to_atom(Hostname);
-hostname([_C | Cs]) ->
-    hostname(Cs).
-
 tok_loop() ->
     tok_loop(hej).
 
diff --git a/erts/emulator/test/binary_SUITE.erl b/erts/emulator/test/binary_SUITE.erl
index fe0e968f63..a22ff6518f 100644
--- a/erts/emulator/test/binary_SUITE.erl
+++ b/erts/emulator/test/binary_SUITE.erl
@@ -495,9 +495,9 @@ do_t2b_system_limit() ->
                 garbage_collect(),
                 ok
         end,
-    Opts = [{args, "-pa " ++ filename:dirname(code:which(?MODULE))}],
-    {ok,Node} = test_server:start_node(?FUNCTION_NAME, slave, Opts),
-    erpc:call(Node, F).
+    {ok, Peer, Node} = ?CT_PEER(),
+    erpc:call(Node, F),
+    peer:stop(Peer).
 
 test_t2b_system_limit(HugeBin, Name, F1, F2) ->
     io:format("Testing ~p(HugeBin)~n", [Name]),
@@ -1059,7 +1059,7 @@ run_when_enough_resources(Fun) ->
 
 %% OTP-4053
 bad_binary_to_term_2(Config) when is_list(Config) ->
-    {ok, N} = test_server:start_node(plopp, slave, []),
+    {ok, Peer, N} = ?CT_PEER(),
     R = rpc:call(N, erlang, binary_to_term, [<<131,111,255,255,255,0>>]),
     case R of
 	      {badrpc, {'EXIT', _}} ->
@@ -1067,7 +1067,7 @@ bad_binary_to_term_2(Config) when is_list(Config) ->
 	      _Other ->
 		  ct:fail({rpcresult, R})
 	  end,
-    test_server:stop_node(N),
+    peer:stop(Peer),
     ok.
 
 %% Try bad input to binary_to_term/1.
@@ -1945,18 +1945,11 @@ cmp_old_impl(Config) when is_list(Config) ->
     %% implementation in R16B. Since OTP 22 we can't talk distribution with such
     %% old nodes (< 19). The test case it kept but compares with previous major
     %% version for semantic regression test.
-    Cookie = atom_to_list(erlang:get_cookie()),
-    Rel = (integer_to_list(list_to_integer(erlang:system_info(otp_release)) - 1)
-           ++ "_latest"),
-    case test_server:is_release_available(Rel) of
-	false ->
+    Rel = integer_to_list(list_to_integer(erlang:system_info(otp_release)) - 1),
+    case ?CT_PEER([], Rel, proplists:get_value(priv_dir, Config)) of
+	not_available ->
 	    {skipped, "No OTP "++Rel++" available"};
-	true ->
-	    {ok, Node} = test_server:start_node(list_to_atom(atom_to_list(?MODULE)++"_"++Rel),
-				       peer,
-				       [{args, " -setcookie "++Cookie},
-					{erl, [{release, Rel}]}]),
-
+        {ok, Peer, Node}  ->
 	    cmp_node(Node, {erlang, list_to_binary, [list2iolist(mk_list(1))]}),
 	    cmp_node(Node, {erlang, list_to_binary, [list2iolist(mk_list(10))]}),
 	    cmp_node(Node, {erlang, list_to_binary, [list2iolist(mk_list(100))]}),
@@ -1994,7 +1987,7 @@ cmp_old_impl(Config) when is_list(Config) ->
 	    cmp_node(Node, {erlang, bitstring_to_list, [list_to_bitstring(list2bitstrlist(mk_list(1000000)))]}),
 	    cmp_node(Node, {erlang, bitstring_to_list, [list_to_bitstring(list2bitstrlist(mk_list(10000000)))]}),
 
-	    test_server:stop_node(Node),
+	    peer:stop(Peer),
 
 	    ok
     end.
diff --git a/erts/emulator/test/code_SUITE.erl b/erts/emulator/test/code_SUITE.erl
index 0eceea8dcf..e0cea2d7e2 100644
--- a/erts/emulator/test/code_SUITE.erl
+++ b/erts/emulator/test/code_SUITE.erl
@@ -727,11 +727,11 @@ verify_lit_terms([], _) ->
     ok.
 
 get_external_terms() ->
-    {ok,Node} =	test_server:start_node(?FUNCTION_NAME, slave, []),
+    {ok, Peer, Node}= ?CT_PEER(),
     Ref = rpc:call(Node, erlang, make_ref, []),
     Ports = rpc:call(Node, erlang, ports, []),
     Pid = rpc:call(Node, erlang, self, []),
-    _ = test_server:stop_node(Node),
+    peer:stop(Peer),
     {Ref,hd(Ports),Pid}.
 
 %% OTP-7559: c_p->cp could contain garbage and create a false dependency
diff --git a/erts/emulator/test/dirty_bif_SUITE.erl b/erts/emulator/test/dirty_bif_SUITE.erl
index f8819b4793..5436930737 100644
--- a/erts/emulator/test/dirty_bif_SUITE.erl
+++ b/erts/emulator/test/dirty_bif_SUITE.erl
@@ -216,7 +216,7 @@ dirty_bif_multischedule_exception(Config) when is_list(Config) ->
     end.
 
 dirty_scheduler_exit(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config, "+SDio 1"),
+    {ok, Peer, Node} = ?CT_PEER(["+SDio", "1"]),
     [ok] = mcall(Node,
                  [fun() ->
                           %% Perform a dry run to ensure that all required code
@@ -230,7 +230,7 @@ dirty_scheduler_exit(Config) when is_list(Config) ->
 			  io:format("Time=~p ms~n", [End-Start]),
 			  ok
                   end]),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 test_dirty_scheduler_exit() ->
@@ -315,7 +315,7 @@ dirty_call_while_terminated(Config) when is_list(Config) ->
     end.
 
 dirty_heap_access(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     Me = self(),
     RGL = rpc:call(Node,erlang,whereis,[init]),
     Ref = rpc:call(Node,erlang,make_ref,[]),
@@ -333,7 +333,7 @@ dirty_heap_access(Config) when is_list(Config) ->
     end,
     unlink(Dirty),
     exit(Dirty, kill),
-    stop_node(Node),
+    peer:stop(Peer),
     {comment, integer_to_list(N) ++ " GL change loops; "
      ++ integer_to_list(R) ++ " while running dirty"}.
 
@@ -369,7 +369,7 @@ access_dirty_heap(Dirty, RGL, N, R) ->
 %% the dirty process is still alive immediately after accessing it.
 dirty_process_info(Config) when is_list(Config) ->
     access_dirty_process(
-      Config,
+      ?FUNCTION_NAME,
       fun() -> ok end,
       fun(BifPid) ->
 	      PI = process_info(BifPid),
@@ -381,7 +381,7 @@ dirty_process_info(Config) when is_list(Config) ->
 
 dirty_process_register(Config) when is_list(Config) ->
     access_dirty_process(
-      Config,
+      ?FUNCTION_NAME,
       fun() -> ok end,
       fun(BifPid) ->
 	      register(test_dirty_process_register, BifPid),
@@ -395,7 +395,7 @@ dirty_process_register(Config) when is_list(Config) ->
 
 dirty_process_trace(Config) when is_list(Config) ->
     access_dirty_process(
-      Config,
+      ?FUNCTION_NAME,
       fun() ->
 	      %% BIFs can only be traced when their modules are loaded.
 	      code:ensure_loaded(erts_debug),
@@ -554,13 +554,13 @@ wait_until(Fun) ->
             wait_until(Fun)
     end.
 
-access_dirty_process(Config, Start, Test, Finish) ->
-    {ok, Node} = start_node(Config, ""),
+access_dirty_process(TestCase, Start, Test, Finish) ->
+    {ok, Peer, Node} = ?CT_PEER(#{name => ?CT_PEER_NAME(TestCase)}),
     [ok] = mcall(Node,
 		 [fun() ->
 			  ok = test_dirty_process_access(Start, Test, Finish)
 		  end]),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 test_dirty_process_access(Start, Test, Finish) ->
@@ -586,23 +586,6 @@ test_dirty_process_access(Start, Test, Finish) ->
 	 end,
     ok = Finish(BifPid).
 
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-"
-			++ integer_to_list(erlang:system_time(second))
-			++ "-"
-			++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 mcall(Node, Funs) ->
     Parent = self(),
     Refs = lists:map(fun (Fun) ->
diff --git a/erts/emulator/test/dirty_nif_SUITE.erl b/erts/emulator/test/dirty_nif_SUITE.erl
index fc4c9a514a..a84af67ce7 100644
--- a/erts/emulator/test/dirty_nif_SUITE.erl
+++ b/erts/emulator/test/dirty_nif_SUITE.erl
@@ -144,7 +144,7 @@ nif_raise_exceptions(NifFunc) ->
                 end, ok, ExcTerms).
 
 dirty_scheduler_exit(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config, "+SDio 1"),
+    {ok, Peer, Node} = ?CT_PEER(["+SDio", "1"]),
     Path = proplists:get_value(data_dir, Config),
     NifLib = filename:join(Path, atom_to_list(?MODULE)),
     [ok] = mcall(Node,
@@ -161,7 +161,7 @@ dirty_scheduler_exit(Config) when is_list(Config) ->
 			  io:format("Time=~p ms~n", [End-Start]),
 			  ok
                   end]),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 test_dirty_scheduler_exit() ->
@@ -249,7 +249,7 @@ dirty_call_while_terminated(Config) when is_list(Config) ->
     end.
 
 dirty_heap_access(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     Me = self(),
     RGL = rpc:call(Node,erlang,whereis,[init]),
     Ref = rpc:call(Node,erlang,make_ref,[]),
@@ -267,7 +267,7 @@ dirty_heap_access(Config) when is_list(Config) ->
     end,
     unlink(Dirty),
     exit(Dirty, kill),
-    stop_node(Node),
+    peer:stop(Peer),
     {comment, integer_to_list(N) ++ " GL change loops; "
      ++ integer_to_list(R) ++ " while running dirty"}.
 
@@ -303,7 +303,8 @@ access_dirty_heap(Dirty, RGL, N, R) ->
 %% the dirty process is still alive immediately after accessing it.
 dirty_process_info(Config) when is_list(Config) ->
     access_dirty_process(
-      Config,
+      ?FUNCTION_NAME,
+      ?config(data_dir, Config),
       fun() -> ok end,
       fun(NifPid) ->
 	      PI = process_info(NifPid),
@@ -315,7 +316,8 @@ dirty_process_info(Config) when is_list(Config) ->
 
 dirty_process_register(Config) when is_list(Config) ->
     access_dirty_process(
-      Config,
+      ?FUNCTION_NAME,
+      ?config(data_dir, Config),
       fun() -> ok end,
       fun(NifPid) ->
 	      register(test_dirty_process_register, NifPid),
@@ -329,7 +331,8 @@ dirty_process_register(Config) when is_list(Config) ->
 
 dirty_process_trace(Config) when is_list(Config) ->
     access_dirty_process(
-      Config,
+      ?FUNCTION_NAME,
+      ?config(data_dir, Config),
       fun() ->
 	      erlang:trace_pattern({?MODULE,dirty_sleeper,1},
 				   [{'_',[],[{return_trace}]}],
@@ -537,16 +540,15 @@ literal_area(Config) when is_list(Config) ->
 %% Internal...
 %%
 
-access_dirty_process(Config, Start, Test, Finish) ->
-    {ok, Node} = start_node(Config, ""),
+access_dirty_process(TestCase, Path, Start, Test, Finish) ->
+    {ok, Peer, Node} = ?CT_PEER(#{name => ?CT_PEER_NAME(TestCase)}),
     [ok] = mcall(Node,
 		 [fun() ->
-                          Path = ?config(data_dir, Config),
                           Lib = atom_to_list(?MODULE),
                           ok = erlang:load_nif(filename:join(Path,Lib), []),
 			  ok = test_dirty_process_access(Start, Test, Finish)
 		  end]),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 test_dirty_process_access(Start, Test, Finish) ->
@@ -575,23 +577,6 @@ test_dirty_process_access(Start, Test, Finish) ->
 receive_any() ->
     receive M -> M end.
 
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-"
-			++ integer_to_list(erlang:system_time(second))
-			++ "-"
-			++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 mcall(Node, Funs) ->
     Parent = self(),
     Refs = lists:map(fun (Fun) ->
diff --git a/erts/emulator/test/distribution_SUITE.erl b/erts/emulator/test/distribution_SUITE.erl
index a24d7ddace..026eaf0f20 100644
--- a/erts/emulator/test/distribution_SUITE.erl
+++ b/erts/emulator/test/distribution_SUITE.erl
@@ -34,9 +34,6 @@
 
 -include_lib("common_test/include/ct.hrl").
 
-%-define(Line, erlang:display({line,?LINE}),).
--define(Line,).
-
 -export([all/0, suite/0, groups/0,
          init_per_suite/1, end_per_suite/1,
          init_per_group/2, end_per_group/2,
@@ -82,7 +79,7 @@
 -export([sender/3, receiver2/2, dummy_waiter/0, dead_process/0,
          group_leader_1/1,
          optimistic_dflags_echo/0, optimistic_dflags_sender/1,
-         roundtrip/1, bounce/1, do_dist_auto_connect/1, inet_rpc_server/1,
+         roundtrip/1, bounce/1,
          dist_parallel_sender/3, dist_parallel_receiver/0,
          derr_run/1,
          dist_evil_parallel_receiver/0, make_busy/2]).
@@ -168,10 +165,10 @@ ping(Config) when is_list(Config) ->
 
     %% Pings another node.
 
-    {ok, OtherNode} = start_node(distribution_SUITE_other),
+    {ok, Peer, OtherNode} = ?CT_PEER(),
     io:format("Pinging ~s (assumed to exist)", [OtherNode]),
     test_server:do_times(Times, fun() -> pong = net_adm:ping(OtherNode) end),
-    stop_node(OtherNode),
+    peer_stop(Peer, OtherNode),
 
     %% Pings our own node many times.
 
@@ -183,54 +180,44 @@ ping(Config) when is_list(Config) ->
 
 %% Test erlang:group_leader(_, ExternalPid), i.e. DOP_GROUP_LEADER
 group_leader(Config) when is_list(Config) ->
-    ?Line Sock = start_relay_node(group_leader_1, []),
-    ?Line Sock2 = start_relay_node(group_leader_2, []),
-    try
-        ?Line Node2 = inet_rpc_nodename(Sock2),
-        ?Line {ok, ok} = do_inet_rpc(Sock, ?MODULE, group_leader_1, [Node2])
-    after
-        ?Line stop_relay_node(Sock),
-        ?Line stop_relay_node(Sock2)
-    end,
-    ok.
+    {ok, Peer1, Node1} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE"]}),
+    {ok, Peer2, Node2} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE"]}),
+    pang = net_adm:ping(Node1), pang = net_adm:ping(Node2), %% extra check, may be skipped
+    ok = peer:call(Peer1, ?MODULE, group_leader_1, [Node2]),
+    peer:stop(Peer1), %% verify_nc() will fail because peer is not dist-connected
+    peer:stop(Peer2).
 
 group_leader_1(Node2) ->
-    ?Line ExtPid = spawn(Node2, fun F() ->
+    ExtPid = spawn(Node2, fun F() ->
                                         receive {From, group_leader} ->
                                                 From ! {self(), group_leader, group_leader()}
                                         end,
                                         F()
                                 end),
-    ?Line GL1 = self(),
-    ?Line group_leader(GL1, ExtPid),
-    ?Line ExtPid ! {self(), group_leader},
-    ?Line {ExtPid, group_leader, GL1} = receive_one(),
+    GL1 = self(),
+    group_leader(GL1, ExtPid),
+    ExtPid ! {self(), group_leader},
+    {ExtPid, group_leader, GL1} = receive_one(),
 
     %% Kill connection and repeat test when group_leader/2 triggers auto-connect
-    ?Line net_kernel:monitor_nodes(true),
-    ?Line net_kernel:disconnect(Node2),
-    ?Line {nodedown, Node2} = receive_one(),
-    ?Line GL2 = spawn(fun() -> dummy end),
-    ?Line group_leader(GL2, ExtPid),
-    ?Line {nodeup, Node2} = receive_one(),
-    ?Line ExtPid ! {self(), group_leader},
-    ?Line {ExtPid, group_leader, GL2} = receive_one(),
+    net_kernel:monitor_nodes(true),
+    net_kernel:disconnect(Node2),
+    {nodedown, Node2} = receive_one(),
+    GL2 = spawn(fun() -> dummy end),
+    group_leader(GL2, ExtPid),
+    {nodeup, Node2} = receive_one(),
+    ExtPid ! {self(), group_leader},
+    {ExtPid, group_leader, GL2} = receive_one(),
     ok.
 
 %% Test optimistic distribution flags toward pending connections (DFLAG_DIST_HOPEFULLY)
 optimistic_dflags(Config) when is_list(Config) ->
-    ?Line Sender = start_relay_node(optimistic_dflags_sender, []),
-    ?Line Echo = start_relay_node(optimistic_dflags_echo, []),
-    try
-        ?Line {ok, ok} = do_inet_rpc(Echo, ?MODULE, optimistic_dflags_echo, []),
-
-        ?Line EchoNode = inet_rpc_nodename(Echo),
-        ?Line {ok, ok} = do_inet_rpc(Sender, ?MODULE, optimistic_dflags_sender, [EchoNode])
-    after
-        ?Line stop_relay_node(Sender),
-        ?Line stop_relay_node(Echo)
-    end,
-    ok.
+    {ok, PeerSender, _Sender} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE"]}),
+    {ok, PeerEcho, Echo} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE"]}),
+    ok = peer:call(PeerEcho, ?MODULE, optimistic_dflags_echo, []),
+    ok = peer:call(PeerSender, ?MODULE, optimistic_dflags_sender, [Echo]),
+    peer:stop(PeerSender),
+    peer:stop(PeerEcho).
 
 optimistic_dflags_echo() ->
     P = spawn(fun F() ->
@@ -245,25 +232,25 @@ optimistic_dflags_echo() ->
     ok.
 
 optimistic_dflags_sender(EchoNode) ->
-    ?Line net_kernel:monitor_nodes(true),
+    net_kernel:monitor_nodes(true),
 
     optimistic_dflags_do(EchoNode, <<1:1>>),
     optimistic_dflags_do(EchoNode, fun lists:map/2),
     ok.
 
 optimistic_dflags_do(EchoNode, Term) ->
-    ?Line {optimistic_dflags_echo, EchoNode} ! {self(), Term},
-    ?Line {nodeup, EchoNode} = receive_one(),
-    ?Line {EchoPid, Term} = receive_one(),
+    {optimistic_dflags_echo, EchoNode} ! {self(), Term},
+    {nodeup, EchoNode} = receive_one(),
+    {EchoPid, Term} = receive_one(),
     %% repeat with pid destination
-    ?Line net_kernel:disconnect(EchoNode),
-    ?Line {nodedown, EchoNode} = receive_one(),
-    ?Line EchoPid ! {self(), Term},
-    ?Line {nodeup, EchoNode} = receive_one(),
-    ?Line {EchoPid, Term} = receive_one(),
-
-    ?Line net_kernel:disconnect(EchoNode),
-    ?Line {nodedown, EchoNode} = receive_one(),
+    net_kernel:disconnect(EchoNode),
+    {nodedown, EchoNode} = receive_one(),
+    EchoPid ! {self(), Term},
+    {nodeup, EchoNode} = receive_one(),
+    {EchoPid, Term} = receive_one(),
+
+    net_kernel:disconnect(EchoNode),
+    {nodedown, EchoNode} = receive_one(),
     ok.
 
 
@@ -281,13 +268,13 @@ bulk_send(Terms, BinSize) ->
     ct:timetrap({seconds, 30}),
 
     io:format("Sending ~w binaries, each of size ~w K", [Terms, BinSize]),
-    {ok, Node} = start_node(bulk_receiver),
+    {ok, Peer, Node} = ?CT_PEER(),
     Recv = spawn(Node, erlang, apply, [fun receiver/2, [0, 0]]),
     Bin = binary:copy(<<253>>, BinSize*1024),
     Size = Terms*size(Bin),
     {Elapsed, {Terms, Size}} = test_server:timecall(?MODULE, sender,
                                                     [Recv, Bin, Terms]),
-    stop_node(Node),
+    peer_stop(Peer, Node),
     {comment, integer_to_list(round(Size/1024/max(1,Elapsed))) ++ " K/s"}.
 
 sender(To, _Bin, 0) ->
@@ -321,7 +308,7 @@ bulk_sendsend2(Terms, BinSize, BusyBufSize) ->
 
     io:format("\nSending ~w binaries, each of size ~w K",
               [Terms, BinSize]),
-    {ok, NodeRecv} = start_node(bulk_receiver),
+    {ok, RecvPeer, NodeRecv} = ?CT_PEER(),
     Recv = spawn(NodeRecv, erlang, apply, [fun receiver/2, [0, 0]]),
     Bin = binary:copy(<<253>>, BinSize*1024),
 
@@ -334,8 +321,7 @@ bulk_sendsend2(Terms, BinSize, BusyBufSize) ->
     %% default busy size and "+zdbbl 5", and if the 5 case gets
     %% "many many more" monitor messages, then we know we're working.
 
-    {ok, NodeSend} = start_node(bulk_sender, "+zdbbl " ++
-                                    integer_to_list(BusyBufSize)),
+    {ok, SendPeer, NodeSend} = ?CT_PEER(["+zdbbl", integer_to_list(BusyBufSize)]),
     _Send = spawn(NodeSend, erlang, apply,
                   [fun sendersender/4, [self(), Recv, Bin, Terms]]),
     {Elapsed, {_TermsN, SizeN}, MonitorCount} =
@@ -347,8 +333,8 @@ bulk_sendsend2(Terms, BinSize, BusyBufSize) ->
             {sendersender, BigRes} ->
                 BigRes
         end,
-    stop_node(NodeRecv),
-    stop_node(NodeSend),
+    peer_stop(RecvPeer, NodeRecv),
+    peer_stop(SendPeer, NodeSend),
     {round(SizeN/1024/Elapsed), MonitorCount}.
 
 %% Sender process to be run on a slave node
@@ -449,7 +435,7 @@ receiver2(Num, TotSize) ->
 %% Test that link/1 to a busy distribution port works.
 link_to_busy(Config) when is_list(Config) ->
     ct:timetrap({seconds, 60}),
-    {ok, Node} = start_node(link_to_busy),
+    {ok, Peer, Node} = ?CT_PEER(),
     Recv = spawn(Node, erlang, apply, [fun sink/1, [link_to_busy_sink]]),
 
     Tracer = case os:getenv("TRACE_BUSY_DIST_PORT") of
@@ -475,7 +461,7 @@ link_to_busy(Config) when is_list(Config) ->
     do_busy_test(Node, fun () -> tail_applied_linker(Recv) end),
 
     %% Done.
-    stop_node(Node),
+    peer_stop(Peer, Node),
     stop_busy_dist_port_tracer(Tracer),
     ok.
 
@@ -495,7 +481,7 @@ tail_applied_linker(Pid) ->
 %% Test that exit/2 to a busy distribution port works.
 exit_to_busy(Config) when is_list(Config) ->
     ct:timetrap({seconds, 60}),
-    {ok, Node} = start_node(exit_to_busy),
+    {ok, Peer, Node} = ?CT_PEER(),
 
     Tracer = case os:getenv("TRACE_BUSY_DIST_PORT") of
                  "true" -> start_busy_dist_port_tracer();
@@ -545,7 +531,7 @@ exit_to_busy(Config) when is_list(Config) ->
     end,
 
     %% Done.
-    stop_node(Node),
+    peer_stop(Peer, Node),
     stop_busy_dist_port_tracer(Tracer),
     ok.
 
@@ -664,7 +650,7 @@ sink1() ->
 %% Test that EXIT and DOWN messages send to another node are not lost if
 %% the distribution port is busy.
 lost_exit(Config) when is_list(Config) ->
-    {ok, Node} = start_node(lost_exit),
+    {ok, Peer, Node} = ?CT_PEER(),
 
     Tracer = case os:getenv("TRACE_BUSY_DIST_PORT") of
                  "true" -> start_busy_dist_port_tracer();
@@ -717,7 +703,7 @@ lost_exit(Config) when is_list(Config) ->
 
     %% Done.
     stop_busy_dist_port_tracer(Tracer),
-    stop_node(Node),
+    peer_stop(Peer, Node),
     ok.
 
 dummy_waiter() ->
@@ -730,9 +716,7 @@ dummy_waiter() ->
 %% AND that the link is teared down.
 link_to_dead(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    {ok, Node} = start_node(link_to_dead),
-    %    monitor_node(Node, true),
-    net_adm:ping(Node), %% Ts_cross_server workaround.
+    {ok, Peer, Node} = ?CT_PEER(),
     Pid = spawn(Node, ?MODULE, dead_process, []),
     receive
     after 5000 -> ok
@@ -749,13 +733,14 @@ link_to_dead(Config) when is_list(Config) ->
     {links, Links} = process_info(self(), links),
     io:format("Pid=~p, links=~p", [Pid, Links]),
     false = lists:member(Pid, Links),
-    stop_node(Node),
     receive
         Message ->
             ct:fail({unexpected_message, Message})
     after 3000 ->
               ok
     end,
+    process_flag(trap_exit, false),
+    peer_stop(Peer, Node),
     ok.
 
 dead_process() ->
@@ -767,18 +752,24 @@ link_to_dead_new_node(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
 
     %% Start the node, get a Pid and stop the node again.
-    {ok, Node} = start_node(link_to_dead_new_node),
+    Name = ?CT_PEER_NAME(?FUNCTION_NAME),
+    {ok, Peer, Node} = ?CT_PEER(#{name => Name}),
     Pid = spawn(Node, ?MODULE, dead_process, []),
-    stop_node(Node),
+
+    peer_stop(Peer, Node),
+    %% since exits are trapped, need to catch exiting peer
+    receive {'EXIT', Peer, normal} -> ok end,
 
     %% Start a new node with the same name.
-    {ok, Node} = start_node(link_to_dead_new_node),
+    {ok, Peer2, Node} = ?CT_PEER(#{name => Name}),
     link(Pid),
+
     receive
         {'EXIT', Pid, noproc} ->
             ok;
         Other ->
-            stop_node(Node),
+            process_flag(trap_exit, false),
+            peer_stop(Peer2, Node),
             ct:fail({unexpected_message, Other})
     after 5000 ->
               ct:fail(nothing_received)
@@ -788,13 +779,16 @@ link_to_dead_new_node(Config) when is_list(Config) ->
     {links, Links} = process_info(self(), links),
     io:format("Pid=~p, links=~p", [Pid, Links]),
     false = lists:member(Pid, Links),
-    stop_node(Node),
     receive
         Message ->
+            process_flag(trap_exit, false),
             ct:fail({unexpected_message, Message})
     after 3000 ->
               ok
     end,
+    %% stop trapping exits, and let the peer stop
+    process_flag(trap_exit, false),
+    peer_stop(Peer2, Node),
     ok.
 
 %% Test that sending a port or reference to another node and back again
@@ -803,13 +797,13 @@ ref_port_roundtrip(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
     Port = make_port(),
     Ref = make_ref(),
-    {ok, Node} = start_node(ref_port_roundtrip),
+    {ok, Peer, Node} = ?CT_PEER(),
     net_adm:ping(Node),
     Term = {Port, Ref},
     io:format("Term before: ~p", [show_term(Term)]),
     Pid = spawn_link(Node, ?MODULE, roundtrip, [Term]),
     receive after 5000 -> ok end,
-    stop_node(Node),
+    peer_stop(Peer, Node),
     receive
         {'EXIT', Pid, {Port, Ref}} ->
             io:format("Term after: ~p", [show_term(Term)]),
@@ -832,7 +826,7 @@ roundtrip(Term) ->
 %% another node node and back again.
 nil_roundtrip(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    {ok, Node} = start_node(nil_roundtrip),
+    {ok, Peer, Node} = ?CT_PEER(),
     net_adm:ping(Node),
     Pid = spawn_link(Node, ?MODULE, bounce, [self()]),
     Pid ! [],
@@ -840,7 +834,7 @@ nil_roundtrip(Config) when is_list(Config) ->
         [] ->
             receive
                 {'EXIT', Pid, []} ->
-                    stop_node(Node),
+                    peer_stop(Peer, Node),
                     ok
             end
     end.
@@ -900,7 +894,7 @@ tr3() ->
 
 
 
-% This has to be done by nodes with differrent cookies, otherwise global
+% This has to be done by nodes with different cookies, otherwise global
 % will connect nodes, which is correct, but makes it hard to test.
 % * Start two nodes, n1 and n2. n2 with the dist_auto_connect once parameter
 % * n2 pings n1 -> connection
@@ -913,177 +907,65 @@ tr3() ->
 % * n2 now also gets pong when pinging n1
 % * disconnect n2 from n1
 % * n2 gets pang when pinging n1
-% * n2 forces connection by using net_kernel:connect_node (ovverrides)
+% * n2 forces connection by using net_kernel:connect_node (overrides)
 % * n2 gets pong when pinging n1.
 
 %% Test the dist_auto_connect once kernel parameter
 dist_auto_connect_once(Config) when is_list(Config) ->
-    Sock = start_relay_node(dist_auto_connect_relay_node,[]),
-    NN = inet_rpc_nodename(Sock),
-    Sock2 = start_relay_node(dist_auto_connect_once_node,
-                             "-kernel dist_auto_connect once"),
-    NN2 = inet_rpc_nodename(Sock2),
-    {ok,[]} = do_inet_rpc(Sock,erlang,nodes,[]),
-    {ok, pong} = do_inet_rpc(Sock2,net_adm,ping,[NN]),
-    {ok,[NN2]} = do_inet_rpc(Sock,erlang,nodes,[]),
-    {ok,[NN]} = do_inet_rpc(Sock2,erlang,nodes,[]),
-    [_,HostPartPeer] = string:lexemes(atom_to_list(NN),"@"),
-    [_,MyHostPart] = string:lexemes(atom_to_list(node()),"@"),
+    {ok, PN, NN} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE"]}),
+    {ok, PN2, NN2} = ?CT_PEER(#{connection => 0,
+        args => ["-setcookie", "NONE", "-kernel", "dist_auto_connect", "once"]}),
+    [] = peer:call(PN,erlang,nodes,[]),
+    pong = peer:call(PN2,net_adm,ping,[NN]),
+    [NN2] = peer:call(PN,erlang,nodes,[]),
+    [NN] = peer:call(PN2,erlang,nodes,[]),
     % Give net_kernel a chance to change the state of the node to up to.
     receive after 1000 -> ok end,
-    case HostPartPeer of
-        MyHostPart ->
-            ok = stop_relay_node(Sock),
-            {ok,pang} = do_inet_rpc(Sock2,net_adm,ping,[NN]);
-        _ ->
-            {ok, true} = do_inet_rpc(Sock,net_kernel,disconnect,[NN2]),
-            receive
-            after 500 -> ok
-            end
-    end,
-    {ok, []} = do_inet_rpc(Sock2,erlang,nodes,[]),
-    Sock3 = case HostPartPeer of
-                MyHostPart ->
-                    start_relay_node(dist_auto_connect_relay_node,[]);
-                _ ->
-                    Sock
-            end,
+    ok = peer:stop(PN),
+    pang = peer:call(PN2,net_adm,ping,[NN]),
+    [] = peer:call(PN2,erlang,nodes,[]),
+    %% restart NN node
+    {ok, PN3, NN} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE"],
+        name => hd(string:lexemes(atom_to_list(NN), "@"))}),
     TS1 = timestamp(),
-    {ok, pang} = do_inet_rpc(Sock2,net_adm,ping,[NN]),
+    pang = peer:call(PN2,net_adm,ping,[NN]),
     TS2 = timestamp(),
     RefT = net_kernel:connecttime() - 1000,
     true = ((TS2 - TS1) < RefT),
     TS3 = timestamp(),
-    {ok, true} = do_inet_rpc(Sock2,erlang,monitor_node,
-                             [NN,true,[allow_passive_connect]]),
+    true = peer:call(PN2,erlang,monitor_node,
+                             [NN,true,[allow_passive_connect]], 60000),
     TS4 = timestamp(),
     true = ((TS4 - TS3) > RefT),
-    {ok, pong} = do_inet_rpc(Sock3,net_adm,ping,[NN2]),
-    {ok, pong} = do_inet_rpc(Sock2,net_adm,ping,[NN]),
-    {ok, true} = do_inet_rpc(Sock3,net_kernel,disconnect,[NN2]),
+    pong = peer:call(PN3,net_adm,ping,[NN2]),
+    pong = peer:call(PN2,net_adm,ping,[NN]),
+    true = peer:call(PN3,net_kernel,disconnect,[NN2]),
     receive
     after 500 -> ok
     end,
-    {ok, pang} = do_inet_rpc(Sock2,net_adm,ping,[NN]),
-    {ok, true} = do_inet_rpc(Sock2,net_kernel,connect_node,[NN]),
-    {ok, pong} = do_inet_rpc(Sock2,net_adm,ping,[NN]),
-    stop_relay_node(Sock3),
-    stop_relay_node(Sock2).
+    pang = peer:call(PN2,net_adm,ping,[NN]),
+    true = peer:call(PN2,net_kernel,connect_node,[NN]),
+    pong = peer:call(PN2,net_adm,ping,[NN]),
+    peer:stop(PN3),
+    peer:stop(PN2).
 
 
 
-%% Start a relay node and a lonely (dist_auto_connect never) node.
-%% Lonely node pings relay node. That should fail. 
-%% Lonely node connects to relay node with net_kernel:connect_node/1.
-%% Result is sent here through relay node.
+%% Spawn dist_auto_connect never node, ensure it won't
+%%  connect to the origin with net_adm:ping(), but will with
+%%  explicit net_kernel:connect_node.
 dist_auto_connect_never(Config) when is_list(Config) ->
-    Self = self(),
-    {ok, RelayNode} = start_node(dist_auto_connect_relay),
-    spawn(RelayNode,
-          fun() ->
-                  register(dist_auto_connect_relay, self()),
-                  dist_auto_connect_relay(Self)
-          end),
-    {ok, Handle} = dist_auto_connect_start(dist_auto_connect, never),
-    Result = receive
-                 {do_dist_auto_connect, ok} ->
-                     ok;
-                 {do_dist_auto_connect, Error} ->
-                     {error, Error};
-                 %% The io:formats in dos_dist_auto_connect will
-                 %% generate port output messages that are ok
-                 Other when not is_port(element(1, Other))->
-                     {error, Other}
-             after 32000 ->
-                       timeout
-             end,
-    stop_node(RelayNode),
-    Stopped = dist_auto_connect_stop(Handle),
-    Junk = receive
-               {do_dist_auto_connect, _} = J -> J
-           after 0 -> ok
-           end,
-    {ok, ok, ok} = {Result, Stopped, Junk},
+    {ok, LonelyPeer, Node} = ?CT_PEER(#{connection => 0, args => ["-kernel", "dist_auto_connect", "never"]}),
+    pang = peer:call(LonelyPeer, net_adm, ping, [node()]),
+    false = lists:member(Node, nodes()),
+    true = peer:call(LonelyPeer, net_kernel, connect_node, [node()]),
+    true = lists:member(Node, nodes()),
+    peer:stop(LonelyPeer),
     ok.
 
-
-do_dist_auto_connect([never]) ->
-    Node = list_to_atom("dist_auto_connect_relay@" ++ hostname()),
-    io:format("~p:do_dist_auto_connect([false]) Node=~p~n", [?MODULE, Node]),
-    Ping = net_adm:ping(Node),
-    io:format("~p:do_dist_auto_connect([false]) Ping=~p~n", [?MODULE, Ping]),
-    Result = case Ping of
-                 pang -> ok;
-                 _ -> {error, Ping}
-             end,
-    io:format("~p:do_dist_auto_connect([false]) Result=~p~n", [?MODULE, Result]),
-    net_kernel:connect_node(Node),
-    catch {dist_auto_connect_relay, Node} ! {do_dist_auto_connect, Result};
-%    receive after 1000 -> ok end,
-%    halt();
-
-do_dist_auto_connect(Arg) ->
-    io:format("~p:do_dist_auto_connect(~p)~n", [?MODULE, Arg]),
-    receive after 10000 -> ok end,
-    halt().
-
-
-dist_auto_connect_start(Name, Value) when is_atom(Name) ->
-    dist_auto_connect_start(atom_to_list(Name), Value);
-dist_auto_connect_start(Name, Value) when is_list(Name), is_atom(Value) ->
-    Node = list_to_atom(lists:append([Name, "@", hostname()])),
-    ModuleDir = filename:dirname(code:which(?MODULE)),
-    ValueStr = atom_to_list(Value),
-    Cookie = atom_to_list(erlang:get_cookie()),
-    Cmd = lists:append(
-            [%"xterm -e ",
-             ct:get_progname(),
-             %	     " -noinput ",
-             " -detached ",
-             long_or_short(), " ", Name,
-             " -setcookie ", Cookie,
-             " -pa ", ModuleDir,
-             " -s ", atom_to_list(?MODULE),
-             " do_dist_auto_connect ", ValueStr,
-             " -kernel dist_auto_connect ", ValueStr]),
-    io:format("~p:dist_auto_connect_start() cmd: ~p~n", [?MODULE, Cmd]),
-    Port = open_port({spawn, Cmd}, [stream]),
-    {ok, {Port, Node}}.
-
-
-dist_auto_connect_stop({Port, Node}) ->
-    Pid = spawn_link(fun() -> rpc:call(Node, erlang, halt, []) end),
-    dist_auto_connect_stop(Port, Node, Pid, 5000).
-
-dist_auto_connect_stop(Port, _Node, Pid, N) when is_integer(N), N =< 0 ->
-    exit(Pid, normal),
-    catch erlang:port_close(Port),
-    Result = {error, node_not_down},
-    io:format("~p:dist_auto_connect_stop() ~p~n", [?MODULE, Result]),
-    Result;
-dist_auto_connect_stop(Port, Node, Pid, N) when is_integer(N) ->
-    case net_adm:ping(Node) of
-        pong ->
-            receive after 100 -> ok end,
-            dist_auto_connect_stop(Port, Node, Pid, N-100);
-        pang ->
-            exit(Pid, normal),
-            catch erlang:port_close(Port),
-            io:format("~p:dist_auto_connect_stop() ok~n", [?MODULE]),
-            ok
-    end.
-
-
-dist_auto_connect_relay(Parent) ->
-    receive X ->
-                catch Parent ! X
-    end,
-    dist_auto_connect_relay(Parent).
-
-
 dist_parallel_send(Config) when is_list(Config) ->
-    {ok, RNode} = start_node(dist_parallel_receiver),
-    {ok, SNode} = start_node(dist_parallel_sender),
+    {ok, RPeer, RNode} = ?CT_PEER(),
+    {ok, SPeer, SNode} = ?CT_PEER(),
     WatchDog = spawn_link(
                  fun () ->
                          TRef = erlang:start_timer((2*60*1000), self(), oops),
@@ -1136,8 +1018,8 @@ dist_parallel_send(Config) when is_list(Config) ->
     unlink(WatchDog),
     exit(WatchDog, bang),
 
-    stop_node(RNode),
-    stop_node(SNode),
+    peer_stop(RPeer, RNode),
+    peer_stop(SPeer, SNode),
 
     ok.
 
@@ -1163,17 +1045,17 @@ dist_evil_parallel_receiver() ->
 atom_roundtrip(Config) when is_list(Config) ->
     AtomData = atom_data(),
     verify_atom_data(AtomData),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     do_atom_roundtrip(Node, AtomData),
-    stop_node(Node),
+    peer_stop(Peer, Node),
     ok.
 
 unicode_atom_roundtrip(Config) when is_list(Config) ->
     AtomData = unicode_atom_data(),
     verify_atom_data(AtomData),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     do_atom_roundtrip(Node, AtomData),
-    stop_node(Node),
+    peer_stop(Peer, Node),
     ok.
 
 do_atom_roundtrip(Node, AtomData) ->
@@ -1269,17 +1151,17 @@ unicode_atom_data() ->
                  end, lists:seq(1, 2000))].
 
 contended_atom_cache_entry(Config) when is_list(Config) ->
-    contended_atom_cache_entry_test(Config, latin1).
+    contended_atom_cache_entry_test(latin1).
 
 contended_unicode_atom_cache_entry(Config) when is_list(Config) ->
-    contended_atom_cache_entry_test(Config, unicode).
+    contended_atom_cache_entry_test(unicode).
 
-contended_atom_cache_entry_test(Config, Type) ->
+contended_atom_cache_entry_test(Type) ->
     TestServer = self(),
     ProcessPairs = 10,
     Msgs = 100000,
-    {ok, SNode} = start_node(Config),
-    {ok, RNode} = start_node(Config),
+    {ok, SPeer, SNode} = ?CT_PEER(),
+    {ok, RPeer, RNode} = ?CT_PEER(),
     Success = make_ref(),
     spawn_link(
       SNode,
@@ -1341,8 +1223,8 @@ contended_atom_cache_entry_test(Config, Type) ->
         Success ->
             ok
     end,
-    stop_node(SNode),
-    stop_node(RNode),
+    peer_stop(SPeer, SNode),
+    peer_stop(RPeer, RNode),
     ok.
 
 send_ref_atom(_To, _Ref, _Atom, 0) ->
@@ -1417,15 +1299,15 @@ get_conflicting_unicode_atoms(CIX, N) ->
 %% they no longer fail when the latency is incorrect. However, they are
 %% kept as they continue to find bugs in the distribution implementation.
 message_latency_large_message(Config) when is_list(Config) ->
-    measure_latency_large_message(?FUNCTION_NAME, fun(Dropper, Payload) -> Dropper ! Payload end).
+    measure_latency_large_message(fun(Dropper, Payload) -> Dropper ! Payload end).
 message_latency_large_exit2(Config) when is_list(Config) ->
-    measure_latency_large_message(?FUNCTION_NAME, fun erlang:exit/2).
+    measure_latency_large_message(fun erlang:exit/2).
 
 message_latency_large_link_exit(Config) when is_list(Config) ->
-    message_latency_large_exit(?FUNCTION_NAME, fun erlang:link/1).
+    message_latency_large_exit(fun erlang:link/1).
 
 message_latency_large_monitor_exit(Config) when is_list(Config) ->
-    message_latency_large_exit(?FUNCTION_NAME,
+    message_latency_large_exit(
                                fun(Dropper) ->
                                        Dropper ! {monitor, self()},
                                        receive ok -> ok end
@@ -1440,9 +1322,8 @@ message_latency_large_link_exit() ->
 message_latency_large_monitor_exit() ->
     message_latency_large_message().
 
-message_latency_large_exit(Nodename, ReasonFun) ->
+message_latency_large_exit(ReasonFun) ->
     measure_latency_large_message(
-      Nodename,
       fun(Dropper, Payload) ->
               Pid  = spawn(fun() ->
                                    receive go -> ok end,
@@ -1467,11 +1348,11 @@ message_latency_large_exit(Nodename, ReasonFun) ->
               end
       end).
 
-measure_latency_large_message(Nodename, DataFun) ->
+measure_latency_large_message(DataFun) ->
 
     erlang:system_monitor(self(), [busy_dist_port]),
 
-    {ok, N} = start_node(Nodename),
+    {ok, Peer, N} = ?CT_PEER(),
 
     Dropper = spawn(N, fun F() ->
                                process_flag(trap_exit, true),
@@ -1505,7 +1386,7 @@ measure_latency_large_message(Nodename, DataFun) ->
 
     ct:pal("~p",[IndexTimes]),
 
-    stop_node(N),
+    peer_stop(Peer, N),
 
     case {lists:max(Times), lists:min(Times)} of
         {Max, Min} when Max * 0.25 > Min, BuildType =:= opt ->
@@ -1520,8 +1401,6 @@ measure_latency_large_message(Nodename, DataFun) ->
 
 measure_latency(DataFun, Dropper, Echo, Payload) ->
 
-    TCProc = self(),
-
     flush(),
 
     Senders = [spawn_monitor(
@@ -1599,7 +1478,7 @@ test_system_limit(Config) when is_list(Config) ->
     Bits = ((1 bsl 32)+1)*8,
     HugeBin = <<0:Bits>>,
     HugeListBin = [lists:duplicate(2000000,2000000), HugeBin],
-    {ok, N1} = start_node(Config),
+    {ok, _Peer1, N1} = ?CT_PEER(),
     monitor_node(N1, true),
     receive
         {nodedown, N1} ->
@@ -1672,7 +1551,7 @@ test_system_limit(Config) when is_list(Config) ->
           end),
     receive {nodedown, N1} -> ok end,
 
-    {ok, N2} = start_node(Config),
+    {ok, _Peer2, N2} = ?CT_PEER(),
     monitor_node(N2, true),
     P2 = spawn(N2,
                fun () ->
@@ -1685,7 +1564,7 @@ test_system_limit(Config) when is_list(Config) ->
     receive {nodedown, N2} -> ok end,
 
     io:format("~n** distributed monitor down **~n~n", []),
-    {ok, N3} = start_node(Config),
+    {ok, _Peer3, N3} = ?CT_PEER(),
     monitor_node(N3, true),
     Go1 = make_ref(),
     LP1 = spawn(fun () ->
@@ -1700,7 +1579,7 @@ test_system_limit(Config) when is_list(Config) ->
                end),
     receive {nodedown, N3} -> ok end,
 
-    {ok, N4} = start_node(Config),
+    {ok, _Peer4, N4} = ?CT_PEER(),
     monitor_node(N4, true),
     Go2 = make_ref(),
     LP2 = spawn(fun () ->
@@ -1785,8 +1664,8 @@ start_link(Offender,P) ->
 bad_dist_structure(Config) when is_list(Config) ->
     ct:timetrap({seconds, 15}),
 
-    {ok, Offender} = start_node(bad_dist_structure_offender),
-    {ok, Victim} = start_node(bad_dist_structure_victim),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
     start_node_monitors([Offender,Victim]),
     Parent = self(),
     P = spawn(Victim,
@@ -1872,16 +1751,16 @@ bad_dist_structure(Config) when is_list(Config) ->
 
     unlink(P),
     P ! done,
-    stop_node(Offender),
-    stop_node(Victim),
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim),
     ok.
 
 %% Test various dist fragmentation errors
 bad_dist_fragments(Config) when is_list(Config) ->
     ct:timetrap({seconds, 15}),
 
-    {ok, Offender} = start_node(bad_dist_fragment_offender),
-    {ok, Victim} = start_node(bad_dist_fragment_victim),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
 
     Msg = iolist_to_binary(dmsg_ext(lists:duplicate(255,255))),
 
@@ -1974,8 +1853,8 @@ bad_dist_fragments(Config) when is_list(Config) ->
 
     unlink(P),
     P ! done,
-    stop_node(Offender),
-    stop_node(Victim),
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim),
     ok.
 
 dmsg_frag_hdr(Frag) ->
@@ -2035,8 +1914,8 @@ send_bad_fragments(Offender,VictimNode,Victim,Ctrl,WhereToPutSelf,Fragments) ->
     end.
 
 bad_dist_ext_receive(Config) when is_list(Config) ->
-    {ok, Offender} = start_node(bad_dist_ext_receive_offender),
-    {ok, Victim} = start_node(bad_dist_ext_receive_victim),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
     start_node_monitors([Offender,Victim]),
 
     Parent = self(),
@@ -2102,13 +1981,13 @@ bad_dist_ext_receive(Config) when is_list(Config) ->
     P ! done,
     unlink(P),
     verify_no_down(Offender, Victim),
-    stop_node(Offender),
-    stop_node(Victim).
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim).
 
 
 bad_dist_ext_process_info(Config) when is_list(Config) ->
-    {ok, Offender} = start_node(bad_dist_ext_process_info_offender),
-    {ok, Victim} = start_node(bad_dist_ext_process_info_victim),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
     start_node_monitors([Offender,Victim]),
 
     Parent = self(),
@@ -2163,12 +2042,12 @@ bad_dist_ext_process_info(Config) when is_list(Config) ->
     P ! done,
     unlink(P),
     verify_no_down(Offender, Victim),
-    stop_node(Offender),
-    stop_node(Victim).
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim).
 
 bad_dist_ext_control(Config) when is_list(Config) ->
-    {ok, Offender} = start_node(bad_dist_ext_control_offender),
-    {ok, Victim} = start_node(bad_dist_ext_control_victim),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
     start_node_monitors([Offender,Victim]),
 
     pong = rpc:call(Victim, net_adm, ping, [Offender]),
@@ -2182,12 +2061,12 @@ bad_dist_ext_control(Config) when is_list(Config) ->
     verify_down(Offender, connection_closed, Victim, killed),
 
     verify_no_down(Offender, Victim),
-    stop_node(Offender),
-    stop_node(Victim).
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim).
 
 bad_dist_ext_connection_id(Config) when is_list(Config) ->
-    {ok, Offender} = start_node(bad_dist_ext_connection_id_offender),
-    {ok, Victim} = start_node(bad_dist_ext_connection_id_victim),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
     start_node_monitors([Offender,Victim]),
 
     Parent = self(),
@@ -2248,15 +2127,13 @@ bad_dist_ext_connection_id(Config) when is_list(Config) ->
     P ! done,
     unlink(P),
     verify_no_down(Offender, Victim),
-    stop_node(Offender),
-    stop_node(Victim).
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim).
 
 %% OTP-14661: Bad message is discovered by erts_msg_attached_data_size
 bad_dist_ext_size(Config) when is_list(Config) ->
-    {ok, Offender} = start_node(bad_dist_ext_process_info_offender),
-    %%Prog = "Prog=/home/uabseri/src/otp_new3/bin/cerl -rr -debug",
-    Prog = [],
-    {ok, Victim} = start_node(bad_dist_ext_process_info_victim, [], Prog),
+    {ok, OffenderPeer, Offender} = ?CT_PEER(),
+    {ok, VictimPeer, Victim} = ?CT_PEER(),
     start_node_monitors([Offender,Victim]),
 
     Parent = self(),
@@ -2303,8 +2180,8 @@ bad_dist_ext_size(Config) when is_list(Config) ->
 
     unlink(P),
     verify_no_down(Offender, Victim),
-    stop_node(Offender),
-    stop_node(Victim).
+    peer_stop(OffenderPeer, Offender),
+    peer_stop(VictimPeer, Victim).
 
 
 bad_dist_struct_check_msgs([]) ->
@@ -2543,43 +2420,47 @@ dmsg_bad_tag() ->  %% Will fail early at heap size calculation
 
 start_epmd_false(Config) when is_list(Config) ->
     %% Start a node with the option -start_epmd false.
-    {ok, OtherNode} = start_node(start_epmd_false, "-start_epmd false"),
+    {ok, Peer, OtherNode} = ?CT_PEER(["-start_epmd", "false"]),
     %% We should be able to ping it, as epmd was started by us:
     pong = net_adm:ping(OtherNode),
-    stop_node(OtherNode),
+    peer_stop(Peer,OtherNode),
 
     ok.
 
 no_epmd(Config) when is_list(Config) ->
     %% Trying to start a node with -no_epmd but without passing the
     %% --proto_dist option should fail.
-    {error, timeout} = start_node(no_epmd, "-no_epmd").
+    try
+        ?CT_PEER(#{connection => standard_io, args => ["-no_epmd"]}),
+        ct:fail(unexpected_no_epmd_start)
+    catch
+        exit:{boot_failed, {exit_status, 1}} ->
+            ok
+    end.
 
 epmd_module(Config) when is_list(Config) ->
     %% We need a relay node to test this, since the test node uses the
     %% standard epmd module.
-    Sock1 = start_relay_node(epmd_module_node1, "-epmd_module " ++ ?MODULE_STRING),
-    Node1 = inet_rpc_nodename(Sock1),
+    {ok, Peer1, Node1} = ?CT_PEER(#{connection => 0, args => ["-setcookie", "NONE", "-epmd_module", ?MODULE_STRING]}),
     %% Ask what port it's listening on - it won't have registered with
     %% epmd.
-    {ok, {ok, Port1}} = do_inet_rpc(Sock1, application, get_env, [kernel, dist_listen_port]),
+    {ok, Port1} = peer:call(Peer1, application, get_env, [kernel, dist_listen_port]),
 
     %% Start a second node, passing the port number as a secret
     %% argument.
-    Sock2 = start_relay_node(epmd_module_node2, "-epmd_module " ++ ?MODULE_STRING
-			     ++ " -other_node_port " ++ integer_to_list(Port1)),
-    Node2 = inet_rpc_nodename(Sock2),
+    {ok, Peer2, Node2} = ?CT_PEER(#{connection => 0,
+        args => ["-setcookie", "NONE", "-epmd_module", ?MODULE_STRING, "-other_node_port", integer_to_list(Port1)]}),
     %% Node 1 can't ping node 2
-    {ok, pang} = do_inet_rpc(Sock1, net_adm, ping, [Node2]),
-    {ok, []} = do_inet_rpc(Sock1, erlang, nodes, []),
-    {ok, []} = do_inet_rpc(Sock2, erlang, nodes, []),
+    pang = peer:call(Peer1, net_adm, ping, [Node2]),
+    [] = peer:call(Peer1, erlang, nodes, []),
+    [] = peer:call(Peer2, erlang, nodes, []),
     %% But node 2 can ping node 1
-    {ok, pong} = do_inet_rpc(Sock2, net_adm, ping, [Node1]),
-    {ok, [Node2]} = do_inet_rpc(Sock1, erlang, nodes, []),
-    {ok, [Node1]} = do_inet_rpc(Sock2, erlang, nodes, []),
+    pong = peer:call(Peer2, net_adm, ping, [Node1]),
+    [Node2] = peer:call(Peer1, erlang, nodes, []),
+    [Node1] = peer:call(Peer2, erlang, nodes, []),
 
-    stop_relay_node(Sock2),
-    stop_relay_node(Sock1).
+    peer:stop(Peer2),
+    peer:stop(Peer1).
 
 %% epmd_module functions:
 
@@ -2618,8 +2499,8 @@ hopefull_data_encoding(Config) when is_list(Config) ->
     test_hopefull_data_encoding(Config, false).
 
 test_hopefull_data_encoding(Config, Fallback) when is_list(Config) ->
-    {ok, ProxyNode} = start_node(hopefull_data_normal),
-    {ok, BouncerNode} = start_node(hopefull_data_bouncer, "-hidden"),
+    {ok, PeerProxy, ProxyNode} = ?CT_PEER(),
+    {ok, PeerBouncer, BouncerNode} = ?CT_PEER(["-hidden"]),
     case Fallback of
         false ->
             ok;
@@ -2678,8 +2559,8 @@ test_hopefull_data_encoding(Config, Fallback) when is_list(Config) ->
     exit(Proxy, bye),
     unlink(Bouncer),
     exit(Bouncer, bye),
-    stop_node(ProxyNode),
-    stop_node(BouncerNode),
+    peer_stop(PeerProxy, ProxyNode),
+    peer_stop(PeerBouncer, BouncerNode),
     ok.
 
 bounce_loop() ->
@@ -2774,14 +2655,14 @@ hopefull_export_fun_bug(Config) when is_list(Config) ->
            2, fun blipp:blapp/7],
     {dummy, dummy@dummy} ! Msg.  % Would crash on debug VM
 
-huge_iovec(Config) ->
+huge_iovec(Config) when is_list(Config) ->
     %% Make sure that we can pass a term that will produce
     %% an io-vector larger than IOV_MAX over the distribution...
     %% IOV_MAX is typically 1024. Currently we produce an
     %% element in the io-vector for all off heap binaries...
     NoBinaries = 1 bsl 14,
     BinarySize = 65,
-    {ok, Node} = start_node(huge_iovec),
+    {ok, Peer, Node} = ?CT_PEER(),
     P = spawn_link(Node,
                    fun () ->
                            receive {From, Data} ->
@@ -2797,7 +2678,7 @@ huge_iovec(Config) ->
     P ! {self(), RBL},
     receive
         {P, EchoedRBL} ->
-            stop_node(Node),
+            peer_stop(Peer, Node),
             RBL = EchoedRBL
     end,
     ok.
@@ -2821,10 +2702,10 @@ mk_rand_bin(N, Data) ->
 
 %% Try provoke DistEntry refc bugs (OTP-17513).
 dist_entry_refc_race(_Config) ->
-    {ok, Node} = start_node(dist_entry_refc_race, "+zdntgc 1"),
+    {ok, Peer, Node} = ?CT_PEER(["+zdntgc", "1"]),
     Pid = spawn_link(Node, ?MODULE, derr_run, [self()]),
     {Pid, done} = receive M -> M end,
-    stop_node(Node),
+    peer_stop(Peer, Node),
     ok.
 
 derr_run(Papa) ->
@@ -2866,36 +2747,9 @@ derr_sender(Main, Nodes) ->
 timestamp() ->
     erlang:monotonic_time(millisecond).
 
-start_node(X) ->
-    start_node(X, [], []).
-
-start_node(X, Y) ->
-    start_node(X, Y, []).
-
-start_node(Name, Args, Rel) when is_atom(Name), is_list(Rel) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Cookie = atom_to_list(erlang:get_cookie()),
-    RelArg = case Rel of
-                 [] -> [];
-                 _ -> [{erl,[{release,Rel}]}]
-             end,
-    test_server:start_node(Name, slave,
-                           [{args,
-                             Args++" -setcookie "++Cookie++" -pa \""++Pa++"\""}
-                            | RelArg]);
-start_node(Config, Args, Rel) when is_list(Config), is_list(Rel) ->
-    Name = list_to_atom((atom_to_list(?MODULE)
-                         ++ "-"
-                         ++ atom_to_list(proplists:get_value(testcase, Config))
-                         ++ "-"
-                         ++ integer_to_list(erlang:system_time(second))
-                         ++ "-"
-                         ++ integer_to_list(erlang:unique_integer([positive])))),
-    start_node(Name, Args, Rel).
-
-stop_node(Node) ->
+peer_stop(Peer, Node) ->
     verify_nc(Node),
-    test_server:stop_node(Node).
+    peer:stop(Peer).
 
 verify_nc(Node) ->
     P = self(),
@@ -2931,78 +2785,6 @@ freeze_node(Node, MS) ->
     receive DoingIt -> ok end,
     receive after Own -> ok end.
 
-inet_rpc_nodename({N,H,_Sock}) ->
-    list_to_atom(N++"@"++H).
-
-do_inet_rpc({_,_,Sock},M,F,A) ->
-    Bin = term_to_binary({M,F,A}),
-    gen_tcp:send(Sock,Bin),
-    case gen_tcp:recv(Sock,0) of
-        {ok, Bin2} ->
-            T = binary_to_term(Bin2),
-            {ok,T};
-        Else ->
-            {error, Else}
-    end.
-
-inet_rpc_server([Host, PortList]) ->
-    Port = list_to_integer(PortList),
-    {ok, Sock} = gen_tcp:connect(Host, Port,[binary, {packet, 4}, 
-                                             {active, false}]),
-    inet_rpc_server_loop(Sock).
-
-inet_rpc_server_loop(Sock) ->
-    case gen_tcp:recv(Sock,0) of
-        {ok, Bin} ->
-            {M,F,A} = binary_to_term(Bin),
-            Res = (catch apply(M,F,A)),
-            RB = term_to_binary(Res),
-            gen_tcp:send(Sock,RB),
-            inet_rpc_server_loop(Sock);
-        _ ->
-            erlang:halt()
-    end.
-
-
-start_relay_node(Node, Args) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Cookie = "NOT"++atom_to_list(erlang:get_cookie()),
-    {ok, LSock} = gen_tcp:listen(0, [binary, {packet, 4}, {active, false}]),
-    {ok, Port} = inet:port(LSock),
-    {ok, Host} = inet:gethostname(),
-    RunArg = "-run " ++ atom_to_list(?MODULE) ++ " inet_rpc_server " ++
-    Host ++ " " ++ integer_to_list(Port),
-    {ok, NN} = test_server:start_node(Node, peer,
-                                      [{args, Args ++
-                                        " -setcookie "++Cookie++" -pa "++Pa++" "++
-                                        RunArg}]),
-    [N,H] = string:lexemes(atom_to_list(NN),"@"),
-    {ok, Sock} = gen_tcp:accept(LSock),
-    pang = net_adm:ping(NN),
-    {N,H,Sock}.
-
-stop_relay_node({N,H,Sock}) ->
-    catch do_inet_rpc(Sock,erlang,halt,[]),
-    catch gen_tcp:close(Sock),
-    wait_dead(N,H,10).
-
-wait_dead(N,H,0) ->
-    {error,{not_dead,N,H}};
-wait_dead(N,H,X) ->
-    case erl_epmd:port_please(N,H) of
-        {port,_,_} ->
-            receive
-            after 1000 ->
-                      ok
-            end,
-            wait_dead(N,H,X-1);
-        noport ->
-            ok;
-        Else ->
-            {error, {unexpected, Else}}
-    end.
-
-
 start_node_monitors(Nodes) ->
     Master = self(),
     lists:foreach(fun (Node) ->
@@ -3109,13 +2891,6 @@ from(_, []) -> [].
 %% fun_spawn(Fun, Args) ->
 %%     spawn_link(erlang, apply, [Fun, Args]).
 
-
-long_or_short() -> 
-    case net_kernel:longnames() of
-        true -> " -name ";
-        false -> " -sname "
-    end.
-
 until(Fun) ->
     case Fun() of
         true ->
diff --git a/erts/emulator/test/distribution_SUITE_data/run.erl b/erts/emulator/test/distribution_SUITE_data/run.erl
index f574b2c02c..c834793d26 100644
--- a/erts/emulator/test/distribution_SUITE_data/run.erl
+++ b/erts/emulator/test/distribution_SUITE_data/run.erl
@@ -54,7 +54,7 @@ start() ->
 
 do_it() ->
     {ok, _} = net_kernel:start([fideridum,shortnames]),
-    {ok, Node} = slave:start(host(), heppel),
+    {ok, _Peer, Node} = peer:start(#{name => peer:random_name(heppel)}),
     P = spawn(Node, net_kernel, stop, []),
     B1 = term_to_binary(P),
     N1 = node(P),
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index 083f98dc30..751c4a9e5d 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -84,7 +84,6 @@
          env/1,
          poll_pipe/1,
          lots_of_used_fds_on_boot/1,
-         lots_of_used_fds_on_boot_slave/1,
          z_test/1]).
 
 -export([bin_prefix/2]).
@@ -178,16 +177,18 @@ end_per_suite(_Config) ->
     catch erts_debug:set_internal_state(available_internal_state, false).
 
 init_per_group(poll_thread, Config) ->
-    [{node_args, "+IOt 2"} | Config];
+    [{node_args, ["+IOt", "2"]} | Config];
 init_per_group(poll_set, Config) ->
-    [{node_args, "+IOt 2 +IOp 2"} | Config];
+    [{node_args, ["+IOt", "2", "+IOp", "2"]} | Config];
 init_per_group(polling, Config) ->
     case proplists:get_value(node_args, Config) of
         undefined ->
             Config;
         Args ->
-            {ok, Node} = start_node(polling, Args),
-            [{node, Node} | Config]
+            {ok, Peer, Node} = ?CT_PEER(Args),
+            unlink(Peer), %% otherwise it will immediately stop
+            setup_logger(Node),
+            [{node, {Peer, Node}} | Config]
     end;
 init_per_group(_GroupName, Config) ->
     Config.
@@ -195,11 +196,11 @@ init_per_group(_GroupName, Config) ->
 end_per_group(_GroupName, Config) ->
     case proplists:get_value(node, Config) of
         undefined ->
-            ok;
-        Node ->
-            stop_node(Node)
-    end,
-    Config.
+            Config;
+        {Peer, _Node} ->
+            peer:stop(Peer),
+            {save_config, proplists:delete(node, Config)}
+    end.
 
 init_per_testcase(Case, Config) when is_atom(Case), is_list(Config) ->
     CIOD = rpc(Config,
@@ -230,12 +231,13 @@ end_per_testcase(Case, Config) ->
             case proplists:get_value(node, Config) of
                 undefined ->
                     ok;
-                Node ->
-                    timer:sleep(1000), %% Give the node time to die
-                    [NodeName, _] = string:lexemes(atom_to_list(Node),"@"),
-                    {ok, Node} = start_node_final(
-                                   list_to_atom(NodeName),
-                                   proplists:get_value(node_args, Config))
+                {Peer, _Node} ->
+                    peer:stop(Peer),
+                    {ok, Peer2, Node2} = ?CT_PEER(proplists:get_value(node_args, Config)),
+                    unlink(Peer2), %% otherwise it will immediately stop
+                    setup_logger(Node2),
+                    Config2 = [{node, {Peer2, Node2}} | proplists:delete(node, Config)],
+                    {save_config, Config2}
             end
     end,
     ok.
@@ -1155,7 +1157,7 @@ tag_type(poll_threads) -> sum.
 %% driver that didn't use the same lock. The lock checker
 %% used to trigger on this and dump core.
 otp_6602(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     Done = make_ref(),
     Parent = self(),
     Tester = spawn_link(Node,
@@ -1170,7 +1172,7 @@ otp_6602(Config) when is_list(Config) ->
                         end),
     receive Done -> ok end,
     unlink(Tester),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 -define(EXPECTED_SYSTEM_INFO_NAMES1,
@@ -1869,68 +1871,20 @@ lots_of_used_fds_on_boot_test(Config) ->
     %% open. This used to hang the whole VM at boot in
     %% an eternal loop trying to figure out how to size
     %% arrays in erts_poll() implementation.
-    Name = lots_of_used_fds_on_boot,
-    HostSuffix = lists:dropwhile(fun ($@) -> false; (_) -> true end,
-				 atom_to_list(node())),
-    FullName = list_to_atom(atom_to_list(Name) ++ HostSuffix),
-    Pa = filename:dirname(code:which(?MODULE)),
     Prog = case catch init:get_argument(progname) of
 	       {ok,[[P]]} -> P;
 	       _ -> exit(no_progname_argument_found)
 	   end,
-    NameSw = case net_kernel:longnames() of
-		 false -> "-sname ";
-		 true -> "-name ";
-		 _ -> exit(not_distributed_node)
-	     end,
-    {ok, Pwd} = file:get_cwd(),
-    NameStr = atom_to_list(Name),
     DataDir = proplists:get_value(data_dir, Config),
     Wrapper = filename:join(DataDir, "lots_of_fds_used_wrapper"),
-    CmdLine = Wrapper ++ " " ++ Prog ++ " -noshell -noinput "
-	++ NameSw ++ " " ++ NameStr ++ " "
-	++ "-pa " ++ Pa ++ " "
-	++ "-env ERL_CRASH_DUMP " ++ Pwd ++ "/erl_crash_dump." ++ NameStr ++ " "
-	++ "-setcookie " ++ atom_to_list(erlang:get_cookie()) ++ " "
-        ++ "-s " ++ atom_to_list(?MODULE) ++ " lots_of_used_fds_on_boot_slave "
-        ++ atom_to_list(node()),
-    io:format("Starting node ~p: ~s~n", [FullName, CmdLine]),
-    net_kernel:monitor_nodes(true),
-    Port = case open_port({spawn, CmdLine}, [exit_status]) of
-               Prt when is_port(Prt) ->
-                   Prt;
-               OPError ->
-                   exit({failed_to_start_node, {open_port_error, OPError}})
-           end,
-    receive
-        {Port, {exit_status, 17}} ->
-            {skip, "Cannot open enough fds to test this"};
-        {Port, {exit_status, Error}} ->
-            exit({failed_to_start_node, {exit_status, Error}});
-        {nodeup, FullName} ->
-            io:format("~p connected!~n", [FullName]),
-            FullName = rpc:call(FullName, erlang, node, []),
-            rpc:cast(FullName, erlang, halt, []),
-            receive
-                {Port, {exit_status, 0}} ->
-                    ok;
-                {Port, {exit_status, Error}} ->
-                    exit({unexpected_exit_status, Error})
-            after 5000 ->
-                    exit(missing_exit_status)
-            end
-    after 5000 ->
-            exit(connection_timeout)
+    try
+        {ok, Peer, _Node} = ?CT_PEER(#{connection => standard_io, exec => {Wrapper, [Prog]}}),
+        peer:stop(Peer)
+    catch
+        exit:{boot_failed, {exit_status, 17}} ->
+            {skip, "Cannot open enough fds to test this"}
     end.
 
-lots_of_used_fds_on_boot_slave([Master]) ->
-    erlang:monitor_node(Master, true),
-    receive
-        {nodedown, Master} ->
-            erlang:halt()
-    end,
-    ok.
-
 thread_mseg_alloc_cache_clean(Config) when is_list(Config) ->
     case {erlang:system_info(threads),
           erlang:system_info({allocator,mseg_alloc}),
@@ -2733,32 +2687,14 @@ sleep(Ms) when is_integer(Ms), Ms >= 0 ->
     receive after Ms -> ok end.
 
 
-start_node(Config) when is_list(Config) ->
-    start_node(proplists:get_value(testcase, Config));
-start_node(Name) ->
-    start_node(Name, "").
-start_node(NodeName, Args) ->
-    Name = list_to_atom(atom_to_list(?MODULE)
-                        ++ "-"
-                        ++ atom_to_list(NodeName)
-                        ++ "-"
-                        ++ integer_to_list(erlang:system_time(second))
-                        ++ "-"
-                        ++ integer_to_list(erlang:unique_integer([positive]))),
-    start_node_final(Name, Args).
-start_node_final(Name, Args) ->
+setup_logger(Node) ->
     {ok, Pwd} = file:get_cwd(),
-    FinalArgs = [Args, " -pa ", filename:dirname(code:which(?MODULE))],
-    {ok, Node} = test_server:start_node(Name, slave, [{args, FinalArgs}]),
-    LogPath = Pwd ++ "/error_log." ++ atom_to_list(Name),
+    Name = hd(string:lexemes(atom_to_list(Node), "@")),
+    LogPath = filename:join(Pwd, "error_log." ++ Name),
     ct:pal("Logging to: ~s", [LogPath]),
     rpc:call(Node, logger, add_handler, [file_handler, logger_std_h,
                                          #{formatter => {logger_formatter,#{ single_line => false }},
-                                           config => #{file => LogPath }}]),
-    {ok, Node}.
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
+                                           config => #{file => LogPath }}]).
 
 wait_deallocations() ->
     try
@@ -2776,7 +2712,8 @@ rpc(Config, Fun) ->
     case proplists:get_value(node, Config) of
         undefined ->
             Fun();
-        Node ->
+        {_Peer, Node} ->
+            io:format("Running RPC ~p on ~p/~p~n", [Fun, _Peer, Node]),
             Self = self(),
             Ref = make_ref(),
             Pid = spawn(Node,
diff --git a/erts/emulator/test/dump_SUITE.erl b/erts/emulator/test/dump_SUITE.erl
index 31a80434c7..e874c00b53 100644
--- a/erts/emulator/test/dump_SUITE.erl
+++ b/erts/emulator/test/dump_SUITE.erl
@@ -66,7 +66,7 @@ signal_abort(Config) ->
 
     Dump = filename:join(proplists:get_value(priv_dir, Config),"signal_abort.dump"),
 
-    {ok, Node} = start_node(Config),
+    {ok, _Peer, Node} = ?CT_PEER(),
 
     SO = rpc:call(Node, erlang, system_info, [schedulers_online]),
 
@@ -106,7 +106,7 @@ load() ->
 exiting_dump(Config) when is_list(Config) ->
     Dump = filename:join(proplists:get_value(priv_dir, Config),"signal_abort.dump"),
 
-    {ok, Node} = start_node(Config),
+    {ok, _Peer, Node} = ?CT_PEER(),
 
     Self = self(),
 
@@ -142,8 +142,8 @@ exiting_dump(Config) when is_list(Config) ->
 free_dump(Config) when is_list(Config) ->
     Dump = filename:join(proplists:get_value(priv_dir, Config),"signal_abort.dump"),
 
-    {ok, NodeA} = start_node(Config),
-    {ok, NodeB} = start_node(Config),
+    {ok, _PeerA, NodeA} = ?CT_PEER(),
+    {ok, PeerB, NodeB} = ?CT_PEER(),
 
     Self = self(),
 
@@ -197,7 +197,7 @@ free_dump(Config) when is_list(Config) ->
 
     unlink(PidB),
 
-    rpc:call(NodeB, erlang, halt, [0]),
+    peer:stop(PeerB),
 
     ok.
 
@@ -222,13 +222,3 @@ get_dump_when_done(Dump, Sz) ->
             get_dump_when_done(Dump, NewSz)
     end.
 
-start_node(Config) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-                        ++ "-"
-                        ++ atom_to_list(proplists:get_value(testcase, Config))
-                        ++ "-"
-                        ++ integer_to_list(erlang:system_time(second))
-                        ++ "-"
-                        ++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa}]).
diff --git a/erts/emulator/test/efile_SUITE.erl b/erts/emulator/test/efile_SUITE.erl
index 075051753b..26f0dd6052 100644
--- a/erts/emulator/test/efile_SUITE.erl
+++ b/erts/emulator/test/efile_SUITE.erl
@@ -52,11 +52,9 @@ iter_max_files_1(Config) ->
             N = 10
     end,
     %% Run on a different node in order to make the test more stable.
-    Dir = filename:dirname(code:which(?MODULE)),
-    {ok,Node} = test_server:start_node(test_iter_max_files,slave,
-                                       [{args,"-pa " ++ Dir}]),
+    {ok, Peer, Node} = ?CT_PEER(),
     L = rpc:call(Node,?MODULE,do_iter_max_files,[N, TestFile]),
-    test_server:stop_node(Node),
+    peer:stop(Peer),
     io:format("Number of files opened in each test:~n~w\n", [L]),
     verify_max_files(L),
     Head = hd(L),
diff --git a/erts/emulator/test/erl_link_SUITE.erl b/erts/emulator/test/erl_link_SUITE.erl
index 7e8a6b2d2c..45da19932d 100644
--- a/erts/emulator/test/erl_link_SUITE.erl
+++ b/erts/emulator/test/erl_link_SUITE.erl
@@ -111,8 +111,8 @@ links(Config) when is_list(Config) ->
 
 %% Tests distributed links
 dist_links(Config) when is_list(Config) ->
-    [NodeName] = get_names(1, dist_link),
-    {ok, Node} = start_node(NodeName),
+    {ok, _Peer, Node} = ?CT_PEER(),
+    rpc:call(Node, erts_debug, set_internal_state, [available_internal_state, true]),
     common_link_test(node(), Node),
     TP4 = spawn(?MODULE, test_proc, []),
     TP5 = spawn(?MODULE, test_proc, []),
@@ -174,11 +174,11 @@ common_link_test(NodeA, NodeB) ->
 
 %% Tests monitor of nodes
 monitor_nodes(Config) when is_list(Config) ->
-    [An, Bn, Cn, Dn] = get_names(4, dist_link),
-    {ok, A} = start_node(An),
-    {ok, B} = start_node(Bn),
-    C = list_to_atom(lists:concat([Cn, "@", hostname()])),
-    D = list_to_atom(lists:concat([Dn, "@", hostname()])),
+    {ok, PeerA, A} = ?CT_PEER(),
+    {ok, PeerB, B} = ?CT_PEER(),
+    [_, HostName] = string:lexemes(atom_to_list(node()), "@"),
+    C = list_to_atom(peer:random_name(?MODULE_STRING) ++ "@" ++ HostName),
+    D = list_to_atom(peer:random_name(?MODULE_STRING) ++ "@" ++ HostName),
     0 = no_of_monitor_node(self(), A),
     0 = no_of_monitor_node(self(), B),
     monitor_node(A, true),
@@ -212,11 +212,11 @@ monitor_nodes(Config) when is_list(Config) ->
     check_monitor_node(self(), C, 0),
     check_monitor_node(self(), D, 0),
 
-    stop_node(A),
+    peer:stop(PeerA),
     receive {nodedown, A} -> ok end,
     check_monitor_node(self(), A, 0),
     check_monitor_node(self(), B, 3),
-    stop_node(B),
+    peer:stop(PeerB),
     receive {nodedown, B} -> ok end,
     receive {nodedown, B} -> ok end,
     receive {nodedown, B} -> ok end,
@@ -235,7 +235,8 @@ process_monitors(Config) when is_list(Config) ->
     common_process_monitors(node(), node()),
     Mon1 = erlang:monitor(process,self()),
     [] = find_erl_monitor(self(), Mon1),
-    [Name] = get_names(1, process_monitors),
+    Name = list_to_atom(lists:concat([?FUNCTION_NAME,
+        integer_to_list(erlang:unique_integer([positive]))])),
     true = register(Name, self()),
     Mon2 = erlang:monitor(process, Name),
     [] = find_erl_monitor(self(), Mon2),
@@ -252,8 +253,8 @@ process_monitors(Config) when is_list(Config) ->
 
 %% Tests distributed process monitors
 dist_process_monitors(Config) when is_list(Config) -> 
-    [Name] = get_names(1,dist_process_monitors),
-    {ok, Node} = start_node(Name),
+    {ok, _Peer, Node} = ?CT_PEER(),
+    rpc:call(Node, erts_debug, set_internal_state, [available_internal_state, true]),
     common_process_monitors(node(), Node),
     TP1 = spawn(Node, ?MODULE, test_proc, []),
     R1 = erlang:monitor(process, TP1),
@@ -280,7 +281,8 @@ common_process_monitors(NodeA, NodeB) ->
     run_common_process_monitors(TP1, TP2),
     TP3 = spawn(NodeA, ?MODULE, test_proc, []),
     TP4 = spawn(NodeB, ?MODULE, test_proc, []),
-    [TP4N] = get_names(1, common_process_monitors),
+    TP4N = list_to_atom(lists:concat([?FUNCTION_NAME,
+        integer_to_list(erlang:unique_integer([positive]))])),
     true = tp_call(TP4, fun () -> register(TP4N,self()) end),
     run_common_process_monitors(TP3,
                                 case node() == node(TP4) of
@@ -337,8 +339,7 @@ busy_dist_port_monitor(Config) when is_list(Config) ->
                  _ -> false
              end,
 
-    [An] = get_names(1, busy_dist_port_monitor),
-    {ok, A} = start_node(An),
+    {ok, PeerA, A} = ?CT_PEER(),
     TP1 = spawn(A, ?MODULE, test_proc, []),
     %% Check monitor over busy port
     M1 = suspend_on_busy_test(A,
@@ -367,7 +368,7 @@ busy_dist_port_monitor(Config) when is_list(Config) ->
                                end
                        end),
     tp_cast(TP1, fun () -> exit(normal) end),
-    stop_node(A),
+    peer:stop(PeerA),
     stop_busy_dist_port_tracer(Tracer),
     ok.
 
@@ -379,8 +380,7 @@ busy_dist_port_link(Config) when is_list(Config) ->
                  _ -> false
              end,
 
-    [An] = get_names(1, busy_dist_port_link),
-    {ok, A} = start_node(An),
+    {ok, PeerA, A} = ?CT_PEER(),
     TP1 = spawn(A, ?MODULE, test_proc, []),
     %% Check link over busy port
     suspend_on_busy_test(A,
@@ -413,7 +413,7 @@ busy_dist_port_link(Config) when is_list(Config) ->
                                end
                        end),
     tp_cast(TP1, fun () -> exit(normal) end),
-    stop_node(A),
+    peer:stop(PeerA),
     stop_busy_dist_port_tracer(Tracer),
     ok.
 
@@ -422,10 +422,9 @@ otp_5772_link(Config) when is_list(Config) ->
     otp_5772_link_test(node()).
 
 otp_5772_dist_link(Config) when is_list(Config) ->
-    [An] = get_names(1, otp_5772_dist_link),
-    {ok, A} = start_node(An),
+    {ok, PeerA, A} = ?CT_PEER(),
     otp_5772_link_test(A),
-    stop_node(A).
+    peer:stop(PeerA).
 
 otp_5772_link_test(Node) ->
     Prio = process_flag(priority, high),
@@ -454,11 +453,9 @@ otp_5772_monitor(Config) when is_list(Config) ->
     otp_5772_monitor_test(node()).
 
 otp_5772_dist_monitor(Config) when is_list(Config) ->
-    [An] = get_names(1, otp_5772_dist_monitor),
-    {ok, A} = start_node(An),
+    {ok, PeerA, A} = ?CT_PEER(),
     otp_5772_monitor_test(A),
-    stop_node(A),
-    ok.
+    peer:stop(PeerA).
 
 otp_5772_monitor_test(Node) ->
     Prio = process_flag(priority, high),
@@ -482,8 +479,7 @@ otp_5772_monitor_test(Node) ->
     ok.
 
 otp_7946(Config) when is_list(Config) ->
-    [NodeName] = get_names(1, otp_7946),
-    {ok, Node} = start_node(NodeName),
+    {ok, _Peer, Node} = ?CT_PEER(),
     Proc = rpc:call(Node, erlang, whereis, [net_kernel]),
     Mon = erlang:monitor(process, Proc),
     rpc:cast(Node, erlang, halt, []),
@@ -504,10 +500,9 @@ otp_17127_local_link_with_simultaneous_link_unlink(Config) when is_list(Config)
     otp_17127_link_with_simultaneous_link_unlink_test(node(), node()).
 
 otp_17127_dist_link_with_simultaneous_link_unlink(Config) when is_list(Config) ->
-    [NodeName] = get_names(1, otp_17127),
-    {ok, Node} = start_node(NodeName),
+    {ok, Peer, Node} = ?CT_PEER(),
     Res = otp_17127_link_with_simultaneous_link_unlink_test(node(), Node),
-    stop_node(Node),
+    peer:stop(Peer),
     Res.
 
 otp_17127_link_with_simultaneous_link_unlink_test(NodeA, NodeB) ->
@@ -524,10 +519,10 @@ otp_17127_local_random(Config) when is_list(Config) ->
     otp_17127_random_test(node(), node(), 100).
 
 otp_17127_dist_random(Config) when is_list(Config) ->
-    [NodeName] = get_names(1, otp_17127),
-    {ok, Node} = start_node(NodeName),
+    {ok, Peer, Node} = ?CT_PEER(),
+    rpc:call(Node, erts_debug, set_internal_state, [available_internal_state, true]),
     Res = otp_17127_random_test(node(), Node, 20),
-    stop_node(Node),
+    peer:stop(Peer),
     Res.
 
 otp_17127_random_test(_NodeA, _NodeB, 0) ->
@@ -1182,48 +1177,6 @@ check_monitor_node(From, Node, No) when is_pid(From),
                   dir = target,
                   pid = From}] = find_erl_monitor({node(From), Node}, From).
 
-connection_id(Node) ->
-    try
-        erts_debug:get_internal_state({connection_id, Node})
-    catch
-        _:_ -> -1
-    end.
-
-hostname() ->
-    from($@, atom_to_list(node())).
-
-from(H, [H | T]) -> T;
-from(H, [_ | T]) -> from(H, T);
-from(_H, []) -> [].
-
-get_names(N, T) when is_atom(T) ->
-    get_names(N, T, []).
-get_names(0, _, Acc) ->
-    Acc;
-get_names(N, T, Acc) ->
-    get_names(N-1, T, [list_to_atom(atom_to_list(?MODULE)
-                                    ++ "-"
-                                    ++ atom_to_list(T)
-                                    ++ "-"
-                                    ++ integer_to_list(erlang:system_time(second))
-                                    ++ "-"
-                                    ++ integer_to_list(erlang:unique_integer([positive]))) | Acc]).
-
-start_node(Name) ->
-    start_node(Name, "").
-
-start_node(Name, Args) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Res = test_server:start_node(Name, slave, [{args,  Args ++ " -pa " ++ Pa}]),
-    {ok, Node} = Res,
-    rpc:call(Node, erts_debug, set_internal_state,
-             [available_internal_state, true]),
-    Res.
-
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 -define(COOKIE, '').
 -define(DOP_LINK,		1).
 -define(DOP_SEND,		2).
diff --git a/erts/emulator/test/erts_debug_SUITE.erl b/erts/emulator/test/erts_debug_SUITE.erl
index 79e2c9d02c..35205076af 100644
--- a/erts/emulator/test/erts_debug_SUITE.erl
+++ b/erts/emulator/test/erts_debug_SUITE.erl
@@ -260,30 +260,22 @@ instructions(Config) when is_list(Config) ->
 
 alloc_blocks_size(Config) when is_list(Config) ->
     F = fun(Args) ->
-                Node = start_slave(Args),
+                {ok, Peer, Node} = ?CT_PEER(Args),
                 ok = rpc:call(Node, ?MODULE, do_alloc_blocks_size, []),
-                true = test_server:stop_node(Node)
+                peer:stop(Peer)
         end,
     case test_server:is_asan() of
-	false -> F("+Meamax");
+	false -> F(["+Meamax"]);
 	true -> skip
     end,
-    F("+Meamin"),
-    F(""),
+    F(["+Meamin"]),
+    F([]),
     ok.
 
 do_alloc_blocks_size() ->
     _ = erts_debug:alloc_blocks_size(binary_alloc),
     ok.
 
-start_slave(Args) ->
-    Name = ?MODULE_STRING ++ "_slave",
-    Pa = filename:dirname(code:which(?MODULE)),
-    {ok, Node} = test_server:start_node(list_to_atom(Name),
-                                        slave,
-                                        [{args, "-pa " ++ Pa ++ " " ++ Args}]),
-    Node.
-
 id(I) ->
     I.
 
diff --git a/erts/emulator/test/exception_SUITE.erl b/erts/emulator/test/exception_SUITE.erl
index aa24fff57d..1730a71ae9 100644
--- a/erts/emulator/test/exception_SUITE.erl
+++ b/erts/emulator/test/exception_SUITE.erl
@@ -693,7 +693,7 @@ error_info(_Config) ->
                     end,
 
     %% Pick up external pid and port.
-    {ok, ExternalNode} = test_server:start_node(?FUNCTION_NAME, slave, []),
+    {ok, Peer, ExternalNode} = ?CT_PEER(),
     ExternalPid = rpc:call(ExternalNode, erlang, whereis, [code_server]),
     ExternalPort = hd(rpc:call(ExternalNode, erlang, ports, [])),
 
@@ -1307,7 +1307,7 @@ error_info(_Config) ->
     try
         do_error_info(L)
     after
-        test_server:stop_node(ExternalNode)
+        peer:stop(Peer)
     end.
 
 dead_process() ->
diff --git a/erts/emulator/test/float_SUITE.erl b/erts/emulator/test/float_SUITE.erl
index 4c450c4398..2c88a5608e 100644
--- a/erts/emulator/test/float_SUITE.erl
+++ b/erts/emulator/test/float_SUITE.erl
@@ -98,7 +98,7 @@ fp_drv_thread(Config) when is_list(Config) ->
     %% Run in a separate node since it used to crash the emulator...
     Parent = self(),
     DrvDir = proplists:get_value(data_dir, Config),
-    {ok,Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     Tester = spawn_link(Node,
                         fun () ->
                                 Parent !
@@ -107,7 +107,7 @@ fp_drv_thread(Config) when is_list(Config) ->
                                              DrvDir)}
                         end),
     Result = receive {Tester, Res} -> Res end,
-    stop_node(Node),
+    peer:stop(Peer),
     Result.
 
 fp_drv_test(Test, DrvDir) ->
@@ -285,21 +285,6 @@ cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig,
 
 id(I) -> I.
 
-start_node(Config) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-                        ++ "-"
-                        ++ atom_to_list(proplists:get_value(testcase, Config))
-                        ++ "-"
-                        ++ integer_to_list(erlang:system_time(second))
-                        ++ "-"
-                        ++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
-
 %% Test that operations that might hide infinite intermediate results
 %% do not supress the badarith.
 hidden_inf(Config) when is_list(Config) ->
diff --git a/erts/emulator/test/fun_SUITE.erl b/erts/emulator/test/fun_SUITE.erl
index 1a2c235d27..f22238d4c4 100644
--- a/erts/emulator/test/fun_SUITE.erl
+++ b/erts/emulator/test/fun_SUITE.erl
@@ -574,7 +574,7 @@ refc_ets_bag(F1, Options) ->
     ok.
 
 refc_dist(Config) when is_list(Config) ->
-    {ok,Node} = start_node(fun_SUITE_refc_dist),
+    {ok, Peer, Node} = ?CT_PEER(),
     process_flag(trap_exit, true),
     Pid = spawn_link(Node, fun() -> receive
                                         Fun when is_function(Fun) ->
@@ -595,7 +595,7 @@ refc_dist(Config) when is_list(Config) ->
     true = erlang:garbage_collect(),
     2 = fun_refc(F),
     refc_dist_send(Node, F),
-    test_server:stop_node(Node).
+    peer:stop(Peer).
 
 refc_dist_send(Node, F) ->
     Pid = spawn_link(Node, fun() -> receive
@@ -652,7 +652,7 @@ fun_refc(F) ->
     Count.
 
 const_propagation(Config) when is_list(Config) ->
-    Fun1 = fun start_node/1,
+    Fun1 = fun wait_until/1,
     2 = fun_refc(Fun1),
     Fun2 = Fun1,
     my_cmp({Fun1,Fun2}),
@@ -678,14 +678,14 @@ t_arity(Config) when is_list(Config) ->
 
     %% Test that the arity is transferred properly.
     process_flag(trap_exit, true),
-    {ok,Node} = start_node(fun_test_arity),
+    {ok, Peer, Node} = ?CT_PEER(),
     hello_world = spawn_call(Node, fun() -> hello_world end),
     0 = spawn_call(Node, fun(X) -> X end),
     42 = spawn_call(Node, fun(_X) -> A end),
     43 = spawn_call(Node, fun(X, Y) -> A+X+Y end),
     1 = spawn_call(Node, fun(X, Y) -> X+Y end),
     45 = spawn_call(Node, fun(X, Y, Z) -> A+X+Y+Z end),
-    test_server:stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 t_is_function2(Config) when is_list(Config) ->
@@ -868,12 +868,6 @@ fun_arity(F) ->
     {arity,Arity} = erlang:fun_info(F, arity),
     Arity.
 
-start_node(Name) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Cookie = atom_to_list(erlang:get_cookie()),
-    test_server:start_node(Name, slave, 
-			   [{args, "-setcookie " ++ Cookie ++" -pa " ++ Pa}]).
-
 wait_until(Fun) ->
     case catch Fun() of
 	true -> ok;
diff --git a/erts/emulator/test/hash_SUITE.erl b/erts/emulator/test/hash_SUITE.erl
index e8b284b2d0..7734c2d07f 100644
--- a/erts/emulator/test/hash_SUITE.erl
+++ b/erts/emulator/test/hash_SUITE.erl
@@ -563,12 +563,12 @@ last_byte(Bin) ->
 test_phash2_4GB_plus_bin(Config) when is_list(Config) ->
     run_when_enough_resources(
       fun() ->
-              {ok, N} = start_node(?FUNCTION_NAME),
+              {ok, Peer, N} = ?CT_PEER(),
               erpc:call(N,
                         fun() ->
                                 test_phash2_4GB_plus_bin_tc()
                         end),
-              stop_node(N)
+              peer:stop(Peer)
       end).
 
 test_phash2_4GB_plus_bin_tc() ->
@@ -721,36 +721,6 @@ total_memory() ->
             undefined
     end.
 
-start_node(X) ->
-    start_node(X, [], []).
-
-start_node(X, Y) ->
-    start_node(X, Y, []).
-
-start_node(Name, Args, Rel) when is_atom(Name), is_list(Rel) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Cookie = atom_to_list(erlang:get_cookie()),
-    RelArg = case Rel of
-                 [] -> [];
-                 _ -> [{erl,[{release,Rel}]}]
-             end,
-    test_server:start_node(Name, slave,
-                           [{args,
-                             Args++" -setcookie "++Cookie++" -pa \""++Pa++"\""}
-                            | RelArg]);
-start_node(Config, Args, Rel) when is_list(Config), is_list(Rel) ->
-    Name = list_to_atom((atom_to_list(?MODULE)
-                         ++ "-"
-                         ++ atom_to_list(proplists:get_value(testcase, Config))
-                         ++ "-"
-                         ++ integer_to_list(erlang:system_time(second))
-                         ++ "-"
-                         ++ integer_to_list(erlang:unique_integer([positive])))),
-    start_node(Name, Args, Rel).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 -ifdef(FALSE).
 f1() ->
     abc.
diff --git a/erts/emulator/test/hash_property_test_SUITE.erl b/erts/emulator/test/hash_property_test_SUITE.erl
index b4c7810a52..968c426811 100644
--- a/erts/emulator/test/hash_property_test_SUITE.erl
+++ b/erts/emulator/test/hash_property_test_SUITE.erl
@@ -81,23 +81,15 @@ test_phash2_no_diff_long(Config) when is_list(Config) ->
 
 test_phash2_no_diff_between_versions(Config) when is_list(Config) ->
     R = "21",
-    case test_server:is_release_available(R) of
-        true ->
-            Rel = {release,R},
-            case test_server:start_node(rel21,peer,[{erl,[Rel]}]) of
-                {error, Reason} -> {skip, io_lib:format("Could not start node: ~p~n", [Reason])};
-                {ok, Node} ->
-                    try
-                        true = ct_property_test:quickcheck(
-                                 phash2_properties:prop_phash2_same_in_different_versions(Node),
-                                 Config),
-                        true = ct_property_test:quickcheck(
-                                 phash2_properties:prop_phash2_same_in_different_versions_with_long_input(Node),
-                                 Config)
-                    after
-                        test_server:stop_node(Node)
-                    end
-            end;
-        false ->
+    case ?CT_PEER([], R, proplists:get_value(priv_dir, Config)) of
+        {ok, Peer, Node} ->
+            true = ct_property_test:quickcheck(
+                     phash2_properties:prop_phash2_same_in_different_versions(Node),
+                     Config),
+            true = ct_property_test:quickcheck(
+                     phash2_properties:prop_phash2_same_in_different_versions_with_long_input(Node),
+                     Config),
+            peer:stop(Peer);
+        not_available ->
             {skip, io_lib:format("Release ~s not available~n", [R])}
     end.
diff --git a/erts/emulator/test/list_bif_SUITE.erl b/erts/emulator/test/list_bif_SUITE.erl
index b398e22707..0295e48e97 100644
--- a/erts/emulator/test/list_bif_SUITE.erl
+++ b/erts/emulator/test/list_bif_SUITE.erl
@@ -143,7 +143,7 @@ t_list_to_ref(Config) when is_list(Config) ->
 
 %% Test list_to_pid/port/ref for external pids/ports/refs.
 t_list_to_ext_pidportref(Config) when is_list(Config) ->
-    {ok, Node} = slave:start(net_adm:localhost(), t_list_to_ext_pidportref),
+    {ok, Peer, Node} = ?CT_PEER(),
     Pid = rpc:call(Node, erlang, self, []),
     Port = hd(rpc:call(Node, erlang, ports, [])),
     Ref = rpc:call(Node, erlang, make_ref, []),
@@ -195,7 +195,7 @@ t_list_to_ext_pidportref(Config) when is_list(Config) ->
     true = rpc:call(Node, erlang, '=:=', [Ref, Ref0]),
     true = rpc:call(Node, erlang, '==',  [Ref, Ref0]),
 
-    slave:stop(Node),
+    peer:stop(Peer),
     ok.
 
 -define(NEW_PID_EXT, 88).
diff --git a/erts/emulator/test/lttng_SUITE.erl b/erts/emulator/test/lttng_SUITE.erl
index ceeff05e75..17e44b3ba4 100644
--- a/erts/emulator/test/lttng_SUITE.erl
+++ b/erts/emulator/test/lttng_SUITE.erl
@@ -298,14 +298,14 @@ chk_caller(Port, Callback, ExpectedCaller) ->
             ExpectedCaller = Caller
     end.
 
-ets_load(Config) ->
+ets_load(Config) when is_list(Config) ->
 
     %% Have to do on a fresh node to guarantee that carriers are created
-    {ok,Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
 
     Res = rpc:call(Node, ?MODULE, ets_load, []),
 
-    stop_node(Node),
+    peer:stop(Peer),
 
     Res.
 
@@ -447,19 +447,3 @@ cmd(Cmd) ->
     io:format(">> ~ts~n", [Res]),
     {ok,Res}.
 
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-"
-			++ integer_to_list(erlang:system_time(second))
-			++ "-"
-			++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/map_SUITE.erl b/erts/emulator/test/map_SUITE.erl
index daf3110b82..9cc954a937 100644
--- a/erts/emulator/test/map_SUITE.erl
+++ b/erts/emulator/test/map_SUITE.erl
@@ -90,6 +90,7 @@
          t_large_unequal_bins_same_hash_bug/1]).
 
 -include_lib("stdlib/include/ms_transform.hrl").
+-include_lib("common_test/include/ct.hrl").
 
 -define(CHECK(Cond,Term),
 	case (catch (Cond)) of
@@ -3250,8 +3251,7 @@ t_hash_entropy(Config) when is_list(Config)  ->
 %% Provoke major GC with a lot of "fat" maps on external format in msg queue
 %% causing heap fragments to be allocated.
 t_gc_rare_map_overflow(Config) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    {ok, Node} = test_server:start_node(gc_rare_map_overflow, slave, [{args, "-pa \""++Pa++"\""}]),
+    {ok, Peer, Node} = ?CT_PEER(),
     erts_debug:set_internal_state(available_internal_state, true),
     try
 	Echo = spawn_link(Node, fun Loop() -> receive {From,Msg} -> From ! Msg
@@ -3282,7 +3282,7 @@ t_gc_rare_map_overflow(Config) when is_list(Config) ->
     after
 	process_flag(trap_exit, false),
 	erts_debug:set_internal_state(available_internal_state, false),
-	test_server:stop_node(Node)
+	peer:stop(Peer)
     end.
 
 t_gc_rare_map_overflow_do(Echo, FatMap, GcFun) ->
diff --git a/erts/emulator/test/match_spec_SUITE.erl b/erts/emulator/test/match_spec_SUITE.erl
index 75aae473bd..7d7371665a 100644
--- a/erts/emulator/test/match_spec_SUITE.erl
+++ b/erts/emulator/test/match_spec_SUITE.erl
@@ -176,7 +176,7 @@ test_3(Config) when is_list(Config) ->
 %% Test that caller and return to work as they should
 %% There was a bug where caller would be undefined when return_to was set
 %% for r the bif erlang:put().
-caller_and_return_to(Config) ->
+caller_and_return_to(Config) when is_list(Config) ->
     tr(
       fun do_put_wrapper/0,
       fun (Tracee) ->
@@ -686,10 +686,9 @@ destructive_in_test_bif(Config) when is_list(Config) ->
 
 %% Test that the comparison between boxed and small does not crash emulator
 boxed_and_small(Config) when is_list(Config) ->
-    {ok, Node} = start_node(match_spec_suite_other),
+    {ok, Peer, Node} = ?CT_PEER(),
     ok = rpc:call(Node,?MODULE,do_boxed_and_small,[]),
-    stop_node(Node),
-    ok.
+    peer:stop(Peer).
 
 do_boxed_and_small() ->
     {ok, false, _, _} = erlang:match_spec_test({0,3},[{{1.47,'_'},[],['$_']}],table),
@@ -700,10 +699,9 @@ do_boxed_and_small() ->
 
 %% Test that faulty seq_trace_call does not crash emulator
 faulty_seq_trace(Config) when is_list(Config) ->
-    {ok, Node} = start_node(match_spec_suite_other),
+    {ok, Peer, Node} = ?CT_PEER(),
     ok = rpc:call(Node,?MODULE,do_faulty_seq_trace,[]),
-    stop_node(Node),
-    ok.
+    peer:stop(Peer).
 
 do_faulty_seq_trace() ->
     {ok,'EXIT',_,_} = erlang:match_spec_test([],[{'_',[],[{message,{set_seq_token,yxa,true}}]}],trace),
@@ -1154,12 +1152,3 @@ fbinmatch(<<>>, Acc) -> Acc.
 
 id(X) ->
     X.
-
-start_node(Name) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Cookie = atom_to_list(erlang:get_cookie()),
-    test_server:start_node(Name, slave, 
-                           [{args, "-setcookie " ++ Cookie ++" -pa " ++ Pa}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/message_queue_data_SUITE.erl b/erts/emulator/test/message_queue_data_SUITE.erl
index 90337b27b8..8dbfd6b3b1 100644
--- a/erts/emulator/test/message_queue_data_SUITE.erl
+++ b/erts/emulator/test/message_queue_data_SUITE.erl
@@ -53,13 +53,13 @@ basic(Config) when is_list(Config) ->
 
     basic_test(erlang:system_info(message_queue_data)),
 
-    {ok, Node1} = start_node(Config, "+hmqd off_heap"),
+    {ok, Peer1, Node1} = ?CT_PEER(["+hmqd", "off_heap"]),
     ok = rpc:call(Node1, ?MODULE, basic_test, [off_heap]),
-    stop_node(Node1),
+    peer:stop(Peer1),
 
-    {ok, Node2} = start_node(Config, "+hmqd on_heap"),
+    {ok, Peer2, Node2} = ?CT_PEER(["+hmqd", "on_heap"]),
     ok = rpc:call(Node2, ?MODULE, basic_test, [on_heap]),
-    stop_node(Node2),
+    peer:stop(Peer2),
 
     ok.
 
@@ -326,17 +326,3 @@ recv_msgs(Msgs) ->
     after 0 ->
 	    lists:reverse(Msgs)
     end.
-
-start_node(Config, Opts) when is_list(Config), is_list(Opts) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-"
-			++ integer_to_list(erlang:system_time(second))
-			++ "-"
-			++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, Opts++" -pa "++Pa}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/monitor_SUITE.erl b/erts/emulator/test/monitor_SUITE.erl
index 49fe788faf..4e5efa9244 100644
--- a/erts/emulator/test/monitor_SUITE.erl
+++ b/erts/emulator/test/monitor_SUITE.erl
@@ -36,7 +36,7 @@
 
 suite() ->
     [{ct_hooks,[ts_install_cth]},
-     {timetrap, {minutes, 15}}].
+     {timetrap, {seconds, 30}}].
 
 all() -> 
     [case_1, case_1a, case_2, case_2a, mon_e_1, demon_e_1,
@@ -141,13 +141,13 @@ expect_no_msg() ->
 %%% Error cases for monitor/2
 
 mon_e_1(Config) when is_list(Config) ->
-    {ok, N} = test_server:start_node(hej, slave, []),
+    {ok, Peer, N} = ?CT_PEER(),
     mon_error(plutt, self()),
     mon_error(process, [bingo]),
     mon_error(process, {rex, N, junk}),
     mon_error(process, 1),
 
-    true = test_server:stop_node(N),
+    peer:stop(Peer),
     ok.
 
 %%% We would also like to have a test case that tries to monitor something
@@ -169,7 +169,7 @@ mon_error(Type, Item) ->
 %%% Error cases for demonitor/1
 
 demon_e_1(Config) when is_list(Config) ->
-    {ok, N} = test_server:start_node(hej, slave, []),
+    {ok, Peer, N} = ?CT_PEER(),
     demon_error(plutt, badarg),
     demon_error(1, badarg),
 
@@ -192,7 +192,7 @@ demon_e_1(Config) when is_list(Config) ->
             ct:fail({rec, Other2})
     end,
 
-    true = test_server:stop_node(N),
+    peer:stop(Peer),
     ok.
 
 demon_error(Ref, Reason) ->
@@ -247,22 +247,22 @@ demon_2(Config) when is_list(Config) ->
 
 %% Distributed case for demonitor/1 (OTP-3499)
 demon_3(Config) when is_list(Config) ->
-    {ok, N} = test_server:start_node(hej, slave, []),
+    {ok, Peer, N} = ?CT_PEER(),
 
     %% 'DOWN' before demonitor
     P2 = spawn(N, timer, sleep, [100000]),
     R2 = erlang:monitor(process, P2),
-    true = test_server:stop_node(N),
+    peer:stop(Peer),
     true = erlang:demonitor(R2),
     expect_down(R2, P2, noconnection),
 
-    {ok, N2} = test_server:start_node(hej, slave, []),
+    {ok, Peer2, N2} = ?CT_PEER(),
 
     %% Demonitor before 'DOWN'
     P3 = spawn(N2, timer, sleep, [100000]),
     R3 = erlang:monitor(process, P3),
     true = erlang:demonitor(R3),
-    true = test_server:stop_node(N2),
+    peer:stop(Peer2),
     expect_no_msg(),
 
     ok.
@@ -271,9 +271,9 @@ demonitor_flush(Config) when is_list(Config) ->
     {'EXIT', {badarg, _}} = (catch erlang:demonitor(make_ref(), flush)),
     {'EXIT', {badarg, _}} = (catch erlang:demonitor(make_ref(), [flus])),
     {'EXIT', {badarg, _}} = (catch erlang:demonitor(x, [flush])),
-    {ok, N} = test_server:start_node(demonitor_flush, slave, []),
+    {ok, Peer, N} = ?CT_PEER(),
     ok = demonitor_flush_test(N),
-    true = test_server:stop_node(N),
+    peer:stop(Peer),
     ok = demonitor_flush_test(node()).
 
 demonitor_flush_test(Node) ->
@@ -336,7 +336,7 @@ local_remove_monitor(Config) when is_list(Config) ->
      "True = "++integer_to_list(True)++"; False = "++integer_to_list(False)}.
 
 remote_remove_monitor(Config) when is_list(Config) ->
-    {ok, N} = test_server:start_node(demonitor_flush, slave, []),
+    {ok, Peer, N} = ?CT_PEER(),
     Gs = generate(fun () -> start_remove_monitor_group(N) end,
                   ?RM_MON_GROUPS),
     {True, False} = lists:foldl(fun (G, {T, F}) ->
@@ -348,7 +348,7 @@ remote_remove_monitor(Config) when is_list(Config) ->
                                 {0, 0},
                                 Gs),
     erlang:display({remote_remove_monitor, True, False}),
-    true = test_server:stop_node(N),
+    peer:stop(Peer),
     {comment,
      "True = "++integer_to_list(True)++"; False = "++integer_to_list(False)}.
 
@@ -433,7 +433,7 @@ mon_1(Config) when is_list(Config) ->
 
 %% Distributed cases for monitor/2
 mon_2(Config) when is_list(Config) ->
-    {ok, N1} = test_server:start_node(hej1, slave, []),
+    {ok, Peer, N1} = ?CT_PEER(),
 
     %% Normal case
     P2 = spawn(N1, timer, sleep, [4000]),
@@ -454,7 +454,7 @@ mon_2(Config) when is_list(Config) ->
     P5 = spawn(N1, timer, sleep, [100000]),
     R5 = erlang:monitor(process, P5),
 
-    true = test_server:stop_node(N1),
+    peer:stop(Peer),
 
     expect_down(R5, P5, noconnection),
 
@@ -465,9 +465,7 @@ mon_2(Config) when is_list(Config) ->
     true = (R6_Reason == noconnection) orelse (R6_Reason == noproc),
 
     %% Start a new node that can load code in this module
-    PA = filename:dirname(code:which(?MODULE)),
-    {ok, N2} = test_server:start_node
-    (hej2, slave, [{args, "-pa " ++ PA}]),
+    {ok, Peer2, N2} = ?CT_PEER(),
 
     %% Normal case (named process)
     P7 = start_jeeves({jeeves, N2}),
@@ -489,7 +487,7 @@ mon_2(Config) when is_list(Config) ->
     _P10 = start_jeeves({jeeves, N2}),
     R10 = erlang:monitor(process, {jeeves, N2}),
 
-    true = test_server:stop_node(N2),
+    peer:stop(Peer2),
 
     expect_down(R10, {jeeves, N2}, noconnection),
 
@@ -542,7 +540,6 @@ large_exit_sub(S) ->
 list_cleanup(Config) when is_list(Config) ->
     P0 = self(),
     M  = node(),
-    PA = filename:dirname(code:which(?MODULE)),
     true = register(master_bertie, self()),
 
     %% Normal local case, monitor and demonitor
@@ -578,8 +575,7 @@ list_cleanup(Config) when is_list(Config) ->
     {[], []} = monitors(),
 
     %% Start a new node that can load code in this module
-    {ok, J} = test_server:start_node
-    (jeeves, slave, [{args, "-pa " ++ PA}]),
+    {ok, Peer, J} = ?CT_PEER(),
 
     %% Normal remote case, monitor and demonitor
     P3 = start_jeeves({jeeves, J}),
@@ -622,7 +618,7 @@ list_cleanup(Config) when is_list(Config) ->
     {[], [P5]} = monitors(),
     expect_jeeves(P5, monitors, 
                   {monitors, {[{process, P0}], []}} ),
-    test_server:stop_node(J),
+    peer:stop(Peer),
     timer:sleep(4000),
     {[], []} = monitors(),
 
@@ -633,12 +629,7 @@ list_cleanup(Config) when is_list(Config) ->
 %%% Mixed internal and external monitors
 
 mixer(Config) when is_list(Config) ->
-    PA = filename:dirname(code:which(?MODULE)),
-    NN = [j0,j1,j2],
-    NL0 = [begin
-               {ok, J} = test_server:start_node(X,slave,[{args, "-pa " ++ PA}]),
-               J
-           end  || X <- NN],
+    {_, Peers, NL0} = lists:unzip3([?CT_PEER() || _ <- lists:seq(1, 3)]),
     NL1 = lists:duplicate(2,node()) ++ NL0,
     Perm = perm(NL1),
     lists:foreach(
@@ -712,7 +703,7 @@ mixer(Config) when is_list(Config) ->
               [tell_jeeves(P,{exit,flaff}) || P <- Js]
       end,
       Perm),
-    [test_server:stop_node(K) || K <- NL0],
+    [peer:stop(P) || P <- Peers],
     ok.
 
 %% Test that DOWN message for a named monitor isn't
@@ -792,7 +783,7 @@ otp_5827(Config) when is_list(Config) ->
     end.
 
 monitor_time_offset(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config, "+C single_time_warp"),
+    {ok, Peer, Node} = ?CT_PEER(["+C", "single_time_warp"]),
     Me = self(),
     PMs = lists:map(fun (_) ->
                             Pid = spawn(Node,
@@ -822,7 +813,7 @@ monitor_time_offset(Config) when is_list(Config) ->
                                   ct:fail(Reason)
                           end
                   end, PMs),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 check_monitor_time_offset(Leader) ->
@@ -1182,22 +1173,3 @@ generate(_Fun, 0) ->
     [];
 generate(Fun, N) ->
     [Fun() | generate(Fun, N-1)].
-
-start_node(Config, Args) ->
-    TestCase = proplists:get_value(testcase, Config),
-    PA = filename:dirname(code:which(?MODULE)),
-    ESTime = erlang:monotonic_time(1) + erlang:time_offset(1),
-    Unique = erlang:unique_integer([positive]),
-    Name = list_to_atom(atom_to_list(?MODULE)
-                        ++ "-"
-                        ++ atom_to_list(TestCase)
-                        ++ "-"
-                        ++ integer_to_list(ESTime)
-                        ++ "-"
-                        ++ integer_to_list(Unique)),
-    test_server:start_node(Name,
-                           slave,
-                           [{args, "-pa " ++ PA ++ " " ++ Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/node_container_SUITE.erl b/erts/emulator/test/node_container_SUITE.erl
index 161968fe0d..618b2ec30d 100644
--- a/erts/emulator/test/node_container_SUITE.erl
+++ b/erts/emulator/test/node_container_SUITE.erl
@@ -151,8 +151,7 @@ ttbtteq_do_remote(RNode) ->
 %% Tests that node containers that are sent between nodes stay equal to themselves.
 round_trip_eq(Config) when is_list(Config) ->
     ThisNode = {node(), erlang:system_info(creation)},
-    NodeFirstName = get_nodefirstname(),
-    {ok, Node} = start_node(NodeFirstName),
+    {ok, Peer, Node} = ?CT_PEER(),
     Self = self(),
     RPid = spawn_link(Node,
                       fun () ->
@@ -186,7 +185,7 @@ round_trip_eq(Config) when is_list(Config) ->
                 RecLRef,
                 RecHLRef,
                 RecSRef}} ->
-            stop_node(Node),
+            stop_node(Peer, Node),
             SentPid = RecPid,
             SentXPid = RecXPid,
             SentPort = RecPort,
@@ -486,8 +485,7 @@ make_faked_pid_list(Start, No, Creation, Acc) ->
 %% Tests that external reference counts are incremented and decremented
 %% as they should for distributed links
 dist_link_refc(Config) when is_list(Config) ->
-    NodeFirstName = get_nodefirstname(),
-    {ok, Node} = start_node(NodeFirstName),
+    {ok, Peer, Node} = ?CT_PEER(),
     RP = spawn_execer(Node),
     LP = spawn_link_execer(node()),
     true = sync_exec(RP, fun () -> link(LP) end),
@@ -510,7 +508,7 @@ dist_link_refc(Config) when is_list(Config) ->
           refering_entity_id({process, LP},
                              get_node_references({Node, NodeCre}))),
     exit(LP, normal),
-    stop_node(Node),
+    stop_node(Peer, Node),
     nc_refc_check(node()),
     ok.
 
@@ -521,8 +519,7 @@ dist_link_refc(Config) when is_list(Config) ->
 %% Tests that external reference counts are incremented and decremented
 %% as they should for distributed monitors
 dist_monitor_refc(Config) when is_list(Config) ->
-    NodeFirstName = get_nodefirstname(),
-    {ok, Node} = start_node(NodeFirstName),
+    {ok, Peer, Node} = ?CT_PEER(),
     RP = spawn_execer(Node),
     LP = spawn_link_execer(node()),
     RMon = sync_exec(RP, fun () -> erlang:monitor(process, LP) end),
@@ -563,7 +560,7 @@ dist_monitor_refc(Config) when is_list(Config) ->
           refering_entity_id({process, LP},
                              get_node_references({Node, NodeCre}))),
     exit(LP, normal),
-    stop_node(Node),
+    stop_node(Peer, Node),
     nc_refc_check(node()),
     ok.
 
@@ -576,8 +573,7 @@ dist_monitor_refc(Config) when is_list(Config) ->
 node_controller_refc(Config) when is_list(Config) ->
     erts_debug:set_internal_state(available_internal_state, true),
     erts_debug:set_internal_state(node_tab_delayed_delete, 0),
-    NodeFirstName = get_nodefirstname(),
-    {ok, Node} = start_node(NodeFirstName),
+    {ok, Peer, Node} = ?CT_PEER(),
     true = lists:member(Node, nodes()),
     1 = reference_type_count(control, get_dist_references(Node)),
     P = spawn_link_execer(node()),
@@ -590,7 +586,7 @@ node_controller_refc(Config) when is_list(Config) ->
                 end),
     Creation = rpc:call(Node, erlang, system_info, [creation]),
     monitor_node(Node,true),
-    stop_node(Node),
+    stop_node(Peer, Node),
     receive {nodedown, Node} -> ok end,
     DistRefs = get_dist_references(Node),
     true = reference_type_count(node, DistRefs) > 0,
@@ -952,7 +948,7 @@ magic_ref(Config) when is_list(Config) ->
     ok.
 
 persistent_term(Config) when is_list(Config) ->
-    {ok, Node} = start_node(get_nodefirstname()),
+    {ok, Peer, Node} = ?CT_PEER(),
     Self = self(),
     NcData = make_ref(),
     RPid = spawn_link(Node,
@@ -964,7 +960,7 @@ persistent_term(Config) when is_list(Config) ->
                    {RPid, RPort, RRef}
            end,
     unlink(RPid),
-    stop_node(Node),
+    stop_node(Peer, Node),
     Stuff = lists:foldl(fun (N, Acc) ->
                                 persistent_term:put({?MODULE, N}, Data),
                                 persistent_term:erase({?MODULE, N-1}),
@@ -996,7 +992,7 @@ lost_pending_connection(Node) ->
 
 dist_entry_gc(Config) when is_list(Config) ->
     Me = self(),
-    {ok, Node} = start_node(get_nodefirstname(), "+zdntgc 0"),
+    {ok, Peer, Node} = ?CT_PEER(["+zdntgc", "0"]),
     P = spawn_link(Node,
                    fun () ->
                            LostNode = list_to_atom("lost_pending_connection@" ++ hostname()),
@@ -1008,15 +1004,16 @@ dist_entry_gc(Config) when is_list(Config) ->
         {P, ok} -> ok
     end,
     unlink(P),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 huge_ref(Config) when is_list(Config) ->
-    {ok, Node} = start_node(get_nodefirstname()),
+    {ok, Peer, Node} = ?CT_PEER(),
     HRef = mk_ref({Node, 4711}, [4711, 705676, 3456, 1000000, 3456]),
     io:format("HRef=~p~n", [HRef]),
     HRef = binary_to_term(term_to_binary(HRef)),
     HRef = erpc:call(Node, fun () -> HRef end),
+    peer:stop(Peer),
     ok.
 
 %%
@@ -1117,23 +1114,9 @@ reference_type_count(Type, ReferingEntities) when is_list(ReferingEntities) ->
                 0,
                 ReferingEntities).
 
-
-start_node(Name, Args) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Res = test_server:start_node(Name,
-                                 slave,
-                                 [{args, "-pa "++Pa++" "++Args}]),
-    {ok, Node} = Res,
-    rpc:call(Node, erts_debug, set_internal_state,
-             [available_internal_state, true]),
-    Res.
-
-start_node(Name) ->
-    start_node(Name, "").
-
-stop_node(Node) ->
+stop_node(Peer, Node) ->
     nc_refc_check(Node),
-    true = test_server:stop_node(Node).
+    peer:stop(Peer).
 
 hostname() ->
     from($@, atom_to_list(node())).
@@ -1155,9 +1138,6 @@ get_nodefirstname_string() ->
     ++ "-"
     ++ integer_to_list(erlang:unique_integer([positive])).
 
-get_nodefirstname() ->
-    list_to_atom(get_nodefirstname_string()).
-
 get_nodename() ->
     list_to_atom(get_nodefirstname_string()
                  ++ "@"
diff --git a/erts/emulator/test/persistent_term_SUITE.erl b/erts/emulator/test/persistent_term_SUITE.erl
index 0dad57e100..58b5c840f8 100644
--- a/erts/emulator/test/persistent_term_SUITE.erl
+++ b/erts/emulator/test/persistent_term_SUITE.erl
@@ -74,10 +74,10 @@ end_per_suite(Config) ->
 init_per_testcase(_, Config) ->
     Config.
 
-end_per_testcase(_, _Config) ->
-    ok;
 end_per_testcase(get_all_race, _Config) ->
     get_all_race_cleanup(),
+    ok;
+end_per_testcase(_, _Config) ->
     ok.
 
 basic(_Config) ->
diff --git a/erts/emulator/test/port_SUITE.erl b/erts/emulator/test/port_SUITE.erl
index e7f93b103e..364f238b6d 100644
--- a/erts/emulator/test/port_SUITE.erl
+++ b/erts/emulator/test/port_SUITE.erl
@@ -250,15 +250,9 @@ win_massive(Config) when is_list(Config) ->
 
 do_win_massive() ->
     ct:timetrap({minutes, 6}),
-    SuiteDir = filename:dirname(code:which(?MODULE)),
-    Ports = " +Q 8192",
-    {ok, Node} =
-    test_server:start_node(win_massive,
-                           slave,
-                           [{args, " -pa " ++ SuiteDir ++ Ports}]),
+    {ok, Peer, Node} = ?CT_PEER(["+Q", "8192"]),
     ok = rpc:call(Node,?MODULE,win_massive_client,[3000]),
-    test_server:stop_node(Node),
-    ok.
+    peer:stop(Peer).
 
 win_massive_client(N) ->
     {ok,P}=gen_tcp:listen(?WIN_MASSIVE_PORT,[{reuseaddr,true}]),
@@ -766,11 +760,9 @@ iter_max_ports_test(Config) ->
                 _ -> 10
             end,
     %% Run on a different node in order to limit the effect if this test fails.
-    Dir = filename:dirname(code:which(?MODULE)),
-    {ok,Node} = test_server:start_node(test_iter_max_socks,slave,
-                                       [{args,"+Q 2048 -pa " ++ Dir}]),
+    {ok, Peer, Node} = ?CT_PEER(["+Q", "2048"]),
     L = rpc:call(Node,?MODULE,do_iter_max_ports,[Iters, Command]),
-    test_server:stop_node(Node),
+    peer:stop(Peer),
 
     io:format("Result: ~p",[L]),
     all_equal(L),
@@ -1312,13 +1304,9 @@ otp_3906(Config, OSName) ->
                                        "test_server","variables"])),
     case lists:keysearch('CC', 1, Variables) of
         {value,{'CC', CC}} ->
-            SuiteDir = filename:dirname(code:which(?MODULE)),
             PrivDir = proplists:get_value(priv_dir, Config),
             Prog = otp_3906_make_prog(CC, PrivDir),
-            {ok, Node} = test_server:start_node(otp_3906,
-                                                slave,
-                                                [{args, " -pa " ++ SuiteDir},
-                                                 {linked, false}]),
+            {ok, Peer, Node} = ?CT_PEER(),
             OP = process_flag(priority, max),
             OTE = process_flag(trap_exit, true),
             FS = spawn_link(Node,
@@ -1347,7 +1335,7 @@ otp_3906(Config, OSName) ->
                      end,
             process_flag(trap_exit, OTE),
             process_flag(priority, OP),
-            test_server:stop_node(Node),
+            peer:stop(Peer),
             case Result of
                 succeded ->
                     ok;
diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index d484eb8e42..edb3fd4468 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -92,7 +92,7 @@
 
 suite() ->
     [{ct_hooks,[ts_install_cth]},
-     {timetrap, {minutes, 9}}].
+     {timetrap, {minutes, 2}}].
 
 all() ->
     [spawn_with_binaries, t_exit_1, {group, t_exit_2},
@@ -180,11 +180,11 @@ init_per_testcase(Func, Config)
     case erlang:system_info(build_type) of
         BT when BT =:= debug; BT =:= valgrind ->
             {skip, "Don't run in debug/valgrind"};
-        false ->
-            [{testcase, Func} | Config]
+        _ ->
+            Config
     end;
 init_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
-    [{testcase, Func}|Config].
+    Config.
 
 end_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
     %% Restore max_heap_size to default value.
@@ -653,7 +653,7 @@ process_info_other_dist_msg(Config) when is_list(Config) ->
     %% Check that process_info can handle messages that have not been
     %% decoded yet.
     %%
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     Self = self(),
     Pid = spawn_link(fun() -> other_process(Self) end),
     receive {go_ahead,Pid} -> ok end,
@@ -696,7 +696,7 @@ process_info_other_dist_msg(Config) when is_list(Config) ->
 	  end,
     {messages,[]} = process_info(Pid, messages),
     Pid ! stop,
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 process_info_other_status(Config) when is_list(Config) ->
@@ -1106,7 +1106,7 @@ process_info_smoke_all(Config) when is_list(Config) ->
                     magic_ref,
                     fullsweep_after],
 
-    {ok, Node} = start_node(Config, ""),
+    {ok, Peer, Node} = ?CT_PEER(),
     RP = spawn_link(Node, fun process_info_smoke_all_tester/0),
     LP = spawn_link(fun process_info_smoke_all_tester/0),
     RP ! {other_process, LP},
@@ -1126,7 +1126,7 @@ process_info_smoke_all(Config) when is_list(Config) ->
     exit(RP, kill),
     exit(LP, kill),
     false = is_process_alive(LP),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 process_info_status_handled_signal(Config) when is_list(Config) ->
@@ -1721,9 +1721,9 @@ otp_6237_select_loop() ->
 			     debug_level}).
 
 processes_large_tab(Config) when is_list(Config) ->
-    sys_mem_cond_run(2048, fun () -> processes_large_tab_test(Config) end).
+    sys_mem_cond_run(2048, fun () -> processes_large_tab_test() end).
 
-processes_large_tab_test(Config) ->
+processes_large_tab_test() ->
     enable_internal_state(),
     MaxDbgLvl = 20,
     MinProcTabSize = 2*(1 bsl 15),
@@ -1757,8 +1757,7 @@ processes_large_tab_test(Config) ->
 			    true -> MinProcTabSize;
 			    false -> ProcTabSize3
 			end,
-    {ok, LargeNode} = start_node(Config,
-				       "+P " ++ integer_to_list(ProcTabSize)),
+    {ok, Peer, LargeNode} = ?CT_PEER(["+P", integer_to_list(ProcTabSize)]),
     Res = rpc:call(LargeNode, ?MODULE, processes_bif_test, []),
     case rpc:call(LargeNode,
 			erts_debug,
@@ -1768,23 +1767,23 @@ processes_large_tab_test(Config) ->
 							    Chunks > 1 -> ok;
 	      PBInfo -> ct:fail(PBInfo)
 	  end,
-    stop_node(LargeNode),
+    stop_node(Peer, LargeNode),
     chk_processes_bif_test_res(Res).
 
 processes_default_tab(Config) when is_list(Config) ->
     sys_mem_cond_run(1024, fun () -> processes_default_tab_test(Config) end).
 
-processes_default_tab_test(Config) ->
-    {ok, DefaultNode} = start_node(Config, ""),
+processes_default_tab_test(Config) when is_list(Config) ->
+    {ok, Peer, DefaultNode} = ?CT_PEER(),
     Res = rpc:call(DefaultNode, ?MODULE, processes_bif_test, []),
-    stop_node(DefaultNode),
+    stop_node(Peer, DefaultNode),
     chk_processes_bif_test_res(Res).
 
 processes_small_tab(Config) when is_list(Config) ->
-    {ok, SmallNode} = start_node(Config, "+P 1024"),
+    {ok, Peer, SmallNode} = ?CT_PEER(["+P", "1024"]),
     Res    = rpc:call(SmallNode, ?MODULE, processes_bif_test, []),
     PBInfo = rpc:call(SmallNode, erts_debug, get_internal_state, [processes_bif_info]),
-    stop_node(SmallNode),
+    stop_node(Peer, SmallNode),
     true = PBInfo#ptab_list_bif_info.tab_chunks < 10,
     chk_processes_bif_test_res(Res).
 
@@ -2476,11 +2475,11 @@ spawn_huge_arglist(Config) when is_list(Config) ->
     spawn_huge_arglist_test(true, node(), ArgList),
     io:format("Testing spawn with huge argument list on local node with Node...~n", []),
     spawn_huge_arglist_test(false, node(), ArgList),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     _ = rpc:call(Node, ?MODULE, module_info, []),
     io:format("Testing spawn with huge argument list on remote node ~p...~n", [Node]),
     spawn_huge_arglist_test(false, Node, ArgList),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 spawn_huge_arglist_test(Local, Node, ArgList) ->
@@ -2562,10 +2561,10 @@ spawn_request_bif(Config) when is_list(Config) ->
     spawn_request_bif_test(true, node()),
     io:format("Testing spawn_request() on local node with Node...~n", []),
     spawn_request_bif_test(false, node()),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     io:format("Testing spawn_request() on remote node ~p...~n", [Node]),
     spawn_request_bif_test(false, Node),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
                        
 spawn_request_bif_test(Local, Node) ->
@@ -2834,7 +2833,7 @@ spawn_request_bif_test(Local, Node) ->
 
 
 spawn_request_monitor_demonitor(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     BlockFun = fun () ->
                        erts_debug:set_internal_state(available_internal_state, true),
                        erts_debug:set_internal_state(block, 1000),
@@ -2863,7 +2862,7 @@ spawn_request_monitor_demonitor(Config) when is_list(Config) ->
             exit(P, kill)
     end,
     erlang:display(done),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 spawn_request_monitor_child_exit(Config) when is_list(Config) ->
@@ -2877,7 +2876,7 @@ spawn_request_monitor_child_exit(Config) when is_list(Config) ->
                     {undef, _} = Reason1
             end
     end,
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     R2 = spawn_request(Node, nonexisting_module, nonexisting_function, [], [{reply_tag, Tag}, monitor]),
     receive
         {Tag, R2, ok, P2} ->
@@ -2886,7 +2885,7 @@ spawn_request_monitor_child_exit(Config) when is_list(Config) ->
                     {undef, _} = Reason2
             end
     end,
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 spawn_request_link_child_exit(Config) when is_list(Config) ->
@@ -2901,7 +2900,7 @@ spawn_request_link_child_exit(Config) when is_list(Config) ->
                     {undef, _} = Reason1
             end
     end,
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     R2 = spawn_request(Node, nonexisting_module, nonexisting_function, [], [link, {reply_tag, Tag}]),
     receive
         {Tag, R2, ok, P2} ->
@@ -2910,14 +2909,14 @@ spawn_request_link_child_exit(Config) when is_list(Config) ->
                     {undef, _} = Reason2
             end
     end,
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 spawn_request_link_parent_exit(Config) when is_list(Config) ->
     C1 = spawn_request_link_parent_exit_test(node()),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     C2 = spawn_request_link_parent_exit_test(Node),
-    stop_node(Node),
+    stop_node(Peer, Node),
     {comment, C1 ++ " " ++ C2}.
 
 spawn_request_link_parent_exit_test(Node) ->
@@ -2973,7 +2972,7 @@ spawn_request_link_parent_exit_test(Node) ->
     Comment.
 
 spawn_request_abandon_bif(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     false = spawn_request_abandon(make_ref()),
     false = spawn_request_abandon(spawn_request(fun () -> ok end)),
     false = spawn_request_abandon(rpc:call(Node, erlang, make_ref, [])),
@@ -3073,7 +3072,7 @@ spawn_request_abandon_bif(Config) when is_list(Config) ->
                   end,
                   lists:seq(1, TotOps)),
     0 = gather_parent_exits(abandoned, true),
-    stop_node(Node),
+    stop_node(Peer, Node),
     C = "Got " ++ integer_to_list(NoA1) ++ " and "
         ++ integer_to_list(NoA2) ++ " abandoneds of 2*"
         ++ integer_to_list(TotOps) ++ " ops!",
@@ -3103,7 +3102,7 @@ gather_parent_exits(Reason, AllowOther, N) ->
             N
     end.
 dist_spawn_monitor(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     R1 = spawn_request(Node, erlang, exit, [hej], [monitor]),
     receive
         {spawn_reply, R1, ok, P1} ->
@@ -3122,63 +3121,48 @@ dist_spawn_monitor(Config) when is_list(Config) ->
         {'DOWN', Mon3, process, P3, Reason3} ->
             hej = Reason3
     end,
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
     
 spawn_old_node(Config) when is_list(Config) ->
-    Cookie = atom_to_list(erlang:get_cookie()),
     Rel = "22_latest",
-    case test_server:is_release_available(Rel) of
-	false ->
+    case ?CT_PEER(#{connection => 0}, Rel, proplists:get_value(priv_dir, Config)) of
+	not_available ->
 	    {skipped, "No OTP 22 available"};
-        true ->
-	    {ok, OldNode} = test_server:start_node(make_nodename(Config),
-                                                   peer,
-                                                   [{args, " -setcookie "++Cookie},
-                                                    {erl, [{release, Rel}]}]),
-            try
-                %% Spawns triggering a new connection; which
-                %% will trigger hopeful data transcoding
-                %% of spawn requests...
-                io:format("~n~nDoing initial connect tests...~n", []),
-                spawn_old_node_test(OldNode, true),
-                %% Spawns on an already existing connection...
-                io:format("~n~nDoing already connected tests...~n", []),
-                spawn_old_node_test(OldNode, false)
-            after
-                test_server:stop_node(OldNode)
-            end,
-	    ok
+        {ok, Peer, OldNode} ->
+            %% Spawns triggering a new connection; which
+            %% will trigger hopeful data transcoding
+            %% of spawn requests...
+            io:format("~n~nDoing initial connect tests...~n", []),
+            spawn_old_node_test(OldNode, true),
+            %% Spawns on an already existing connection...
+            io:format("~n~nDoing already connected tests...~n", []),
+            spawn_old_node_test(OldNode, false),
+            peer:stop(Peer)
     end.
 
 spawn_new_node(Config) when is_list(Config) ->
-    Cookie = atom_to_list(erlang:get_cookie()),
     %% Test that the same operations as in spawn_old_node test
     %% works as expected on current OTP...
-    {ok, CurrNode} = test_server:start_node(make_nodename(Config),
-                                            peer,
-                                            [{args, " -setcookie "++Cookie}]),
-    try
-        %% Spawns triggering a new connection; which
-        %% will trigger hopeful data transcoding
-        %% of spawn requests...
-        io:format("~n~nDoing initial connect tests...~n", []),
-        spawn_current_node_test(CurrNode, true),
-        io:format("~n~nDoing already connected tests...~n", []),
-        %% Spawns on an already existing connection...
-        spawn_current_node_test(CurrNode, false)
-    after
-        test_server:stop_node(CurrNode)
-    end.
-
-disconnect_node(Node, Disconnect) ->
-    case Disconnect of
-        false ->
-            ok;
-        true ->
-            monitor_node(Node, true),
-            erlang:disconnect_node(Node),
-            receive {nodedown, Node} -> ok end
+    {ok, Peer, CurrNode} = ?CT_PEER(#{connection => 0}),
+
+    %% Spawns triggering a new connection; which
+    %% will trigger hopeful data transcoding
+    %% of spawn requests...
+    io:format("~n~nDoing initial connect tests...~n", []),
+    spawn_current_node_test(CurrNode, true),
+    io:format("~n~nDoing already connected tests...~n", []),
+    %% Spawns on an already existing connection...
+    spawn_current_node_test(CurrNode, false),
+    peer:stop(Peer).
+
+disconnect_node(_Node, false) ->
+    ok;
+disconnect_node(Node, true) ->
+    lists:member(Node, nodes()) andalso begin
+        monitor_node(Node, true),
+        true = erlang:disconnect_node(Node),
+        receive {nodedown, Node} -> ok end
     end.
 
 spawn_old_node_test(Node, Disconnect) ->
@@ -3269,11 +3253,11 @@ spawn_current_node_test(Node, Disconnect) ->
     end.
 
 spawn_request_reply_option(Config) when is_list(Config) ->
-    spawn_request_reply_option_test(node()),
-    {ok, Node} = start_node(Config),
-    spawn_request_reply_option_test(Node).
+    spawn_request_reply_option_test(undefined, node()),
+    {ok, Peer, Node} = ?CT_PEER(),
+    spawn_request_reply_option_test(Peer, Node).
     
-spawn_request_reply_option_test(Node) ->
+spawn_request_reply_option_test(Peer, Node) ->
     io:format("Testing on node: ~p~n", [Node]),
     Parent = self(),
     Done1 = make_ref(),
@@ -3336,7 +3320,7 @@ spawn_request_reply_option_test(Node) ->
         true ->
             ok;
         false ->
-            stop_node(Node),
+            stop_node(Peer, Node),
             RID9 = spawn_request(Node, fun () -> ok end, [{reply, yes}]),
             receive
                 {spawn_reply, RID9, error, noconnection} -> ok
@@ -3362,21 +3346,21 @@ processes_term_proc_list(Config) when is_list(Config) ->
     Tester = self(),
 
     Run = fun(Args) ->
-              {ok, Node} = start_node(Config, Args),
+              {ok, Peer, Node} = ?CT_PEER(Args),
               RT = spawn_link(Node, fun () ->
                               receive after 1000 -> ok end,
                               as_expected = processes_term_proc_list_test(false),
                               Tester ! {it_worked, self()}
                       end),
               receive {it_worked, RT} -> ok end,
-              stop_node(Node)
+              stop_node(Peer, Node)
           end,
 
     %% We have to run this test case with +S1 since instrument:allocations()
     %% will report a free()'d block as present until it's actually deallocated
     %% by its employer.
-    Run("+MSe true +Muatags false +S1"),
-    Run("+MSe true +Muatags true +S1"),
+    Run(["+MSe", "true", "+Muatags", "false", "+S1"]),
+    Run(["+MSe", "true", "+Muatags", "true", "+S1"]),
 
     ok.
 
@@ -4020,9 +4004,9 @@ otp_16642(Config) when is_list(Config) ->
 
 alias_bif(Config) when is_list(Config) ->
     alias_bif_test(node()),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     alias_bif_test(Node),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 alias_bif_test(Node) ->
@@ -4068,9 +4052,9 @@ alias_bif_test(Node) ->
 
 monitor_alias(Config) when is_list(Config) ->
     monitor_alias_test(node()),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     monitor_alias_test(Node),
-    stop_node(Node),
+    stop_node(Peer, Node),
     ok.
 
 monitor_alias_test(Node) ->
@@ -4154,21 +4138,21 @@ monitor_alias_test(Node) ->
 spawn_monitor_alias(Config) when is_list(Config) ->
     %% Exit signals with immediate exit reasons are sent
     %% in a different manner than compound exit reasons.
-    spawn_monitor_alias_test(node(), spawn_opt, normal),
-    spawn_monitor_alias_test(node(), spawn_opt, make_ref()),
-    spawn_monitor_alias_test(node(), spawn_request, normal),
-    spawn_monitor_alias_test(node(), spawn_request, make_ref()),
-    {ok, Node1} = start_node(Config),
-    spawn_monitor_alias_test(Node1, spawn_opt, normal),
-    {ok, Node2} = start_node(Config),    
-    spawn_monitor_alias_test(Node2, spawn_opt, make_ref()),
-    {ok, Node3} = start_node(Config),
-    spawn_monitor_alias_test(Node3, spawn_request, normal),
-    {ok, Node4} = start_node(Config),
-    spawn_monitor_alias_test(Node4, spawn_request, make_ref()),
+    spawn_monitor_alias_test(undefined, node(), spawn_opt, normal),
+    spawn_monitor_alias_test(undefined, node(), spawn_opt, make_ref()),
+    spawn_monitor_alias_test(undefined, node(), spawn_request, normal),
+    spawn_monitor_alias_test(undefined, node(), spawn_request, make_ref()),
+    {ok, Peer1, Node1} = ?CT_PEER(),
+    spawn_monitor_alias_test(Peer1, Node1, spawn_opt, normal),
+    {ok, Peer2, Node2} = ?CT_PEER(),
+    spawn_monitor_alias_test(Peer2, Node2, spawn_opt, make_ref()),
+    {ok, Peer3, Node3} = ?CT_PEER(),
+    spawn_monitor_alias_test(Peer3, Node3, spawn_request, normal),
+    {ok, Peer4, Node4} = ?CT_PEER(),
+    spawn_monitor_alias_test(Peer4, Node4, spawn_request, make_ref()),
     ok.
 
-spawn_monitor_alias_test(Node, SpawnType, ExitReason) ->
+spawn_monitor_alias_test(Peer, Node, SpawnType, ExitReason) ->
     Spawn = case SpawnType of
                 spawn_opt ->
                     fun (F, O) ->
@@ -4295,7 +4279,7 @@ spawn_monitor_alias_test(Node, SpawnType, ExitReason) ->
                                       receive after infinity -> ok end
                               end, [{monitor, [{alias, demonitor}]}]),
             P6 ! {alias, MA6},
-            stop_node(Node),
+            stop_node(Peer, Node),
             [{MA6,1},{MA6,2},{'DOWN', MA6, _, _, noconnection}] = recv_msgs(3),
             {_P6_1, M6_1} = spawn_monitor(fun () ->
                                                   MA6 ! {MA6, 3},
@@ -4311,33 +4295,33 @@ monitor_tag(Config) when is_list(Config) ->
     %% in a different manner than compound exit reasons, and
     %% immediate tags are stored in a different manner than
     %% compound tags.
-    monitor_tag_test(node(), spawn_opt, immed, normal),
-    monitor_tag_test(node(), spawn_opt, make_ref(), normal),
-    monitor_tag_test(node(), spawn_opt, immed, make_ref()),
-    monitor_tag_test(node(), spawn_opt, make_ref(), make_ref()),
-    monitor_tag_test(node(), spawn_request, immed, normal),
-    monitor_tag_test(node(), spawn_request, make_ref(), normal),
-    monitor_tag_test(node(), spawn_request, immed, make_ref()),
-    monitor_tag_test(node(), spawn_request, make_ref(), make_ref()),
-    {ok, Node1} = start_node(Config),
-    monitor_tag_test(Node1, spawn_opt, immed, normal),
-    {ok, Node2} = start_node(Config),
-    monitor_tag_test(Node2, spawn_opt, make_ref(), normal),
-    {ok, Node3} = start_node(Config),
-    monitor_tag_test(Node3, spawn_opt, immed, make_ref()),
-    {ok, Node4} = start_node(Config),
-    monitor_tag_test(Node4, spawn_opt, make_ref(), make_ref()),
-    {ok, Node5} = start_node(Config),
-    monitor_tag_test(Node5, spawn_request, immed, normal),
-    {ok, Node6} = start_node(Config),
-    monitor_tag_test(Node6, spawn_request, make_ref(), normal),
-    {ok, Node7} = start_node(Config),
-    monitor_tag_test(Node7, spawn_request, immed, make_ref()),
-    {ok, Node8} = start_node(Config),
-    monitor_tag_test(Node8, spawn_request, make_ref(), make_ref()),
+    monitor_tag_test(undefined, node(), spawn_opt, immed, normal),
+    monitor_tag_test(undefined, node(), spawn_opt, make_ref(), normal),
+    monitor_tag_test(undefined, node(), spawn_opt, immed, make_ref()),
+    monitor_tag_test(undefined, node(), spawn_opt, make_ref(), make_ref()),
+    monitor_tag_test(undefined, node(), spawn_request, immed, normal),
+    monitor_tag_test(undefined, node(), spawn_request, make_ref(), normal),
+    monitor_tag_test(undefined, node(), spawn_request, immed, make_ref()),
+    monitor_tag_test(undefined, node(), spawn_request, make_ref(), make_ref()),
+    {ok, Peer1, Node1} = ?CT_PEER(),
+    monitor_tag_test(Peer1, Node1, spawn_opt, immed, normal),
+    {ok, Peer2, Node2} = ?CT_PEER(),
+    monitor_tag_test(Peer2, Node2, spawn_opt, make_ref(), normal),
+    {ok, Peer3, Node3} = ?CT_PEER(),
+    monitor_tag_test(Peer3, Node3, spawn_opt, immed, make_ref()),
+    {ok, Peer4, Node4} = ?CT_PEER(),
+    monitor_tag_test(Peer4, Node4, spawn_opt, make_ref(), make_ref()),
+    {ok, Peer5, Node5} = ?CT_PEER(),
+    monitor_tag_test(Peer5, Node5, spawn_request, immed, normal),
+    {ok, Peer6, Node6} = ?CT_PEER(),
+    monitor_tag_test(Peer6, Node6, spawn_request, make_ref(), normal),
+    {ok, Peer7, Node7} = ?CT_PEER(),
+    monitor_tag_test(Peer7, Node7, spawn_request, immed, make_ref()),
+    {ok, Peer8, Node8} = ?CT_PEER(),
+    monitor_tag_test(Peer8, Node8, spawn_request, make_ref(), make_ref()),
     ok.
 
-monitor_tag_test(Node, SpawnType, Tag, ExitReason) ->
+monitor_tag_test(Peer, Node, SpawnType, Tag, ExitReason) ->
 
     P1 = spawn(Node, fun () -> receive go -> ok end, exit(ExitReason) end),
     M1 = monitor(process, P1, [{tag, Tag}]),
@@ -4383,7 +4367,7 @@ monitor_tag_test(Node, SpawnType, Tag, ExitReason) ->
         false ->
             {P3, M3} = Spawn(fun () -> receive after infinity -> ok end end,
                              [{monitor, [{tag, Tag}]}]),
-            stop_node(Node),
+            stop_node(Peer, Node),
             [{Tag, M3, process, P3, noconnection}] = recv_msgs(1),
 
             case SpawnType == spawn_opt of
@@ -4426,27 +4410,10 @@ tok_loop(hopp) ->
 
 id(I) -> I.
 
-make_nodename(Config) when is_list(Config) ->
-    list_to_atom(atom_to_list(?MODULE)
-                 ++ "-"
-                 ++ atom_to_list(proplists:get_value(testcase, Config))
-                 ++ "-"
-                 ++ integer_to_list(erlang:system_time(second))
-                 ++ "-"
-                 ++ integer_to_list(erlang:unique_integer([positive]))).
-    
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = make_nodename(Config),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
-
-stop_node(Node) ->
+stop_node(Peer, Node) ->
     verify_nc(node()),
     verify_nc(Node),
-    test_server:stop_node(Node).
+    peer:stop(Peer).
 
 verify_nc(Node) ->
     P = self(),
diff --git a/erts/emulator/test/ref_SUITE.erl b/erts/emulator/test/ref_SUITE.erl
index a3fb96a6aa..be49f1db53 100644
--- a/erts/emulator/test/ref_SUITE.erl
+++ b/erts/emulator/test/ref_SUITE.erl
@@ -132,7 +132,7 @@ external_size(Config) when is_list(Config) ->
     %% matches what the documentation say in the advanced chapter of the
     %% efficiency guide. Note that the values in the efficiency guide
     %% also add the word referencing the heap structure.
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
 
     %% Ordinary external reference
     ORef = check_external_size(erpc:call(Node, fun () -> make_ref() end)),
@@ -145,7 +145,7 @@ external_size(Config) when is_list(Config) ->
     io:format("PRef = ~p~n", [PRef]),
 
 
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 check_external_size(Ref) when is_reference(Ref) ->
@@ -165,25 +165,3 @@ check_external_size(Ref) when is_reference(Ref) ->
                     error({internal_ref_size_out_of_range, Sz})
             end
     end.
-
-%% Internal stuff...
-
-make_nodename(Config) when is_list(Config) ->
-    list_to_atom(atom_to_list(?MODULE)
-                 ++ "-"
-                 ++ atom_to_list(proplists:get_value(testcase, Config))
-                 ++ "-"
-                 ++ integer_to_list(erlang:system_time(second))
-                 ++ "-"
-                 ++ integer_to_list(erlang:unique_integer([positive]))).
-    
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = make_nodename(Config),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/scheduler_SUITE.erl b/erts/emulator/test/scheduler_SUITE.erl
index faf16a96ef..d514672c15 100644
--- a/erts/emulator/test/scheduler_SUITE.erl
+++ b/erts/emulator/test/scheduler_SUITE.erl
@@ -276,7 +276,7 @@ bound_loop(NS, N, M, Sched) ->
 
 
 -define(TOPOLOGY_A_CMD,
-	"+sct"
+	["+sct"
 	"L0-1t0-1c0p0n0"
 	":L2-3t0-1c1p0n0"
 	":L4-5t0-1c0p1n0"
@@ -284,7 +284,7 @@ bound_loop(NS, N, M, Sched) ->
 	":L8-9t0-1c0p2n1"
 	":L10-11t0-1c1p2n1"
 	":L12-13t0-1c0p3n1"
-	":L14-15t0-1c1p3n1").
+	":L14-15t0-1c1p3n1"]).
 
 -define(TOPOLOGY_A_TERM,
 	[{node,[{processor,[{core,[{thread,{logical,0}},
@@ -305,7 +305,7 @@ bound_loop(NS, N, M, Sched) ->
 				   {thread,{logical,15}}]}]}]}]).
 
 -define(TOPOLOGY_B_CMD,
-	"+sct"
+	["+sct"
 	"L0-1t0-1c0n0p0"
 	":L2-3t0-1c1n0p0"
 	":L4-5t0-1c2n1p0"
@@ -313,7 +313,7 @@ bound_loop(NS, N, M, Sched) ->
 	":L8-9t0-1c0n2p1"
 	":L10-11t0-1c1n2p1"
 	":L12-13t0-1c2n3p1"
-	":L14-15t0-1c3n3p1").
+	":L14-15t0-1c3n3p1"]).
 
 -define(TOPOLOGY_B_TERM,
 	[{processor,[{node,[{core,[{thread,{logical,0}},
@@ -369,7 +369,7 @@ bound_loop(NS, N, M, Sched) ->
 
 
 -define(TOPOLOGY_C_CMD,
-	"+sct"
+	["+sct"
 	"L0-1t0-1c0p0n0"
 	":L2-3t0-1c1p0n0"
 	":L4-5t0-1c0p1n0"
@@ -385,7 +385,7 @@ bound_loop(NS, N, M, Sched) ->
 	":L24-25t0-1c0n4p5"
 	":L26-27t0-1c1n4p5"
 	":L28-29t0-1c2n5p5"
-	":L30-31t0-1c3n5p5").
+	":L30-31t0-1c3n5p5"]).
 
 -define(TOPOLOGY_D_TERM,
 	[{processor,[{node,[{core,[{thread,{logical,0}},
@@ -422,7 +422,7 @@ bound_loop(NS, N, M, Sched) ->
 				   {thread,{logical,31}}]}]}]}]).
 
 -define(TOPOLOGY_D_CMD,
-	"+sct"
+	["+sct"
 	"L0-1t0-1c0n0p0"
 	":L2-3t0-1c1n0p0"
 	":L4-5t0-1c2n1p0"
@@ -438,10 +438,10 @@ bound_loop(NS, N, M, Sched) ->
 	":L24-25t0-1c0p4n5"
 	":L26-27t0-1c1p4n5"
 	":L28-29t0-1c0p5n5"
-	":L30-31t0-1c1p5n5").
+	":L30-31t0-1c1p5n5"]).
 
 -define(TOPOLOGY_E_CMD,
-	"+sct"
+	["+sct"
 	"L0-1t0-1c0p0n0"
 	":L2-3t0-1c1p0n0"
 	":L4-5t0-1c2p0n0"
@@ -449,7 +449,7 @@ bound_loop(NS, N, M, Sched) ->
 	":L8-9t0-1c0p1n1"
 	":L10-11t0-1c1p1n1"
 	":L12-13t0-1c2p1n1"
-	":L14-15t0-1c3p1n1").
+	":L14-15t0-1c3p1n1"]).
 
 -define(TOPOLOGY_E_TERM,
 	[{node,[{processor,[{core,[{thread,{logical,0}},
@@ -470,7 +470,7 @@ bound_loop(NS, N, M, Sched) ->
 				   {thread,{logical,15}}]}]}]}]).
 
 -define(TOPOLOGY_F_CMD,
-	"+sct"
+	["+sct"
 	"L0-1t0-1c0n0p0"
 	":L2-3t0-1c1n0p0"
 	":L4-5t0-1c2n0p0"
@@ -486,7 +486,7 @@ bound_loop(NS, N, M, Sched) ->
 	":L24-25t0-1c12n3p0"
 	":L26-27t0-1c13n3p0"
 	":L28-29t0-1c14n3p0"
-	":L30-31t0-1c15n3p0").
+	":L30-31t0-1c15n3p0"]).
 
 -define(TOPOLOGY_F_TERM,
         [{processor,[{node,[{core,[{thread,{logical,0}},
@@ -543,27 +543,27 @@ bindings(Node, BindType) ->
 scheduler_bind_types(Config) when is_list(Config) ->
     OldRelFlags = clear_erl_rel_flags(),
     try
-	scheduler_bind_types_test(Config,
+	scheduler_bind_types_test(
 				  ?TOPOLOGY_A_TERM,
 				  ?TOPOLOGY_A_CMD,
 				  a),
-	scheduler_bind_types_test(Config,
+	scheduler_bind_types_test(
 				  ?TOPOLOGY_B_TERM,
 				  ?TOPOLOGY_B_CMD,
 				  b),
-	scheduler_bind_types_test(Config,
+	scheduler_bind_types_test(
 				  ?TOPOLOGY_C_TERM,
 				  ?TOPOLOGY_C_CMD,
 				  c),
-	scheduler_bind_types_test(Config,
+	scheduler_bind_types_test(
 				  ?TOPOLOGY_D_TERM,
 				  ?TOPOLOGY_D_CMD,
 				  d),
-	scheduler_bind_types_test(Config,
+	scheduler_bind_types_test(
 				  ?TOPOLOGY_E_TERM,
 				  ?TOPOLOGY_E_CMD,
 				  e),
-	scheduler_bind_types_test(Config,
+	scheduler_bind_types_test(
 				  ?TOPOLOGY_F_TERM,
 				  ?TOPOLOGY_F_CMD,
 				  f)
@@ -572,17 +572,17 @@ scheduler_bind_types(Config) when is_list(Config) ->
     end,
     ok.
 
-scheduler_bind_types_test(Config, Topology, CmdLine, TermLetter) ->
+scheduler_bind_types_test(Topology, CmdLine, TermLetter) ->
     io:format("Testing (~p): ~p~n", [TermLetter, Topology]),
-    {ok, Node0} = start_node(Config),
+    {ok, Peer, Node0} = ?CT_PEER(),
     _ = rpc:call(Node0, erlang, system_flag, [cpu_topology, Topology]),
     cmp(Topology, rpc:call(Node0, erlang, system_info, [cpu_topology])),
     check_bind_types(Node0, TermLetter),
-    stop_node(Node0),
-    {ok, Node1} = start_node(Config, CmdLine),
+    peer:stop(Peer),
+    {ok, Peer1, Node1} = ?CT_PEER(CmdLine),
     cmp(Topology, rpc:call(Node1, erlang, system_info, [cpu_topology])),
     check_bind_types(Node1, TermLetter),
-    stop_node(Node1).
+    peer:stop(Peer1).
 
 check_bind_types(Node, a) ->
     {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}
@@ -707,7 +707,6 @@ cpu_topology(Config) when is_list(Config) ->
     OldRelFlags = clear_erl_rel_flags(),
     try
         cpu_topology_test(
-          Config,
           [{node,[{processor,[{core,{logical,0}},
                               {core,{logical,1}}]}]},
            {processor,[{node,[{core,{logical,2}},
@@ -716,13 +715,12 @@ cpu_topology(Config) when is_list(Config) ->
                               {core,{logical,5}}]}]},
            {processor,[{node,[{core,{logical,6}},
                               {core,{logical,7}}]}]}],
-          "+sct "
+          ["+sct",
           "L0-1c0-1p0n0"
           ":L2-3c0-1n1p1"
           ":L4-5c0-1p2n2"
-          ":L6-7c0-1n3p3"),
+          ":L6-7c0-1n3p3"]),
         cpu_topology_test(
-          Config,
           [{node,[{processor,[{core,{logical,0}},
                               {core,{logical,1}}]},
                   {processor,[{core,{logical,2}},
@@ -739,7 +737,7 @@ cpu_topology(Config) when is_list(Config) ->
                               {core,{logical,13}}]},
                        {node,[{core,{logical,14}},
                               {core,{logical,15}}]}]}],
-          "+sct "
+          ["+sct",
           "L0-1c0-1p0n0"
           ":L2-3c0-1p1n0"
           ":L4-5c0-1n1p2"
@@ -747,9 +745,8 @@ cpu_topology(Config) when is_list(Config) ->
           ":L8-9c0-1p3n3"
           ":L10-11c0-1p4n3"
           ":L12-13c0-1n4p5"
-          ":L14-15c2-3n5p5"),
+          ":L14-15c2-3n5p5"]),
         cpu_topology_test(
-          Config,
           [{node,[{processor,[{core,{logical,0}},
                               {core,{logical,1}}]}]},
            {processor,[{node,[{core,{logical,2}},
@@ -762,39 +759,39 @@ cpu_topology(Config) when is_list(Config) ->
                               {core,{logical,9}}]}]},
            {processor,[{node,[{core,{logical,10}},
                               {core,{logical,11}}]}]}],
-          "+sct "
+          ["+sct",
           "L0-1c0-1p0n0"
           ":L2-3c0-1n1p1"
           ":L4-5c0-1n2p2"
           ":L6-7c0-1p3n3"
           ":L8-9c0-1p4n4"
-          ":L10-11c0-1n5p5")
+          ":L10-11c0-1n5p5"])
     after
         restore_erl_rel_flags(OldRelFlags)
     end,
     ok.
 
-cpu_topology_test(Config, Topology, Cmd) ->
+cpu_topology_test(Topology, Cmd) ->
     io:format("Testing~n ~p~n ~p~n", [Topology, Cmd]),
-    cpu_topology_bif_test(Config, Topology),
-    cpu_topology_cmdline_test(Config, Topology, Cmd),
+    cpu_topology_bif_test(Topology),
+    cpu_topology_cmdline_test(Topology, Cmd),
     ok.
 
-cpu_topology_bif_test(_Config, false) ->
+cpu_topology_bif_test(false) ->
     ok;
-cpu_topology_bif_test(Config, Topology) ->
-    {ok, Node} = start_node(Config),
+cpu_topology_bif_test(Topology) ->
+    {ok, Peer, Node} = ?CT_PEER(),
     _ = rpc:call(Node, erlang, system_flag, [cpu_topology, Topology]),
     cmp(Topology, rpc:call(Node, erlang, system_info, [cpu_topology])),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
-cpu_topology_cmdline_test(_Config, _Topology, false) ->
+cpu_topology_cmdline_test(_Topology, false) ->
     ok;
-cpu_topology_cmdline_test(Config, Topology, Cmd) ->
-    {ok, Node} = start_node(Config, Cmd),
+cpu_topology_cmdline_test(Topology, Cmd) ->
+    {ok, Peer, Node} = ?CT_PEER(Cmd),
     cmp(Topology, rpc:call(Node, erlang, system_info, [cpu_topology])),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 update_cpu_info(Config) when is_list(Config) ->
@@ -976,14 +973,14 @@ sct_cmd(Config) when is_list(Config) ->
     Topology = ?TOPOLOGY_A_TERM,
     OldRelFlags = clear_erl_rel_flags(),
     try
-	{ok, Node} = start_node(Config, ?TOPOLOGY_A_CMD),
+	{ok, Peer, Node} = ?CT_PEER(?TOPOLOGY_A_CMD),
 	cmp(Topology,
 		  rpc:call(Node, erlang, system_info, [cpu_topology])),
 	cmp(Topology,
 		  rpc:call(Node, erlang, system_flag, [cpu_topology, Topology])),
 	cmp(Topology,
 		  rpc:call(Node, erlang, system_info, [cpu_topology])),
-	stop_node(Node)
+	peer:stop(Peer)
     after
 	restore_erl_rel_flags(OldRelFlags)
     end,
@@ -1013,7 +1010,7 @@ sbt_cmd(Config) when is_list(Config) ->
                     OldRelFlags = clear_erl_rel_flags(),
                     try
                         lists:foreach(fun ({ClBt, Bt}) ->
-                                              sbt_test(Config, CpuTCmd,
+                                              sbt_test(CpuTCmd,
                                                        ClBt, Bt, LP)
                                       end,
                                       ?BIND_TYPES)
@@ -1031,10 +1028,10 @@ sbt_make_topology_args() ->
                 linux ->
                     case erlang:system_info(logical_processors) of
                         1 ->
-                            "+sctL0";
+                            ["+sctL0"];
                         N ->
                             NS = integer_to_list(N - 1),
-                            "+sctL0-"++NS++"p0-"++NS
+                            ["+sctL0-"++NS++"p0-"++NS]
                     end;
                 _ ->
                     false
@@ -1078,11 +1075,11 @@ sbt_check_prereqs() ->
         throw:{skip,_Reason}=Skip -> Skip
     end.
 
-sbt_test(Config, CpuTCmd, ClBt, Bt, LP) ->
+sbt_test(CpuTCmd, ClBt, Bt, LP) ->
     io:format("Testing +sbt ~s (~p)~n", [ClBt, Bt]),
     LPS = integer_to_list(LP),
-    Cmd = CpuTCmd++" +sbt "++ClBt++" +S"++LPS++":"++LPS,
-    {ok, Node} = start_node(Config, Cmd),
+    Cmd = CpuTCmd++["+sbt", ClBt, "+S"++LPS++":"++LPS],
+    {ok, Peer, Node} = ?CT_PEER(Cmd),
     Bt = rpc:call(Node,
 			erlang,
 			system_info,
@@ -1106,16 +1103,16 @@ sbt_test(Config, CpuTCmd, ClBt, Bt, LP) ->
 		      end,
 		      BS,
 		      tuple_to_list(SB)),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 scheduler_threads(Config) when is_list(Config) ->
-    {Sched, SchedOnln, _} = get_sstate(Config, ""),
+    {Sched, SchedOnln, _} = get_sstate(""),
     %% Configure half the number of both the scheduler threads and
     %% the scheduler threads online.
     {HalfSched, HalfSchedOnln} = {lists:max([1,Sched div 2]),
                                   lists:max([1,SchedOnln div 2])},
-    {HalfSched, HalfSchedOnln, _} = get_sstate(Config, "+SP 50:50"),
+    {HalfSched, HalfSchedOnln, _} = get_sstate(["+SP", "50:50"]),
     %% Use +S to configure 4x the number of scheduler threads and
     %% 4x the number of scheduler threads online, but alter that
     %% setting using +SP to 50% scheduler threads and 25% scheduler
@@ -1124,19 +1121,19 @@ scheduler_threads(Config) when is_list(Config) ->
     TwiceSched = Sched*2,
     FourSched = integer_to_list(Sched*4),
     FourSchedOnln = integer_to_list(SchedOnln*4),
-    CombinedCmd1 = "+S "++FourSched++":"++FourSchedOnln++" +SP50:25",
-    {TwiceSched, SchedOnln, _} = get_sstate(Config, CombinedCmd1),
+    CombinedCmd1 = ["+S", FourSched++":"++FourSchedOnln, "+SP50:25"],
+    {TwiceSched, SchedOnln, _} = get_sstate(CombinedCmd1),
     %% Now do the same test but with the +S and +SP options in the
     %% opposite order, since order shouldn't matter.
-    CombinedCmd2 = "+SP50:25 +S "++FourSched++":"++FourSchedOnln,
-    {TwiceSched, SchedOnln, _} = get_sstate(Config, CombinedCmd2),
+    CombinedCmd2 = ["+SP50:25", "+S", FourSched++":"++FourSchedOnln],
+    {TwiceSched, SchedOnln, _} = get_sstate(CombinedCmd2),
     %% Apply two +SP options to make sure the second overrides the first
-    TwoCmd = "+SP 25:25 +SP 100:100",
-    {Sched, SchedOnln, _} = get_sstate(Config, TwoCmd),
+    TwoCmd = ["+SP", "25:25", "+SP", "100:100"],
+    {Sched, SchedOnln, _} = get_sstate(TwoCmd),
     %% Configure 50% of scheduler threads online only
-    {Sched, HalfSchedOnln, _} = get_sstate(Config, "+SP:50"),
+    {Sched, HalfSchedOnln, _} = get_sstate(["+SP:50"]),
     %% Configure 2x scheduler threads only
-    {TwiceSched, SchedOnln, _} = get_sstate(Config, "+SP 200"),
+    {TwiceSched, SchedOnln, _} = get_sstate(["+SP", "200"]),
 
     LProc = erlang:system_info(logical_processors),
     LProcAvail = erlang:system_info(logical_processors_available),
@@ -1150,30 +1147,30 @@ scheduler_threads(Config) when is_list(Config) ->
         is_integer(LProc); is_integer(LProcAvail) ->
             ExpectedOnln = st_expected_onln(LProcAvail, Quota),
 
-            st_reset(Config, LProc, ExpectedOnln, FourSched, FourSchedOnln),
+            st_reset(LProc, ExpectedOnln, FourSched, FourSchedOnln),
 
             if
                 LProc =:= 1; LProcAvail =:= 1 ->
                     {comment, "Skipped reduced amount of schedulers test due "
                               "to too few logical processors"};
                 LProc > 1, LProcAvail > 1 ->
-                    st_reduced(Config, LProc, ExpectedOnln)
+                    st_reduced(LProc, ExpectedOnln)
             end
     end.
 
-st_reset(Config, LProc, ExpectedOnln, FourSched, FourSchedOnln) ->
+st_reset(LProc, ExpectedOnln, FourSched, FourSchedOnln) ->
     %% Test resetting # of schedulers.
-    ResetCmd = "+S "++FourSched++":"++FourSchedOnln++" +S 0:0",
-    {LProc, ExpectedOnln, _} = get_sstate(Config, ResetCmd),
+    ResetCmd = ["+S", FourSched++":"++FourSchedOnln, "+S", "0:0"],
+    {LProc, ExpectedOnln, _} = get_sstate(ResetCmd),
     ok.
 
-st_reduced(Config, LProc, ExpectedOnln) ->
+st_reduced(LProc, ExpectedOnln) ->
     %% Test negative +S settings
     SchedMinus1 = LProc-1,
     SchedOnlnMinus1 = ExpectedOnln-1,
-    {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1"),
-    {LProc, SchedOnlnMinus1, _} = get_sstate(Config, "+S :-1"),
-    {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1:-1"),
+    {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(["+S", "-1"]),
+    {LProc, SchedOnlnMinus1, _} = get_sstate(["+S", ":-1"]),
+    {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(["+S", "-1:-1"]),
     ok.
 
 st_expected_onln(LProcAvail, unknown) -> LProcAvail;
@@ -1185,18 +1182,19 @@ dirty_scheduler_threads(Config) when is_list(Config) ->
         _ -> dirty_scheduler_threads_test(Config)
     end.
 
-dirty_scheduler_threads_test(Config) ->
-    {Sched, SchedOnln, _} = get_dsstate(Config, ""),
+dirty_scheduler_threads_test(Config) when is_list(Config) ->
+    {Sched, SchedOnln, _} = get_dsstate(""),
     {HalfSched, HalfSchedOnln} = {lists:max([1,Sched div 2]),
                                   lists:max([1,SchedOnln div 2])},
-    Cmd1 = "+SDcpu "++integer_to_list(HalfSched)++":"++
-	integer_to_list(HalfSchedOnln),
-    {HalfSched, HalfSchedOnln, _} = get_dsstate(Config, Cmd1),
-    {HalfSched, HalfSchedOnln, _} = get_dsstate(Config, "+SDPcpu 50:50"),
+    Cmd1 = ["+SDcpu", integer_to_list(HalfSched)++":"++
+	integer_to_list(HalfSchedOnln)],
+    {HalfSched, HalfSchedOnln, _} = get_dsstate(Cmd1),
+    {HalfSched, HalfSchedOnln, _} = get_dsstate(["+SDPcpu", "50:50"]),
     IOSched = 20,
-    {_, _, IOSched} = get_dsstate(Config, "+SDio "++integer_to_list(IOSched)),
-    {ok, Node} = start_node(Config, ""),
+    {_, _, IOSched} = get_dsstate(["+SDio", integer_to_list(IOSched)]),
+    {ok, Peer, Node} = ?CT_PEER(),
     [ok] = mcall(Node, [fun() -> dirty_schedulers_online_test() end]),
+    peer:stop(Peer),
     ok.
 
 dirty_schedulers_online_test() ->
@@ -1220,16 +1218,16 @@ dirty_schedulers_online_smp_test(SchedOnln) ->
     QrtrDirtyCPUSchedOnln = erlang:system_info(dirty_cpu_schedulers_online),
     ok.
 
-get_sstate(Config, Cmd) ->
-    {ok, Node} = start_node(Config, Cmd),
+get_sstate(Cmd) ->
+    {ok, Peer, Node} = ?CT_PEER(Cmd),
     [SState] = mcall(Node, [fun () ->
                                     erlang:system_info(schedulers_state)
                             end]),
-    stop_node(Node),
+    peer:stop(Peer),
     SState.
 
-get_dsstate(Config, Cmd) ->
-    {ok, Node} = start_node(Config, Cmd),
+get_dsstate(Cmd) ->
+    {ok, Peer, Node} = ?CT_PEER(Cmd),
     [DSCPU] = mcall(Node, [fun () ->
 				   erlang:system_info(dirty_cpu_schedulers)
 			   end]),
@@ -1239,7 +1237,7 @@ get_dsstate(Config, Cmd) ->
     [DSIO] = mcall(Node, [fun () ->
 				  erlang:system_info(dirty_io_schedulers)
 			  end]),
-    stop_node(Node),
+    peer:stop(Peer),
     {DSCPU, DSCPUOnln, DSIO}.
 
 scheduler_suspend_basic(Config) when is_list(Config) ->
@@ -1351,18 +1349,19 @@ scheduler_suspend_basic_test() ->
 
 scheduler_suspend(Config) when is_list(Config) ->
     ct:timetrap({minutes, 5}),
-    lists:foreach(fun (S) -> scheduler_suspend_test(Config, S) end,
+    lists:foreach(fun (S) -> scheduler_suspend_test(S) end,
 			[64, 32, 16, default]),
     ok.
-scheduler_suspend_test(Config, Schedulers) ->
+
+scheduler_suspend_test(Schedulers) ->
     Cmd = case Schedulers of
 		    default ->
 			"";
 		    _ ->
 			S = integer_to_list(Schedulers),
-			"+S"++S++":"++S
+			["+S"++S++":"++S]
 		end,
-    {ok, Node} = start_node(Config, Cmd),
+    {ok, Peer, Node} = ?CT_PEER(Cmd),
     [SState] = mcall(Node, [fun () ->
                                     erlang:system_info(schedulers_state)
                             end]),
@@ -1404,7 +1403,7 @@ scheduler_suspend_test(Config, Schedulers) ->
 								     native)),
 				    erlang:system_info(schedulers_state)
                             end]),
-    stop_node(Node),
+    peer:stop(Peer),
     ok.
 
 until(Pred, MaxTime) ->
@@ -1494,58 +1493,52 @@ sst5_loop(N) ->
     sst5_loop(N-1).
 
 poll_threads(Config) when is_list(Config) ->
-    {Conc, PollType, KP} = get_ioconfig(Config),
-    {Sched, SchedOnln, _} = get_sstate(Config, ""),
+    [PS | _] = get_iostate(""),
+    Conc = proplists:get_value(concurrent_updates, PS),
 
-    [1, 1] = get_ionum(Config,"+IOt 2 +IOp 2"),
-    [1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 5 +IOp 5"),
-    [1, 1] = get_ionum(Config, "+S 2 +IOPt 100 +IOPp 100"),
+    [1, 1] = get_ionum(["+IOt", "2", "+IOp", "2"]),
+    [1, 1, 1, 1, 1] = get_ionum(["+IOt", "5", "+IOp", "5"]),
+    [1, 1] = get_ionum(["+S", "2", "+IOPt", "100", "+IOPp", "100"]),
 
     if
         Conc ->
 
-            [5] = get_ionum(Config,"+IOt 5 +IOp 1"),
-            [3, 2] = get_ionum(Config,"+IOt 5 +IOp 2"),
-            [2, 2, 2, 2, 2] = get_ionum(Config,"+IOt 10 +IOPp 50"),
+            [5] = get_ionum(["+IOt", "5", "+IOp", "1"]),
+            [3, 2] = get_ionum(["+IOt", "5", "+IOp", "2"]),
+            [2, 2, 2, 2, 2] = get_ionum(["+IOt", "10", "+IOPp", "50"]),
 
-            [2] = get_ionum(Config, "+S 2 +IOPt 100"),
-            [4] = get_ionum(Config, "+S 4 +IOPt 100"),
-            [4] = get_ionum(Config, "+S 4:2 +IOPt 100"),
-            [4, 4] = get_ionum(Config, "+S 8 +IOPt 100 +IOPp 25"),
+            [2] = get_ionum(["+S", "2", "+IOPt", "100"]),
+            [4] = get_ionum(["+S", "4", "+IOPt", "100"]),
+            [4] = get_ionum(["+S", "4:2", "+IOPt", "100"]),
+            [4, 4] = get_ionum(["+S", "8", "+IOPt", "100", "+IOPp", "25"]),
 
-            fail = get_ionum(Config, "+IOt 1 +IOp 2"),
+            fail = get_ionum(["+IOt", "1", "+IOp", "2"]),
 
             ok;
         not Conc ->
 
-            [1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 5 +IOp 1"),
-            [1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 5 +IOp 2"),
-            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 10 +IOPp 50"),
+            [1, 1, 1, 1, 1] = get_ionum(["+IOt", "5", "+IOp", "1"]),
+            [1, 1, 1, 1, 1] = get_ionum(["+IOt", "5", "+IOp", "2"]),
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] = get_ionum(["+IOt", "10", "+IOPp", "50"]),
 
-            [1, 1] = get_ionum(Config, "+S 2 +IOPt 100"),
-            [1, 1, 1, 1] = get_ionum(Config, "+S 4 +IOPt 100"),
-            [1, 1, 1, 1] = get_ionum(Config, "+S 4:2 +IOPt 100"),
-            [1, 1, 1, 1, 1, 1, 1, 1] = get_ionum(Config, "+S 8 +IOPt 100 +IOPp 25"),
+            [1, 1] = get_ionum(["+S", "2", "+IOPt", "100"]),
+            [1, 1, 1, 1] = get_ionum(["+S", "4", "+IOPt", "100"]),
+            [1, 1, 1, 1] = get_ionum(["+S", "4:2", "+IOPt", "100"]),
+            [1, 1, 1, 1, 1, 1, 1, 1] = get_ionum(["+S", "8", "+IOPt", "100"  "+IOPp", "25"]),
 
-            [1] = get_ionum(Config, "+IOt 1 +IOp 2"),
+            [1] = get_ionum(["+IOt", "1", "+IOp", "2"]),
 
             ok
     end,
 
-    fail = get_ionum(Config, "+IOt 1 +IOPp 101"),
-    fail = get_ionum(Config, "+IOt 0"),
-    fail = get_ionum(Config, "+IOPt 101"),
+    fail = get_ionum(["+IOt", "1", "+IOPp", "101"]),
+    fail = get_ionum(["+IOt", "0"]),
+    fail = get_ionum(["+IOPt", "101"]),
 
     ok.
 
-get_ioconfig(Config) ->
-    [PS | _] = get_iostate(Config, ""),
-    {proplists:get_value(concurrent_updates, PS),
-     proplists:get_value(primary, PS),
-     proplists:get_value(kernel_poll, PS)}.
-
-get_ionum(Config, Cmd) ->
-    case get_iostate(Config, Cmd) of
+get_ionum(Cmd) ->
+    case get_iostate(Cmd) of
         fail -> fail;
         PSs ->
             lists:reverse(
@@ -1553,18 +1546,17 @@ get_ionum(Config, Cmd) ->
                 [proplists:get_value(poll_threads, PS) || PS <- PSs]))
     end.
 
-get_iostate(Config, Cmd)->
-    case start_node(Config, Cmd) of
-        {ok, Node} ->
-            [IOStates] = mcall(Node,[fun () ->
-                                             erlang:system_info(check_io)
-                                     end]),
-            IO = [IOState || IOState <- IOStates,
-                             proplists:get_value(fallback, IOState) == false,
-                             proplists:get_value(poll_threads, IOState) /= 0],
-            stop_node(Node),
-            IO;
-        {error,timeout} ->
+get_iostate(Cmd)->
+    try
+        {ok, Peer, Node} = ?CT_PEER(#{connection => standard_io, args => Cmd}),
+        [IOStates] = mcall(Node,[fun () -> erlang:system_info(check_io) end]),
+        IO = [IOState || IOState <- IOStates,
+            proplists:get_value(fallback, IOState) == false,
+            proplists:get_value(poll_threads, IOState) /= 0],
+        peer:stop(Peer),
+        IO
+    catch
+        exit:{boot_failed, _} ->
             fail
     end.
 
@@ -2481,24 +2473,6 @@ active_schedulers() ->
 		enabled -> N
 	    end
     end.
-    
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-"
-			++ integer_to_list(erlang:system_time(second))
-			++ "-"
-			++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 
 enable_internal_state() ->
     case catch erts_debug:get_internal_state(available_internal_state) of
diff --git a/erts/emulator/test/send_term_SUITE.erl b/erts/emulator/test/send_term_SUITE.erl
index 6fa19c47d4..96ba172db9 100644
--- a/erts/emulator/test/send_term_SUITE.erl
+++ b/erts/emulator/test/send_term_SUITE.erl
@@ -212,14 +212,14 @@ make_expected_ext2term_drv([T|Ts]) ->
 %%
 
 generate_external_terms_files(BaseDir) ->
-    {ok,Node} = slave:start(hostname(), a_node),
+    {ok, Peer, Node} = ?CT_PEER(),
     RPid = rpc:call(Node, erlang, self, []),
     true = is_pid(RPid),
     RRef = rpc:call(Node, erlang, make_ref, []),
     true = is_reference(RRef),
     RPort = hd(rpc:call(Node, erlang, ports, [])),
     true = is_port(RPort),
-    slave:stop(Node),
+    peer:stop(Peer),
     Terms = [{4711, -4711, [an_atom, "a list"]},
              [1000000000000000000000,-1111111111111111, "blupp!", blipp],
              {RPid, {RRef, RPort}, self(), hd(erlang:ports()), make_ref()},
@@ -341,12 +341,3 @@ write_license(IoDev) ->
 	" * and needs to be consistent with each other.~n"
 	" */~n",
     io:format(IoDev, S, []).
-
-
-hostname() ->    
-    hostname(atom_to_list(node())).
-
-hostname([$@ | Hostname]) ->
-    list_to_atom(Hostname);
-hostname([_C | Cs]) ->
-    hostname(Cs).
diff --git a/erts/emulator/test/signal_SUITE.erl b/erts/emulator/test/signal_SUITE.erl
index 6d726289b6..66adf80d92 100644
--- a/erts/emulator/test/signal_SUITE.erl
+++ b/erts/emulator/test/signal_SUITE.erl
@@ -63,9 +63,9 @@ all() ->
 xm_sig_order(Config) when is_list(Config) ->
     LNode = node(),
     repeat(fun () -> xm_sig_order_test(LNode) end, 1000),
-    {ok, RNode} = start_node(Config),
+    {ok, Peer, RNode} = ?CT_PEER(),
     repeat(fun () -> xm_sig_order_test(RNode) end, 1000),
-    stop_node(RNode),
+    peer:stop(Peer),
     ok.
     
 
@@ -95,10 +95,9 @@ xm_sig_order_proc() ->
 kill2killed(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
     kill2killed_test(node()),
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     kill2killed_test(Node),
-    stop_node(Node),
-    ok.
+    peer:stop(Peer).
 
 kill2killed_test(Node) ->
     if Node == node() ->
@@ -237,17 +236,3 @@ repeat(_Fun, N) when is_integer(N), N =< 0 ->
 repeat(Fun, N) when is_integer(N)  ->
     Fun(),
     repeat(Fun, N-1).
-
-start_node(Config, Args) ->
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-" ++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-" ++ integer_to_list(erlang:system_time(second))
-			++ "-" ++ integer_to_list(erlang:unique_integer([positive]))),
-    Pa = filename:dirname(code:which(?MODULE)),
-    test_server:start_node(Name, slave, [{args,  "-pa " ++ Pa ++ " " ++ Args}]).
-
-start_node(Config) ->
-    start_node(Config, "").
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/smoke_test_SUITE.erl b/erts/emulator/test/smoke_test_SUITE.erl
index 5b46342127..fa8d742c03 100644
--- a/erts/emulator/test/smoke_test_SUITE.erl
+++ b/erts/emulator/test/smoke_test_SUITE.erl
@@ -24,29 +24,29 @@
 
 %-compile(export_all).
 -export([all/0, suite/0,
-	 init_per_testcase/2, end_per_testcase/2]).
+    init_per_testcase/2, end_per_testcase/2]).
 
 -export([boot_combo/1, native_atomics/1, jump_table/1]).
 
 suite() ->
-    [{ct_hooks,[ts_install_cth]},
-     {timetrap, {minutes, 2}}].
+    [{ct_hooks, [ts_install_cth]},
+        {timetrap, {minutes, 2}}].
 
-all() -> 
+all() ->
     [boot_combo, native_atomics, jump_table].
 
 init_per_testcase(boot_combo = Case, Config) when is_list(Config) ->
     case erlang:system_info(build_type) of
-	opt ->
-	    init_per_tc(Case, Config);
-	_ ->
-	    {skip,"Cannot test boot_combo in special builds since beam.* may not exist"}
+        opt ->
+            init_per_tc(Case, Config);
+        _ ->
+            {skip, "Cannot test boot_combo in special builds since beam.* may not exist"}
     end;
 init_per_testcase(Case, Config) when is_list(Config) ->
     init_per_tc(Case, Config).
 
 init_per_tc(Case, Config) ->
-    [{testcase, Case}|Config].
+    [{testcase, Case} | Config].
 
 end_per_testcase(_Case, Config) when is_list(Config) ->
     ok.
@@ -56,39 +56,31 @@ end_per_testcase(_Case, Config) when is_list(Config) ->
 %%%
 
 boot_combo(Config) when is_list(Config) ->
-    ZFlags = os:getenv("ERL_ZFLAGS", ""),
-    NOOP = fun () -> ok end,
-    A42 = fun () ->
-		  case erlang:system_info(threads) of
-		      true ->
-			  42 = erlang:system_info(thread_pool_size);
-		      false ->
-			  ok
-		  end
-	  end,
-    try
-	chk_boot(Config, "+Ktrue", NOOP),
-	chk_boot(Config, "+A42", A42),
-	chk_boot(Config, "+Ktrue +A42", A42),
-
-        WBTArgs = ["very_short", "short", "medium", "long", "very_long"],
-        WTArgs = ["very_low", "low", "medium", "high", "very_high"],
-        [chk_boot(Config,
-                 " +sbwt " ++ WBT ++
-                 " +sbwtdcpu " ++ WBT ++
-                 " +sbwtdio " ++ WBT ++
-                 " +swt " ++ WT ++
-                 " +swtdcpu " ++ WT ++
-                 " +swtdio " ++ WT, NOOP) || WBT <- WBTArgs,  WT <- WTArgs],
-
-        WSArgs = ["legacy", "default"],
-        [chk_boot(Config, " +sws " ++ WS, NOOP) || WS <- WSArgs],
-
-	%% A lot more combos could be implemented...
-	ok
-    after
-	os:putenv("ERL_ZFLAGS", ZFlags)
-    end.
+    NOOP = fun() -> ok end,
+    A42 = fun() ->
+        case erlang:system_info(threads) of
+            true ->
+                42 = erlang:system_info(thread_pool_size);
+            false ->
+                ok
+        end
+          end,
+
+    chk_boot(["+Ktrue"], NOOP),
+    chk_boot(["+A42"], A42),
+    chk_boot(["+Ktrue", "+A42"], A42),
+
+    WBTArgs = ["very_short", "short", "medium", "long", "very_long"],
+    WTArgs = ["very_low", "low", "medium", "high", "very_high"],
+    [chk_boot(["+sbwt", WBT,
+        "+sbwtdcpu", WBT,
+        "+sbwtdio", WBT,
+        "+swt", WT,
+        "+swtdcpu", WT,
+        "+swtdio", WT], NOOP) || WBT <- WBTArgs, WT <- WTArgs],
+
+    WSArgs = ["legacy", "default"],
+    [chk_boot(["+sws", WS], NOOP) || WS <- WSArgs].
 
 native_atomics(Config) when is_list(Config) ->
     NA32Key = "32-bit native atomics",
@@ -96,70 +88,55 @@ native_atomics(Config) when is_list(Config) ->
     DWNAKey = "Double word native atomics",
     EthreadInfo = erlang:system_info(ethread_info),
     io:format("~p~n", [EthreadInfo]),
-    {value,{NA32Key, NA32, _}} = lists:keysearch(NA32Key, 1, EthreadInfo),
-    {value,{NA64Key, NA64, _}} = lists:keysearch(NA64Key, 1, EthreadInfo),
-    {value,{DWNAKey, DWNA, _}} = lists:keysearch(DWNAKey, 1, EthreadInfo),
+    {value, {NA32Key, NA32, _}} = lists:keysearch(NA32Key, 1, EthreadInfo),
+    {value, {NA64Key, NA64, _}} = lists:keysearch(NA64Key, 1, EthreadInfo),
+    {value, {DWNAKey, DWNA, _}} = lists:keysearch(DWNAKey, 1, EthreadInfo),
     case {erlang:system_info(build_type), NA32, NA64, DWNA} of
-	{opt, "no", "no", _} ->
-	    ct:fail(optimized_smp_runtime_without_native_atomics);
-	_ ->
-	    {comment,
-	     NA32 ++ " 32-bit, "
-	     ++ NA64 ++ " 64-bit, and "
-	     ++ DWNA ++ " double word native atomics"}
+        {opt, "no", "no", _} ->
+            ct:fail(optimized_smp_runtime_without_native_atomics);
+        _ ->
+            {comment,
+                    NA32 ++ " 32-bit, "
+                    ++ NA64 ++ " 64-bit, and "
+                    ++ DWNA ++ " double word native atomics"}
     end.
 
 jump_table(Config) when is_list(Config) ->
     case erlang:system_info(beam_jump_table) of
-	true ->
-	    ok;
-	false ->
-	    case erlang:system_info(build_type) of
-		opt ->
-		    ct:fail(optimized_without_beam_jump_table);
-		BT ->
-		    {comment, "No beam jump table, but build type is " ++ atom_to_list(BT)}
-	    end
+        true ->
+            ok;
+        false ->
+            case erlang:system_info(build_type) of
+                opt ->
+                    ct:fail(optimized_without_beam_jump_table);
+                BT ->
+                    {comment, "No beam jump table, but build type is " ++ atom_to_list(BT)}
+            end
     end.
-	    
+
 
 %%%
 %%% Aux functions --------------------------------------------------------------
 %%%
 
-chk_boot(Config, Args, Fun) ->
-    true = os:putenv("ERL_ZFLAGS", Args),
+chk_boot(Args, Fun) ->
     Success = make_ref(),
     Parent = self(),
-    io:format("--- Testing ~s~n", [Args]),
-    {ok, Node} = start_node(Config),
-    Pid = spawn_link(Node, fun () ->
-				   Fun(),
-				   Parent ! {self(), Success}
-			   end),
+    io:format("--- Testing ~s~n", [lists:join(" ", Args)]),
+    {ok, Peer, Node} = ?CT_PEER(Args),
+    %% if spawn_link is used, race condition happens when
+    %%  remote process exits with 'noconnection' reason and fails
+    %%  the test case
+    Pid = spawn(Node, fun() ->
+        Fun(),
+        Parent ! {self(), Success}
+                           end),
     receive
-	{Pid, Success} ->
-	    Node = node(Pid),
-	    stop_node(Node),
-	    io:format("--- Success!~n", []),
-	    ok
+        {Pid, Success} ->
+            Node = node(Pid),
+            peer:stop(Peer),
+            io:format("--- Success!~n", []),
+            ok
     end.
 
-start_node(Config) ->
-    start_node(Config, "").
-
-start_node(Config, Args) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = list_to_atom(atom_to_list(?MODULE)
-	      ++ "-"
-	      ++ atom_to_list(proplists:get_value(testcase, Config))
-	      ++ "-"
-	      ++ integer_to_list(erlang:system_time(second))
-	      ++ "-"
-	      ++ integer_to_list(erlang:unique_integer([positive]))),
-    Opts = [{args, "-pa "++Pa++" "++Args}],
-    test_server:start_node(Name, slave, Opts).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
 
diff --git a/erts/emulator/test/system_info_SUITE.erl b/erts/emulator/test/system_info_SUITE.erl
index 7c547fde7a..0505302c57 100644
--- a/erts/emulator/test/system_info_SUITE.erl
+++ b/erts/emulator/test/system_info_SUITE.erl
@@ -502,16 +502,6 @@ mapn(_Fun, 0) ->
 mapn(Fun, N) ->
     [Fun(N) | mapn(Fun, N-1)].
 
-
-get_node_name(Config) ->
-    list_to_atom(atom_to_list(?MODULE)
-		 ++ "-"
-		 ++ atom_to_list(proplists:get_value(testcase, Config))
-		 ++ "-"
-		 ++ integer_to_list(erlang:system_time(second))
-		 ++ "-"
-		 ++ integer_to_list(erlang:unique_integer([positive]))).
-
 ets_count(Config) when is_list(Config) ->
     [ets_count_do([Type | Named])
      || Type <- [set, bag, duplicate_bag, ordered_set],
@@ -530,77 +520,33 @@ ets_count_do(Opts) ->
 
 %% Verify system_info(ets_limit) reflects max ETS table settings.
 ets_limit(Config0) when is_list(Config0) ->
-    Config = [{testcase,ets_limit}|Config0],
-    true = is_integer(get_ets_limit(Config)),
-    12345 = get_ets_limit(Config, 12345),
+    true = is_integer(get_ets_limit(0)),
+    12345 = get_ets_limit(12345),
     ok.
 
-get_ets_limit(Config) ->
-    get_ets_limit(Config, 0).
-get_ets_limit(Config, EtsMax) ->
+get_ets_limit(EtsMax) ->
     Envs = case EtsMax of
                0 -> [];
-               _ -> [{"ERL_MAX_ETS_TABLES", integer_to_list(EtsMax)}]
+               _ -> ["-env", "ERL_MAX_ETS_TABLES", integer_to_list(EtsMax)]
            end,
-    {ok, Node} = start_node_ets(Config, Envs),
-    Me = self(),
-    Ref = make_ref(),
-    spawn_link(Node,
-               fun() ->
-                       Res = erlang:system_info(ets_limit),
-                       unlink(Me),
-                       Me ! {Ref, Res}
-               end),
-    receive
-        {Ref, Res} ->
-            Res
-    end,
-    stop_node(Node),
+    {ok, Peer, Node} = ?CT_PEER(Envs),
+    Res = rpc:call(Node, erlang, system_info, [ets_limit]),
+    peer:stop(Peer),
     Res.
 
-start_node_ets(Config, Envs) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    test_server:start_node(get_node_name(Config), peer,
-			   [{args, "-pa "++Pa}, {env, Envs}]).
-
-start_node_atm(Config, AtomsMax) when is_list(Config) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    test_server:start_node(get_node_name(Config), peer,
-			   [{args, "-pa "++ Pa ++ AtomsMax}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
 
 %% Verify system_info(atom_limit) reflects max atoms settings
 %% (using " +t").
 atom_limit(Config0) when is_list(Config0) ->
-    Config = [{testcase,atom_limit}|Config0],
-    2186042 = get_atom_limit(Config, " +t 2186042 "),
-    ok.
-
-get_atom_limit(Config, AtomsMax) ->
-    {ok, Node} = start_node_atm(Config, AtomsMax),
-    Me = self(),
-    Ref = make_ref(),
-    spawn_link(Node,
-        fun() ->
-            Res = erlang:system_info(atom_limit),
-            unlink(Me),
-            Me ! {Ref, Res}
-        end),
-    receive
-        {Ref, Res} ->
-            Res
-    end,
-    stop_node(Node),
-    Res.
+    {ok, Peer, Node} = ?CT_PEER(["+t", "2186042"]),
+    2186042 = rpc:call(Node, erlang, system_info, [atom_limit]),
+    peer:stop(Peer).
 
 %% Verify that system_info(atom_count) works.
 atom_count(Config) when is_list(Config) ->
     Limit = erlang:system_info(atom_limit),
     Count1 = erlang:system_info(atom_count),
-    list_to_atom(integer_to_list(erlang:unique_integer())),
+    _ = list_to_atom(integer_to_list(erlang:unique_integer())),
     Count2 = erlang:system_info(atom_count),
     true = Limit >= Count2,
     true = Count2 > Count1,
diff --git a/erts/emulator/test/time_SUITE.erl b/erts/emulator/test/time_SUITE.erl
index e01efac86b..41f3517815 100644
--- a/erts/emulator/test/time_SUITE.erl
+++ b/erts/emulator/test/time_SUITE.erl
@@ -108,9 +108,7 @@ local_to_univ_utc(Config) when is_list(Config) ->
     case os:type() of
 	{unix,_} ->
 	    %% TZ variable has a meaning
-	    {ok, Node} =
-		test_server:start_node(local_univ_utc,peer,
-				       [{args, "-env TZ UTC"}]),
+	    {ok, Peer, Node} = ?CT_PEER(["-env", "TZ", "UTC"]),
 	    {{2008,8,1},{0,0,0}} =
 		rpc:call(Node,
 			 erlang,localtime_to_universaltime,
@@ -125,8 +123,7 @@ local_to_univ_utc(Config) when is_list(Config) ->
 		rpc:call(Node,
 			 calendar,local_time_to_universal_time_dst,
 			 [{{2008, 8, 1}, {0, 0, 0}}]),
-	    test_server:stop_node(Node),
-	    ok;
+	    peer:stop(Peer);
 	_ ->
 	    {skip,"Only valid on Unix"}
     end.
@@ -431,41 +428,39 @@ now_update1(0) ->
 time_warp_modes(Config) when is_list(Config) ->
     %% All time warp modes always supported in
     %% combination with no time correction...
-    check_time_warp_mode(Config, false, no_time_warp),
-    check_time_warp_mode(Config, false, single_time_warp),
-    check_time_warp_mode(Config, false, multi_time_warp),
+    check_time_warp_mode(false, no_time_warp),
+    check_time_warp_mode(false, single_time_warp),
+    check_time_warp_mode(false, multi_time_warp),
 
     erts_debug:set_internal_state(available_internal_state, true),
     try
 	case erts_debug:get_internal_state({check_time_config,
 					    true, no_time_warp}) of
 	    false -> ok;
-	    true -> check_time_warp_mode(Config, true, no_time_warp)
+	    true -> check_time_warp_mode(true, no_time_warp)
 	end,
 	case erts_debug:get_internal_state({check_time_config,
 					    true, single_time_warp}) of
 	    false -> ok;
-	    true -> check_time_warp_mode(Config, true, single_time_warp)
+	    true -> check_time_warp_mode(true, single_time_warp)
 	end,
 	case erts_debug:get_internal_state({check_time_config,
 					    true, multi_time_warp}) of
 	    false -> ok;
-	    true -> check_time_warp_mode(Config, true, multi_time_warp)
+	    true -> check_time_warp_mode(true, multi_time_warp)
 	end
     after
 	erts_debug:set_internal_state(available_internal_state, false)
     end.
 
-check_time_warp_mode(Config, TimeCorrection, TimeWarpMode) ->
+check_time_warp_mode(TimeCorrection, TimeWarpMode) ->
     io:format("~n~n~n***** Testing TimeCorrection=~p TimeWarpMode=~p *****~n",
 	      [TimeCorrection, TimeWarpMode]),
     Mon = erlang:monitor(time_offset, clock_service),
     _ = erlang:time_offset(),
     Start = erlang:monotonic_time(1000),
     MonotonicityTimeout = 2000,
-    {ok, Node} = start_node(Config,
-			    "+c " ++ atom_to_list(TimeCorrection)
-			    ++ " +C " ++ atom_to_list(TimeWarpMode)),
+    {ok, Peer, Node} = ?CT_PEER(["+c", atom_to_list(TimeCorrection), "+C", atom_to_list(TimeWarpMode)]),
     StartTime = rpc:call(Node, erlang, system_info, [start_time]),
     Me = self(),
     MonotincityTestStarted = make_ref(),
@@ -494,7 +489,7 @@ check_time_warp_mode(Config, TimeCorrection, TimeWarpMode) ->
 					      millisecond),
     io:format("UpMilliSeconds=~p~n", [UpMilliSeconds]),
     End = erlang:monotonic_time(millisecond),
-    stop_node(Node),
+    peer:stop(Peer),
     try
 	true = (UpMilliSeconds > (98*MonotonicityTimeout) div 100),
 	true = (UpMilliSeconds < (102*(End-Start)) div 100)
@@ -867,6 +862,12 @@ test_data() ->
 		case os:cmd("date '+%Z'") of
 		    "SAST"++_ ->
 			{2,2};
+                    "PDT"++_ ->
+                        {-8,-7};
+                    "PST"++_ ->
+                        {-8,-7};
+                    "UTC"++_ ->
+                        {0,0};
 		    _ ->
 			{?timezone,?dst_timezone}
 		end;
@@ -992,22 +993,3 @@ bad_dates() ->
 
      {{1996, 4, 30}, {12, 0, -1}},		% Sec
      {{1996, 4, 30}, {12, 0, 60}}].
-
-start_node(Config, Args) ->
-    TestCase = proplists:get_value(testcase, Config),
-    PA = filename:dirname(code:which(?MODULE)),
-    ESTime = erlang:monotonic_time(1) + erlang:time_offset(1),
-    Unique = erlang:unique_integer([positive]),
-    Name = list_to_atom(atom_to_list(?MODULE)
-			++ "-"
-			++ atom_to_list(TestCase)
-			++ "-"
-			++ integer_to_list(ESTime)
-			++ "-"
-			++ integer_to_list(Unique)),
-    test_server:start_node(Name,
-			   slave,
-			   [{args, "-pa " ++ PA ++ " " ++ Args}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
diff --git a/erts/emulator/test/timer_bif_SUITE.erl b/erts/emulator/test/timer_bif_SUITE.erl
index 6e5b672646..a2e6c701d7 100644
--- a/erts/emulator/test/timer_bif_SUITE.erl
+++ b/erts/emulator/test/timer_bif_SUITE.erl
@@ -228,13 +228,10 @@ start_timer_e(Config) when is_list(Config) ->
     {'EXIT', _} = (catch erlang:start_timer(4.5, self(), hej)),
     {'EXIT', _} = (catch erlang:start_timer(a, self(), hej)),
 
-    Node = start_slave(),
+    {ok, Peer, Node} = ?CT_PEER(),
     Pid = spawn(Node, timer, sleep, [10000]),
     {'EXIT', _} = (catch erlang:start_timer(1000, Pid, hej)),
-    stop_slave(Node),
-
-
-    ok.
+    peer:stop(Peer).
 
 %% Error cases for send_after/3
 send_after_e(Config) when is_list(Config) ->
@@ -245,11 +242,10 @@ send_after_e(Config) when is_list(Config) ->
     {'EXIT', _} = (catch erlang:send_after(4.5, self(), hej)),
     {'EXIT', _} = (catch erlang:send_after(a, self(), hej)),
 
-    Node = start_slave(),
+    {ok, Peer, Node} = ?CT_PEER(),
     Pid = spawn(Node, timer, sleep, [10000]),
     {'EXIT', _} = (catch erlang:send_after(1000, Pid, hej)),
-    stop_slave(Node),
-    ok.
+    peer:stop(Peer).
 
 %% Error cases for cancel_timer/1
 cancel_timer_e(Config) when is_list(Config) ->
@@ -384,7 +380,7 @@ evil_timers(Config) when is_list(Config) ->
     %% in memory
     Self = self(),
     R1 = make_ref(),
-    Node = start_slave(),
+    {ok, Peer, Node} = ?CT_PEER(),
     spawn_link(Node,
                fun () ->
                        Self ! {R1,
@@ -396,7 +392,7 @@ evil_timers(Config) when is_list(Config) ->
                                  fun (A, B) -> A + B end]]}
                end),
     ExtList = receive {R1, L} -> L end,
-    stop_slave(Node),
+    peer:stop(Peer),
     BinList = [<<"bla">>,
                <<"blipp">>,
                <<"blupp">>,
@@ -813,17 +809,6 @@ get_msg() ->
               empty
     end.
 
-start_slave() ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Name = atom_to_list(?MODULE)
-    ++ "-" ++ integer_to_list(erlang:system_time(second))
-    ++ "-" ++ integer_to_list(erlang:unique_integer([positive])),
-    {ok, Node} = test_server:start_node(Name, slave, [{args, "-pa " ++ Pa}]),
-    Node.
-
-stop_slave(Node) ->
-    test_server:stop_node(Node).
-
 collect(Last) ->
     collect(Last, []).
 
diff --git a/erts/emulator/test/trace_SUITE.erl b/erts/emulator/test/trace_SUITE.erl
index 951502cb61..cc7bf087b2 100644
--- a/erts/emulator/test/trace_SUITE.erl
+++ b/erts/emulator/test/trace_SUITE.erl
@@ -130,8 +130,7 @@ receive_trace(Config) when is_list(Config) ->
 		       {true, true}]),
 
     %% Remote messages
-    OtherName = atom_to_list(?MODULE)++"_receive_trace",
-    {ok, OtherNode} = start_node(OtherName),
+    {ok, Peer, OtherNode} = ?CT_PEER(),
     RemoteProc = spawn_link(OtherNode, ?MODULE, process, [self()]),
     io:format("RemoteProc = ~p ~n", [RemoteProc]),
 
@@ -179,7 +178,7 @@ receive_trace(Config) when is_list(Config) ->
     F2(NN, {true, true}),
 
     unlink(RemoteProc),
-    true = stop_node(OtherNode),
+    peer:stop(Peer),
 
     %% Timeout
     Receiver ! {set_timeout, 10},
@@ -647,8 +646,7 @@ procs_trace(Config) when is_list(Config) ->
 
 dist_procs_trace(Config) when is_list(Config) ->
     ct:timetrap({seconds, 15}),
-    OtherName = atom_to_list(?MODULE)++"_dist_procs_trace",
-    {ok, OtherNode} = start_node(OtherName),
+    {ok, Peer, OtherNode} = ?CT_PEER(),
     Self = self(),
     process_flag(trap_exit, true),
     %%
@@ -695,7 +693,7 @@ dist_procs_trace(Config) when is_list(Config) ->
 
     %%
     %% exit (with registered name, due to link)
-    Name = list_to_atom(OtherName),
+    Name = list_to_atom(hd(string:lexemes(atom_to_list(OtherNode), "@"))),
     Reason2 = make_ref(),
     Proc1 ! {link_please, Proc2},
     {trace, Proc1, link, Proc2} = receive_first_trace(),
@@ -708,8 +706,7 @@ dist_procs_trace(Config) when is_list(Config) ->
     receive_nothing(),
     %%
     %% Done.
-    true = stop_node(OtherNode),
-    ok.
+    peer:stop(Peer).
 
 %% Test trace(new, How, [procs]).
 procs_new_trace(Config) when is_list(Config) ->
@@ -1724,7 +1721,7 @@ trace_delivered(Config) when is_list(Config) ->
 
 %% This testcase checks that receive trace works on exit signal messages
 %% when the sender of the exit signal is the process itself.
-trap_exit_self_receive(Config) ->
+trap_exit_self_receive(Config) when is_list(Config) ->
     Parent = self(),
     Proc = spawn_link(fun() -> process(Parent) end),
 
@@ -1754,7 +1751,7 @@ trace_info_badarg(Config) when is_list(Config) ->
 %% An incoming suspend monitor down wasn't handled
 %% correct when the local monitor half had been
 %% removed with an emulator crash as result.
-erl_704(Config) ->
+erl_704(Config) when is_list(Config) ->
     erl_704_test(100).
 
 erl_704_test(0) ->
@@ -1944,16 +1941,6 @@ fun_spawn(Fun, Args) ->
     spawn_link(erlang, apply, [Fun, Args]).
 
 
-start_node(Name) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    Cookie = atom_to_list(erlang:get_cookie()),
-    test_server:start_node(Name, slave,
-                           [{args, "-setcookie " ++ Cookie ++" -pa " ++ Pa}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
-
 wait_for_empty_runq(DeadLine) ->
     case statistics(run_queue) of
         0 -> true;
diff --git a/erts/emulator/test/unique_SUITE.erl b/erts/emulator/test/unique_SUITE.erl
index cfc37bd44f..c9159ba963 100644
--- a/erts/emulator/test/unique_SUITE.erl
+++ b/erts/emulator/test/unique_SUITE.erl
@@ -54,7 +54,7 @@ end_per_suite(_Config) ->
 %%
 
 unique_monotonic_integer_white_box(Config) when is_list(Config) ->
-    {ok, Node} = start_node(Config),
+    {ok, Peer, Node} = ?CT_PEER(),
     TestServer = self(),
     Success = make_ref(),
     %% Run this in a separate node, so we don't mess up
@@ -72,8 +72,7 @@ unique_monotonic_integer_white_box(Config) when is_list(Config) ->
             ok
     end,
     erlang:demonitor(Mon, [flush]),
-    stop_node(Node),
-    ok.
+    peer:stop(Peer).
 
 set_unique_monotonic_integer_state(MinCounter, NextValue) ->
     true = erts_debug:set_internal_state(unique_monotonic_integer_state,
@@ -355,21 +354,3 @@ check_unique_integer_around(Int, #uniqint_info{min_int = MinInt,
 print_ret_val(File, Line, Value) ->    
     io:format("~s:~p: ~p~n", [File, Line, Value]),
     Value.
-
-start_node(Config) ->
-    start_node(Config, []).
-start_node(Config, Opts) when is_list(Config), is_list(Opts) ->
-    Pa = filename:dirname(code:which(?MODULE)),
-    A = erlang:monotonic_time(1) + erlang:time_offset(1),
-    B = erlang:unique_integer([positive]),
-    Name = list_to_atom(atom_to_list(?MODULE)
-                        ++ "-"
-                        ++ atom_to_list(proplists:get_value(testcase, Config))
-                        ++ "-"
-                        ++ integer_to_list(A)
-                        ++ "-"
-                        ++ integer_to_list(B)),
-    test_server:start_node(Name, slave, [{args, Opts++" -pa "++Pa}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-- 
2.31.1

Places

File 1693-emulator-replace-test_server-start-node-with-CT_PEER.patch of Package erlang (Revision 3e585b5159e575cdaf8b197320891957)

Places