Merge branch 'peppe/common_test/auto_cleanup/OTP-13832' into maint

* peppe/common_test/auto_cleanup/OTP-13832:
  Add tests and doc for the new remaining_test_procs function
  Implement function that finds disposable test processes
  Tag Common Test system processes using process dictionary
  Add app name tag in process dictionary

OTP-13832

4 files changed, 659 insertions, 1 deletions

diff --git a/lib/common_test/test/Makefile b/lib/common_test/test/Makefile
index 0d9149f489..ecd1f727a2 100644
--- a/lib/common_test/test/Makefile
+++ b/lib/common_test/test/Makefile
@@ -73,7 +73,8 @@ MODULES= \
 	ct_log_SUITE \
         ct_SUITE \
 	ct_keep_logs_SUITE \
-	ct_unicode_SUITE
+	ct_unicode_SUITE \
+	ct_auto_clean_SUITE
 
 ERL_FILES= $(MODULES:%=%.erl)
 HRL_FILES= test_server_test_lib.hrl
diff --git a/lib/common_test/test/ct_auto_clean_SUITE.erl b/lib/common_test/test/ct_auto_clean_SUITE.erl
new file mode 100644
index 0000000000..fd81430d0d
--- /dev/null
+++ b/lib/common_test/test/ct_auto_clean_SUITE.erl
@@ -0,0 +1,262 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2016. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+-module(ct_auto_clean_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+-include_lib("common_test/include/ct_event.hrl").
+
+-define(eh, ct_test_support_eh).
+
+%%--------------------------------------------------------------------
+%% Function: init_per_suite(Config0) -> Config1 | {skip,Reason}
+%%
+%% Config0 = Config1 = [tuple()]
+%%   A list of key/value pairs, holding the test case configuration.
+%% Reason = term()
+%%   The reason for skipping the suite.
+%%
+%% Description: Since Common Test starts another Test Server
+%% instance, the tests need to be performed on a separate node (or
+%% there will be clashes with logging processes etc).
+%%--------------------------------------------------------------------
+init_per_suite(Config) ->
+    DataDir = ?config(data_dir, Config),
+    CTHs = filelib:wildcard(filename:join(DataDir,"cth_*.erl")),
+    ct:pal("CTHs: ~p",[CTHs]),
+    [ct:pal("Compiling ~p: ~p",
+	    [FileName,compile:file(FileName,[{outdir,DataDir},debug_info])]) ||
+	FileName <- CTHs],
+    ct_test_support:init_per_suite([{path_dirs,[DataDir]} | Config]).
+
+%%--------------------------------------------------------------------
+%% Function: end_per_suite(Config) -> void()
+%%
+%% Config = [tuple()]
+%%   A list of key/value pairs, holding the test case configuration.
+%%
+%% Description: Cleanup after the suite.
+%%--------------------------------------------------------------------
+end_per_suite(Config) ->
+    ct_test_support:end_per_suite(Config).
+
+%%--------------------------------------------------------------------
+%% Function: init_per_testcase(TestCase, Config0) -> Config1 |
+%%                                                   {skip,Reason}
+%% TestCase = atom()
+%%   Name of the test case that is about to run.
+%% Config0 = Config1 = [tuple()]
+%%   A list of key/value pairs, holding the test case configuration.
+%% Reason = term()
+%%   The reason for skipping the test case.
+%%
+%% Description: Initialization before each test case.
+%%
+%% Note: This function is free to add any key/value pairs to the Config
+%% variable, but should NOT alter/remove any existing entries.
+%%--------------------------------------------------------------------
+init_per_testcase(TestCase, Config) ->
+    ct_test_support:init_per_testcase(TestCase, Config).
+
+%%--------------------------------------------------------------------
+%% Function: end_per_testcase(TestCase, Config) -> void()
+%%
+%% TestCase = atom()
+%%   Name of the test case that is finished.
+%% Config = [tuple()]
+%%   A list of key/value pairs, holding the test case configuration.
+%%
+%% Description: Cleanup after each test case.
+%%--------------------------------------------------------------------
+end_per_testcase(TestCase, Config) ->
+    ct_test_support:end_per_testcase(TestCase, Config).
+
+%%--------------------------------------------------------------------
+%% Function: all(Clause) -> Descr | TestCases | {skip,Reason}
+%%
+%% Clause = doc | suite
+%%   Indicates expected return value.
+%% Descr = [string()] | []
+%%   String that describes the test suite.
+%% TestCases = [TestCase] 
+%% TestCase = atom()
+%%   Name of a test case.
+%% Reason = term()
+%%   The reason for skipping the test suite.
+%%
+%% Description: Returns a description of the test suite (doc) and a
+%%              list of all test cases in the suite (suite).
+%%--------------------------------------------------------------------
+suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() -> 
+    [clean].
+
+groups() -> 
+    [].
+
+init_per_group(_GroupName, Config) ->
+	Config.
+
+end_per_group(_GroupName, Config) ->
+	Config.
+
+%%--------------------------------------------------------------------
+%% TEST CASES
+%%--------------------------------------------------------------------
+
+%%--------------------------------------------------------------------
+%% Function: TestCase(Arg) -> Descr | Spec | ok | exit() | {skip,Reason}
+%%
+%% Arg = doc | suite | Config
+%%   Indicates expected behaviour and return value.
+%% Config = [tuple()]
+%%   A list of key/value pairs, holding the test case configuration.
+%% Descr = [string()] | []
+%%   String that describes the test case.
+%% Spec = [tuple()] | []
+%%   A test specification.
+%% Reason = term()
+%%   The reason for skipping the test case.
+%%
+%% Description: Test case function. Returns a description of the test
+%%              case (doc), then returns a test specification (suite),
+%%              or performs the actual test (Config).
+%%--------------------------------------------------------------------
+
+%%%-----------------------------------------------------------------
+%%% 
+
+clean(Config) when is_list(Config) -> 
+    DataDir = ?config(data_dir, Config),
+
+    ACSuite = filename:join(DataDir, "ac_SUITE"),
+    Opts0 = ct_test_support:get_opts(Config),
+    Opts = eh_opts(Config) ++ Opts0 ++ [{suite,ACSuite},
+                                        {ct_hooks,[cth_auto_clean]}],
+
+    ERPid = ct_test_support:start_event_receiver(Config),
+
+    ok = ct_test_support:run(Opts, Config),
+
+    Events = ct_test_support:get_events(ERPid, Config),
+    ct_test_support:log_events(?FUNCTION_NAME, 
+			       ct_test_support:reformat(Events, ?eh),
+			       ?config(priv_dir, Config),
+			       Opts),
+    TestEvents = events_to_check(?FUNCTION_NAME),
+    ok = ct_test_support:verify_events(TestEvents, Events, Config).
+
+
+%%%-----------------------------------------------------------------
+%%% HELP FUNCTIONS
+%%%-----------------------------------------------------------------
+
+eh_opts(Config) ->        
+    Level = ?config(trace_level, Config),
+    [{event_handler,{?eh,[{cbm,ct_test_support},{trace_level,Level}]}}].
+
+events_to_check(Test) ->
+    %% 2 tests (ct:run_test + script_start) is default
+    events_to_check(Test, 2).
+
+events_to_check(_, 0) ->
+    [];
+events_to_check(Test, N) ->
+    events(Test) ++ events_to_check(Test, N-1).
+
+events(clean) ->
+    [
+     {?eh,start_logging,{'DEF','RUNDIR'}},
+     {?eh,test_start,{'DEF',{'START_TIME','LOGDIR'}}},
+     {?eh,start_info,{1,1,9}},
+
+     {?eh,tc_start,{ac_SUITE,init_per_suite}},
+     {?eh,tc_done,{ac_SUITE,init_per_suite,ok}},
+
+     {?eh,tc_start,{ac_SUITE,tc1}},
+     {?eh,tc_done,{ac_SUITE,tc1,ok}},
+
+     {?eh,test_stats,{1,0,{0,0}}},
+
+     {?eh,tc_start,{ac_SUITE,tc2}},
+     {?eh,tc_done,{ac_SUITE,tc2,ok}},
+
+     {?eh,test_stats,{2,0,{0,0}}},
+
+     [{?eh,tc_start,{ac_SUITE,{init_per_group,s1,[]}}},
+      {?eh,tc_done,{ac_SUITE,{init_per_group,s1,[]},ok}},
+
+      {?eh,tc_start,{ac_SUITE,stc1}},
+      {?eh,tc_done,{ac_SUITE,stc1,ok}},
+
+      {?eh,test_stats,{3,0,{0,0}}},
+
+      {?eh,tc_start,{ac_SUITE,stc2}},
+      {?eh,tc_done,{ac_SUITE,stc2,ok}},
+
+      {?eh,test_stats,{4,0,{0,0}}},
+
+      {?eh,tc_start,{ac_SUITE,{end_per_group,s1,[]}}},
+      {?eh,tc_done,{ac_SUITE,{end_per_group,s1,[]},ok}}],
+
+     {parallel,
+      [{?eh,tc_start,{ac_SUITE,{init_per_group,p1,[parallel]}}},
+       {?eh,tc_done,{ac_SUITE,{init_per_group,p1,[parallel]},ok}},
+
+       {?eh,tc_start,{ac_SUITE,ptc1}},
+       {?eh,tc_start,{ac_SUITE,ptc2}},
+       {?eh,tc_done,{ac_SUITE,ptc1,ok}},
+       {?eh,test_stats,{5,0,{0,0}}},
+       {?eh,tc_done,{ac_SUITE,ptc2,ok}},
+       {?eh,test_stats,{6,0,{0,0}}},
+
+       {?eh,tc_start,{ac_SUITE,{end_per_group,p1,[parallel]}}},
+       {?eh,tc_done,{ac_SUITE,{end_per_group,p1,[parallel]},ok}}]},
+
+     [{?eh,tc_start,{ac_SUITE,{init_per_group,s2,[]}}},
+      {?eh,tc_done,{ac_SUITE,{init_per_group,s2,[]},ok}},
+
+      {?eh,tc_start,{ac_SUITE,stc1}},
+      {?eh,tc_done,{ac_SUITE,stc1,ok}},
+
+      {?eh,test_stats,{7,0,{0,0}}},
+
+      {?eh,tc_start,{ac_SUITE,stc2}},
+      {?eh,tc_done,{ac_SUITE,stc2,ok}},
+
+      {?eh,test_stats,{8,0,{0,0}}},
+
+      {?eh,tc_start,{ac_SUITE,{end_per_group,s2,[]}}},
+      {?eh,tc_done,{ac_SUITE,{end_per_group,s2,[]},ok}}],
+
+     {?eh,tc_start,{ac_SUITE,tc1}},
+     {?eh,tc_done,{ac_SUITE,tc1,ok}},
+
+     {?eh,test_stats,{9,0,{0,0}}},
+
+     {?eh,tc_start,{ac_SUITE,end_per_suite}},
+     {?eh,tc_done,{ac_SUITE,end_per_suite,ok}},
+
+     {?eh,test_done,{'DEF','STOP_TIME'}},
+     {?eh,stop_logging,[]}
+    ].
diff --git a/lib/common_test/test/ct_auto_clean_SUITE_data/ac_SUITE.erl b/lib/common_test/test/ct_auto_clean_SUITE_data/ac_SUITE.erl
new file mode 100644
index 0000000000..dae7c1e22c
--- /dev/null
+++ b/lib/common_test/test/ct_auto_clean_SUITE_data/ac_SUITE.erl
@@ -0,0 +1,181 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2016. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+-module(ac_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct.hrl").
+
+%%--------------------------------------------------------------------
+%% @spec suite() -> Info
+%% Info = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+suite() ->
+    [{timetrap,{seconds,30}}].
+
+%%--------------------------------------------------------------------
+%% @spec init_per_suite(Config0) ->
+%%     Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_suite(Config) ->
+    start_processes(),
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_suite(Config0) -> term() | {save_config,Config1}
+%% Config0 = Config1 = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+end_per_suite(_Config) ->
+    start_processes(),
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec init_per_group(GroupName, Config0) ->
+%%               Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% GroupName = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_group(_GroupName, Config) ->
+    start_processes(),
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_group(GroupName, Config0) ->
+%%               term() | {save_config,Config1}
+%% GroupName = atom()
+%% Config0 = Config1 = [tuple()]
+%% @end
+%%--------------------------------------------------------------------
+end_per_group(_GroupName, _Config) ->
+    start_processes(),
+    ok.
+                    
+%%--------------------------------------------------------------------
+%% @spec init_per_testcase(TestCase, Config0) ->
+%%               Config1 | {skip,Reason} | {skip_and_save,Reason,Config1}
+%% TestCase = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+init_per_testcase(_TestCase, Config) ->
+    start_processes(),
+    Config.
+
+%%--------------------------------------------------------------------
+%% @spec end_per_testcase(TestCase, Config0) ->
+%%               term() | {save_config,Config1} | {fail,Reason}
+%% TestCase = atom()
+%% Config0 = Config1 = [tuple()]
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+end_per_testcase(_TestCase, _Config) ->
+    start_processes(),
+    ok.
+
+%%--------------------------------------------------------------------
+%% @spec groups() -> [Group]
+%% Group = {GroupName,Properties,GroupsAndTestCases}
+%% GroupName = atom()
+%% Properties = [parallel | sequence | Shuffle | {RepeatType,N}]
+%% GroupsAndTestCases = [Group | {group,GroupName} | TestCase]
+%% TestCase = atom()
+%% Shuffle = shuffle | {shuffle,{integer(),integer(),integer()}}
+%% RepeatType = repeat | repeat_until_all_ok | repeat_until_all_fail |
+%%              repeat_until_any_ok | repeat_until_any_fail
+%% N = integer() | forever
+%% @end
+%%--------------------------------------------------------------------
+groups() ->
+    [{s1,[],[stc1,stc2]},
+     {p1,[parallel],[ptc1,ptc2]},
+     {s2,[],[stc1,stc2]}].
+
+%%! What about nested groups??
+
+%%--------------------------------------------------------------------
+%% @spec all() -> GroupsAndTestCases | {skip,Reason}
+%% GroupsAndTestCases = [{group,GroupName} | TestCase]
+%% GroupName = atom()
+%% TestCase = atom()
+%% Reason = term()
+%% @end
+%%--------------------------------------------------------------------
+all() -> 
+    [
+     [tc1,tc2],
+     {group,s1},
+     {group,p1},
+     {group,s2},
+     tc1
+    ].
+
+tc1(_Config) ->
+    start_processes(),
+    ok.
+
+tc2(_Config) ->
+    start_processes(),
+    ok.
+
+stc1(_Config) ->
+    start_processes(),
+    ok.
+
+stc2(_Config) ->
+    start_processes(),
+    ok.
+
+ptc1(_Config) ->
+    start_processes(),
+    ok.
+
+ptc2(_Config) ->
+    start_processes(),
+    ok.
+
+
+%%%-----------------------------------------------------------------
+%%% 
+
+start_processes() ->
+    Init = fun() ->
+                   process_flag(trap_exit, true),
+                   do_spawn(fun() -> receive _ -> ok end end),
+                   receive _ ->
+                           ok
+                   end
+           end,
+    do_spawn(Init).
+
+do_spawn(Fun) ->
+    Pid = spawn(Fun),
+    ct:log("Process ~w started with group leader ~w",
+           [Pid,element(2, process_info(Pid, group_leader))]),
+    Pid.
diff --git a/lib/common_test/test/ct_auto_clean_SUITE_data/cth_auto_clean.erl b/lib/common_test/test/ct_auto_clean_SUITE_data/cth_auto_clean.erl
new file mode 100644
index 0000000000..137c81969d
--- /dev/null
+++ b/lib/common_test/test/ct_auto_clean_SUITE_data/cth_auto_clean.erl
@@ -0,0 +1,214 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009-2016. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+-module(cth_auto_clean).
+
+%% CTH Callbacks
+-export([id/1, init/2,
+	 pre_init_per_suite/3, post_init_per_suite/4,
+         pre_end_per_suite/3, post_end_per_suite/4,
+	 pre_init_per_group/4, post_init_per_group/5,
+	 pre_end_per_group/4, post_end_per_group/5,
+	 pre_init_per_testcase/4, post_init_per_testcase/5,
+	 pre_end_per_testcase/4, post_end_per_testcase/5]).
+
+id(_Opts) ->
+    ?MODULE.
+
+init(?MODULE, _Opts) ->
+    ok.
+
+pre_init_per_suite(_Suite, Config, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = test_server_io:get_gl(true),
+    SharedGL = find_and_kill(),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    %% get status of processes at startup, to be compared with end result
+    {Config, [{all_procs,processes()} | State]}.
+
+post_init_per_suite(_Suite, _Config, Return, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    {Return, State}.
+
+pre_end_per_suite(_Suite, Config, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    {Config, State}.
+
+post_end_per_suite(_Suite, _Config, Return, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    AllProcs = processes(),
+    Remaining = AllProcs--proplists:get_value(all_procs, State),
+    ct:pal("Final remaining processes = ~p", [Remaining]),
+    %% only the end_per_suite process shoud remain at this point!
+    Remaining = [self()],
+    {Return, State}.
+
+pre_init_per_group(_Suite, _Group, Config, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(procs_and_gls),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    {Config, State}.
+
+post_init_per_group(_Suite, _Group, _Config, Result, State) -> 
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(procs_and_gls),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    {Result, State}.
+
+pre_init_per_testcase(_Suite, _TC, Config, State) ->
+    identify(?FUNCTION_NAME),
+    ThisGL = group_leader(),
+    find_and_kill(proc, ThisGL),
+    case proplists:get_value(tc_group_properties, Config) of
+        [{name,_},parallel] ->
+            timer:sleep(1000);
+        _ ->
+            do_until(fun() -> element(1,ct:remaining_test_procs()) end, [])
+    end,
+    {Config, State}.
+
+post_init_per_testcase(_Suite, _TC, Config, Return, State) ->
+    identify(?FUNCTION_NAME),
+    ThisGL = group_leader(),
+    find_and_kill(proc, ThisGL),
+    case proplists:get_value(tc_group_properties, Config) of
+        [{name,_},parallel] ->
+            timer:sleep(1000);
+        _ ->
+            do_until(fun() -> element(1,ct:remaining_test_procs()) end, [])
+    end,
+    {Return, State}.
+
+pre_end_per_testcase(_Suite, _TC, Config, State) ->
+    identify(?FUNCTION_NAME),
+    ThisGL = group_leader(),
+    find_and_kill(proc, ThisGL),
+    case proplists:get_value(tc_group_properties, Config) of
+        [{name,_},parallel] ->
+            timer:sleep(1000);
+        _ ->
+            do_until(fun() -> element(1,ct:remaining_test_procs()) end, [])
+    end,
+    {Config, State}.
+
+post_end_per_testcase(_Suite, _TC, Config, Result, State) ->
+    identify(?FUNCTION_NAME),
+    ThisGL = group_leader(),
+    find_and_kill(proc, ThisGL),
+    case proplists:get_value(tc_group_properties, Config) of
+        [{name,_},parallel] ->
+            timer:sleep(1000);
+        _ ->
+            do_until(fun() -> element(1,ct:remaining_test_procs()) end, [])
+    end,
+    {Result, State}.
+
+pre_end_per_group(_Suite, _Group, Config, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(procs_and_gls),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    {Config, State}.
+
+post_end_per_group(_Suite, _Group, _Config, Return, State) ->
+    identify(?FUNCTION_NAME),
+    SharedGL = find_and_kill(procs_and_gls),
+    do_until(fun() -> ct:remaining_test_procs() end, {[],SharedGL,[]}),
+    {Return, State}.
+
+
+%%%-----------------------------------------------------------------
+%%% HELP FUNCTIONS
+%%%-----------------------------------------------------------------
+
+identify(Func) ->
+    ct:pal("********** THIS IS ~w on ~w", [Func, self()]),
+    ok.
+
+find_and_kill() ->
+    find_and_kill(procs).
+
+find_and_kill(procs) ->
+    {Procs,SharedGL,_ParallelGLs} = ct:remaining_test_procs(),
+    ct:pal("Remaining test processes = ~p", [pi(Procs)]),
+    [pkill(P, kill) || {P,_GL} <- Procs],
+    SharedGL;
+
+find_and_kill(procs_and_gls) ->
+    {Procs,SharedGL,GLs} = ct:remaining_test_procs(),
+    ct:pal("Remaining test processes = ~p", [pi(Procs)]),
+    [pkill(P, kill) || {P,_GL} <- Procs],
+    ct:pal("Remaining group leaders = ~p", [pi(GLs)]),
+    [pkill(GL, kill) || GL <- GLs, GL /= SharedGL],
+    SharedGL.
+
+find_and_kill(proc, ProcGL) ->
+    {Procs,SharedGL,GLs} = ct:remaining_test_procs(),
+    ct:pal("Remaining test processes = ~p", [pi(Procs++GLs)]),
+    [pkill(P, kill) || {P,GL} <- Procs, GL == ProcGL],
+    SharedGL.
+
+pi([{P,_GL}|Ps]) ->
+    pi([P|Ps]);
+pi([P|Ps]) ->
+    case node() == node(P) of
+        true ->
+            {_,GL} = process_info(P,group_leader),
+            {_,CF} = process_info(P,current_function),
+            {_,IC} = process_info(P,initial_call),
+            {_,D} = process_info(P,dictionary),
+            Shared = test_server_io:get_gl(true),
+            User = whereis(user),
+            if (GL /= P) and (GL /= Shared) and (GL /= User) ->
+                    [{P,GL,CF,IC,D} | pi([GL|Ps])];
+               true ->
+                    [{P,GL,CF,IC,D} | pi(Ps)]
+            end;
+        false ->
+            pi(Ps)
+    end;
+pi([]) ->
+    [].
+
+do_until(Fun, Until) ->
+    io:format("Will do until ~p~n", [Until]),
+    do_until(Fun, Until, 1000).
+
+do_until(_, Until, 0) ->
+    io:format("Couldn't get ~p~n", [Until]),
+    exit({not_reached,Until});
+
+do_until(Fun, Until, N) ->
+    case Fun() of
+        Until ->
+            ok;
+        _Tmp ->
+            do_until(Fun, Until, N-1)
+    end.
+
+pkill(P, How) ->
+    ct:pal("KILLING ~w NOW!", [P]),
+    exit(P, How).
+