fairchild-poolparty 1.1.3

data/lib/erlang/messenger/lib/eunit/src/eunit_proc.erl

@@ -0,0 +1,552 @@
+%% This library is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Lesser General Public License as
+%% published by the Free Software Foundation; either version 2 of the
+%% License, or (at your option) any later version.
+%%
+%% This library is distributed in the hope that it will be useful, but
+%% WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+%% Lesser General Public License for more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public
+%% License along with this library; if not, write to the Free Software
+%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+%% USA
+%%
+%% $Id: eunit_proc.erl 256 2008-09-29 17:42:21Z rcarlsson $ 
+%%
+%% @author Richard Carlsson <richardc@it.uu.se>
+%% @copyright 2006 Richard Carlsson
+%% @private
+%% @see eunit
+%% @doc Test runner process tree functions
+
+-module(eunit_proc).
+
+-include("eunit.hrl").
+-include("eunit_internal.hrl").
+
+-export([start/4]).
+
+
+-record(procstate, {ref, id, super, insulator, parent, order}).
+
+
+%% Spawns test process and returns the process Pid; sends {done,
+%% Reference, Pid} to caller when finished. See the function
+%% wait_for_task/2 for details about the need for the reference.
+%%
+%% The `Super' process receives a stream of status messages; see
+%% status_message/3 for details.
+
+start(Tests, Order, Super, Reference)
+  when is_pid(Super), is_reference(Reference) ->
+    St = #procstate{ref = Reference,
+		    id = [],
+		    super = Super,
+		    order = Order},
+    spawn_group(local, #group{tests = Tests}, St).
+
+
+%% Status messages sent to the supervisor process. (A supervisor does
+%% not have to act on these messages - it can e.g. just log them, or
+%% even discard them.) Each status message has the following form:
+%%
+%%   {status, Id, Info}
+%%
+%% where Id identifies the item that the message pertains to, and the
+%% Info part can be one of:
+%%
+%%   {progress, 'begin', test | group}
+%%       indicates that the item has been entered, and what type it is
+%%
+%%   {progress, 'end', {Status, Time::integer(), Output::io_list()}}
+%%       Status = 'ok' | {error, Exception} | {skipped, Cause}
+%%
+%%       where Time is measured in milliseconds and Output is the data
+%%       written to the standard output stream during the test; if
+%%       Status is {skipped, Cause}, then Cause is a term thrown from
+%%       eunit_test:run_testfun/1
+%%
+%%   {cancel, Descriptor}
+%%       where Descriptor can be:
+%%           timeout            a timeout occurred
+%%           {blame, Id}        forced to terminate because of item `Id'
+%%           {abort, Cause}     the test failed to execute
+%%           {exit, Reason}     the test process terminated unexpectedly
+%%           {startup, Reason}  failed to start a remote test process
+%%
+%%       where Cause is a term thrown from eunit_data:enter_context/4 or
+%%       from eunit_data:iter_next/2, and Reason is an exit term from a
+%%       crashed process
+%%
+%% Note that due to concurrent (and possibly distributed) execution,
+%% there are *no* strict ordering guarantees on the status messages,
+%% with one exception: a 'begin' message will always arrive before its
+%% corresponding 'end' message.
+
+status_message(Id, Info, St) ->
+    St#procstate.super ! {status, Id, Info}.
+
+
+%% @TODO implement synchronized mode for insulator/child execution
+
+%% Ideas for synchronized mode:
+%%
+%% * At each "program point", i.e., before entering a test, entering a
+%% group, or leaving a group, the child will synchronize with the
+%% insulator to make sure it is ok to proceed.
+%%
+%% * The insulator can receive controlling messages from higher up in
+%% the hierarchy, telling it to pause, resume, single-step, repeat, etc.
+%%
+%% * Synchronization on entering/leaving groups is necessary in order to
+%% get control over things such as subprocess creation/termination and
+%% setup/cleanup, making it possible to, e.g., repeat all the tests
+%% within a particular subprocess without terminating and restarting it,
+%% or repeating tests without repeating the setup/cleanup.
+%%
+%% * Some tests that depend on state will not be possible to repeat, but
+%% require a fresh context setup. There is nothing that can be done
+%% about this, and the many tests that are repeatable should not be
+%% punished because of it. The user must decide which level to restart.
+%%
+%% * Question: How propagate control messages down the hierarchy
+%% (preferably only to the correct insulator process)? An insulator does
+%% not currenctly know whether its child process has spawned subtasks.
+%% (The "supervisor" process does not know the Pids of the controlling
+%% insulator processes in the tree, and it probably should not be
+%% responsible for this anyway.)
+
+
+%% ---------------------------------------------------------------------
+%% Process tree primitives
+
+%% A "task" consists of an insulator process and a child process which
+%% handles the actual work. When the child terminates, the insulator
+%% process sends {done, Reference, self()} to the process which started
+%% the task (the "parent"). The child process is given a State record
+%% which contains the process id:s of the parent, the insulator, and the
+%% supervisor.
+
+%% @spec (Type, (#procstate{}) -> () -> term(), #procstate{}) -> pid()
+%%   Type = local | {remote, Node::atom()}
+
+start_task(Type, Fun, St0) ->
+    St = St0#procstate{parent = self()},
+    %% (note: the link here is mainly to propagate signals *downwards*,
+    %% so that the insulator can detect if the process that started the
+    %% task dies before the task is done)
+    F = fun () -> insulator_process(Type, Fun, St) end,
+    case Type of
+	local ->
+	    %% we assume (at least for now) that local spawns can never
+	    %% fail in such a way that the process does not start, so a
+	    %% new local insulator does not need to synchronize here
+	    spawn_link(F);
+	{remote, Node} ->
+	    Pid = spawn_link(Node, F),
+	    %% See below for the need for the {ok, Reference, Pid}
+	    %% message.
+	    Reference = St#procstate.ref,
+	    Monitor = erlang:monitor(process, Pid),
+	    %% (the DOWN message is guaranteed to arrive after any
+	    %% messages sent by the process itself)
+	    receive
+		{ok, Reference, Pid} ->
+		    Pid;
+		{'DOWN', Monitor, process, Pid, Reason} ->
+		    %% send messages as if the insulator process was
+		    %% started, but terminated on its own accord
+		    Msg = {startup, Reason},
+		    status_message(St#procstate.id, {cancel, Msg}, St),
+		    self() ! {done, Reference, Pid}
+	    end,
+	    erlang:demonitor(Monitor, [flush]),
+	    Pid
+    end.
+
+%% Relatively simple, and hopefully failure-proof insulator process
+%% (This is cleaner than temporarily setting up the caller to trap
+%% signals, and does not affect the caller's mailbox or other state.)
+%%
+%% We assume that nobody does a 'kill' on an insulator process - if that
+%% should happen, the test framework will hang since the insulator will
+%% never send a reply; see below for more.
+%%
+%% Note that even if the insulator process itself never fails, it is
+%% still possible that it does not start properly, if it is spawned
+%% remotely (e.g., if the remote node is down). Therefore, remote
+%% insulators must always immediately send an {ok, Reference, self()}
+%% message to the parent as soon as it is spawned.
+
+%% @spec (Type, Fun::() -> term(), St::#procstate{}) -> ok
+%%  Type = local | {remote, Node::atom()}
+
+insulator_process(Type, Fun, St0) ->
+    process_flag(trap_exit, true),
+    Parent = St0#procstate.parent,
+    if Type == local -> ok;
+       true -> Parent ! {ok, St0#procstate.ref, self()}
+    end,
+    St = St0#procstate{insulator = self()},
+    Child = spawn_link(fun () -> child_process(Fun(St), St) end),
+    insulator_wait(Child, Parent, [], St).
+
+%% Normally, child processes exit with the reason 'normal' even if the
+%% executed tests failed (by throwing exceptions), since the tests are
+%% executed within a try-block. Child processes can terminate abnormally
+%% by the following reasons:
+%%   1) an error in the processing of the test descriptors (a malformed
+%%      descriptor, failure in a setup, cleanup or initialization, a
+%%      missing module or function, or a failing generator function);
+%%   2) an internal error in the test running framework itself;
+%%   3) receiving a non-trapped error signal as a consequence of running
+%%      test code.
+%% Those under point 1 are "expected errors", handled specially in the
+%% protocol, while the other two are unexpected errors. (Since alt. 3
+%% implies that the test neither reported success nor failure, it can
+%% never be considered "proper" behaviour of a test.) Abnormal
+%% termination is reported to the supervisor process but otherwise does
+%% not affect the insulator compared to normal termination. Child
+%% processes can also be killed abruptly by their insulators, in case of
+%% a timeout or if a parent process dies.
+%%
+%% The insulator is the group leader for the child process, and gets all
+%% of its standard I/O. The output is buffered and associated with the
+%% currently active test or group, and is sent along with the 'end'
+%% progress message when the test or group has finished.
+
+insulator_wait(Child, Parent, Buf, St) ->
+    receive
+	{io_request, From, ReplyAs, Req} when is_pid(From) ->
+	    Buf1 = io_request(From, ReplyAs, Req, hd(Buf)),
+	    insulator_wait(Child, Parent, [Buf1 | tl(Buf)], St);
+	{progress, Child, Id, 'begin', Class} ->
+	    status_message(Id, {progress, 'begin', Class}, St),
+	    insulator_wait(Child, Parent, [[] | Buf], St);
+	{progress, Child, Id, 'end', {Status, Time}} ->
+	    Msg = {Status, Time, lists:reverse(hd(Buf))},
+	    status_message(Id, {progress, 'end', Msg}, St),
+	    insulator_wait(Child, Parent, tl(Buf), St);
+	{cancel, Child, Id, Reason} ->
+	    status_message(Id, {cancel, Reason}, St),
+	    insulator_wait(Child, Parent, Buf, St);
+	{abort, Child, Id, Cause} ->
+	    exit_messages(Id, {abort, Cause}, St),
+	    %% no need to wait for the {'EXIT',Child,_} message
+	    terminate_insulator(St);
+	{timeout, Child, Id} ->
+	    exit_messages(Id, timeout, St),
+	    kill_task(Child, St);
+	{'EXIT', Child, normal} ->
+	    terminate_insulator(St);
+	{'EXIT', Child, Reason} ->
+	    exit_messages(St#procstate.id, {exit, Reason}, St),
+	    terminate_insulator(St);
+	{'EXIT', Parent, _} ->
+	    %% make sure child processes are cleaned up recursively
+	    kill_task(Child, St)
+    end.
+
+kill_task(Child, St) ->
+    exit(Child, kill),
+    terminate_insulator(St).
+
+%% Unlinking before exit avoids polluting the parent process with exit
+%% signals from the insulator. The child process is already dead here.
+
+terminate_insulator(St) ->
+    %% messaging/unlinking is ok even if the parent is already dead
+    Parent = St#procstate.parent,
+    Parent ! {done, St#procstate.ref, self()},
+    unlink(Parent),
+    exit(normal).
+
+%% send cancel messages for the Id of the "causing" item, and also for
+%% the Id of the insulator itself, if they are different
+exit_messages(Id, Cause, St) ->
+    %% the message for the most specific Id is always sent first
+    status_message(Id, {cancel, Cause}, St),
+    case St#procstate.id of
+	Id -> ok;
+	Id1 -> status_message(Id1, {cancel, {blame, Id}}, St)
+    end.
+
+%% Child processes send all messages via the insulator to ensure proper
+%% sequencing with timeouts and exit signals.
+
+abort_message(Cause, St) ->
+    St#procstate.insulator ! {abort, self(), St#procstate.id, Cause}.
+
+cancel_message(Msg, St) ->
+    St#procstate.insulator ! {cancel, self(), St#procstate.id, Msg}.
+
+progress_message(Type, Data, St) ->
+    St#procstate.insulator ! {progress, self(), St#procstate.id,
+			      Type, Data}.
+
+%% Timeout handling
+
+set_timeout(Time, St) ->
+    erlang:send_after(Time, St#procstate.insulator,
+		      {timeout, self(), St#procstate.id}).
+
+clear_timeout(Ref) ->
+    erlang:cancel_timer(Ref).
+
+with_timeout(undefined, Default, F, St) ->
+    with_timeout(Default, F, St);
+with_timeout(Time, _Default, F, St) ->
+    with_timeout(Time, F, St).
+
+with_timeout(infinity, F, _St) ->
+    %% don't start timers unnecessarily
+    {T0, _} = statistics(wall_clock),
+    Value = F(),
+    {T1, _} = statistics(wall_clock),
+    {Value, T1 - T0};
+with_timeout(Time, F, St) when is_integer(Time), Time > 16#FFFFffff ->
+    with_timeout(16#FFFFffff, F, St);
+with_timeout(Time, F, St) when is_integer(Time), Time < 0 ->
+    with_timeout(0, F, St);
+with_timeout(Time, F, St) when is_integer(Time) ->
+    Ref = set_timeout(Time, St),
+    {T0, _} = statistics(wall_clock),
+    try F() of
+	Value ->
+	    %% we could also read the timer, but this is simpler
+	    {T1, _} = statistics(wall_clock),
+	    {Value, T1 - T0}
+    after
+	clear_timeout(Ref)
+    end.
+
+%% The normal behaviour of a child process is to trap exit signals. This
+%% makes it easier to write tests that spawn off separate (linked)
+%% processes and test whether they terminate as expected. The testing
+%% framework is not dependent on this, however, so the test code is
+%% allowed to disable signal trapping as it pleases.
+%% Note that I/O is redirected to the insulator process.
+
+%% @spec (() -> term(), #procstate{}) -> ok
+
+child_process(Fun, St) ->
+    process_flag(trap_exit, true),
+    group_leader(St#procstate.insulator, self()),
+    try Fun() of
+	_ -> ok
+    catch
+	%% the only "normal" way for a child process to bail out is to
+	%% throw an {eunit_abort, Reason} exception; any other exception
+	%% will be reported as an unexpected termination of the test
+	{eunit_abort, Cause} ->
+	    abort_message(Cause, St),
+	    exit(aborted)
+    end.
+
+%% @throws abortException()
+%% @type abortException() = {abort, Cause::term()}
+
+abort_task(Cause) ->
+    throw({eunit_abort, Cause}).
+
+%% Typically, the process that executes this code is trapping signals,
+%% but it might not be - it is outside of our control, since test code
+%% could turn off trapping. That is why the insulator process of a task
+%% must be guaranteed to always send a reply before it terminates.
+%%
+%% The unique reference guarantees that we don't extract any message
+%% from the mailbox unless it belongs to the test framework (and not to
+%% the running tests) - it is not possible to use selective receive to
+%% match only messages tagged with some pid in a dynamically varying set
+%% of pids. When the wait-loop terminates, no such message should remain
+%% in the mailbox.
+
+wait_for_task(Pid, St) ->
+    wait_for_tasks(sets:from_list([Pid]), St).
+
+wait_for_tasks(PidSet, St) ->
+    case sets:size(PidSet) of
+	0 ->
+	    ok;
+	_ ->
+	    %% (note that when we receive this message for some task, we
+	    %% are guaranteed that the insulator process of the task has
+	    %% already informed the supervisor about any anomalies)
+	    Reference = St#procstate.ref,
+	    receive
+		{done, Reference, Pid} ->
+		    %% (if Pid is not in the set, del_element has no
+		    %% effect, so this is always safe)
+		    Rest = sets:del_element(Pid, PidSet),
+		    wait_for_tasks(Rest, St)
+	    end
+    end.
+
+
+%% ---------------------------------------------------------------------
+%% Separate testing process
+
+tests(T, St) ->
+    I = eunit_data:iter_init(T, St#procstate.id),
+    case St#procstate.order of
+	inorder -> tests_inorder(I, St);
+	inparallel -> tests_inparallel(I, 0, St);
+	{inparallel, N} when is_integer(N), N >= 0 ->
+	    tests_inparallel(I, N, St)
+    end.
+
+set_id(I, St) ->
+    St#procstate{id = eunit_data:iter_id(I)}.
+
+tests_inorder(I, St) ->
+    tests_inorder(I, 0, St).
+
+tests_inorder(I, N, St) ->
+    case get_next_item(I) of
+	{T, I1} ->
+	    handle_item(T, set_id(I1, St)),
+	    tests_inorder(I1, N+1, St);
+	none ->
+	    N
+    end.
+
+tests_inparallel(I, K0, St) ->
+    tests_inparallel(I, 0, St, K0, K0, sets:new()).
+
+tests_inparallel(I, N, St, K, K0, Children) when K =< 0, K0 > 0 ->
+    wait_for_tasks(Children, St),
+    tests_inparallel(I, N, St, K0, K0, sets:new());
+tests_inparallel(I, N, St, K, K0, Children) ->
+    case get_next_item(I) of
+	{T, I1} ->
+	    Child = spawn_item(T, set_id(I1, St)),
+	    tests_inparallel(I1, N+1, St, K - 1, K0,
+			     sets:add_element(Child, Children));
+	none ->
+	    wait_for_tasks(Children, St),
+	    N
+    end.
+
+spawn_item(T, St0) ->
+    Fun = fun (St) ->
+		  fun () -> handle_item(T, St) end
+	  end,
+    %% inparallel-items are always spawned locally
+    start_task(local, Fun, St0).
+
+get_next_item(I) ->
+    eunit_data:iter_next(I, fun abort_task/1).
+
+handle_item(T, St) ->
+    case T of
+	#test{} -> handle_test(T, St);
+	#group{} -> handle_group(T, St)
+    end.
+
+handle_test(T, St) ->
+    progress_message('begin', test, St),
+    {Status, Time} = with_timeout(T#test.timeout, ?DEFAULT_TEST_TIMEOUT,
+				  fun () -> run_test(T) end, St),
+    progress_message('end', {Status, Time}, St),
+    ok.
+
+%% @spec (#test{}) -> ok | {error, eunit_lib:exception()}
+%%                  | {skipped, eunit_test:wrapperError()}
+
+run_test(#test{f = F}) ->
+    try eunit_test:run_testfun(F) of
+	{ok, _Value} ->
+	    %% just throw away the return value
+	    ok;
+	{error, Exception} ->
+	    {error, Exception}
+    catch
+	throw:WrapperError -> {skipped, WrapperError}
+    end.
+
+set_group_order(#group{order = undefined}, St) ->
+    St;
+set_group_order(#group{order = Order}, St) ->
+    St#procstate{order = Order}.
+
+handle_group(T, St0) ->
+    St = set_group_order(T, St0),
+    case T#group.spawn of
+	undefined ->
+	    run_group(T, St);
+	Type ->
+	    Child = spawn_group(Type, T, St),
+	    wait_for_task(Child, St)
+    end.
+
+spawn_group(Type, T, St0) ->
+    Fun = fun (St) ->
+		  fun () -> run_group(T, St) end
+	  end,
+    start_task(Type, Fun, St0).
+
+run_group(T, St) ->
+    %% note that the setup/cleanup is outside the group timeout; if the
+    %% setup fails, we do not start any timers
+    Timeout = T#group.timeout,
+    progress_message('begin', group, St),
+    F = fun (T) -> enter_group(T, Timeout, St) end,
+    try with_context(T, F) of
+	{Status, Time} ->
+	    progress_message('end', {Status, Time}, St)
+    catch
+	throw:Cause ->
+	    cancel_message({abort, Cause}, St)
+    end,
+    ok.
+
+enter_group(T, Timeout, St) ->
+    with_timeout(Timeout, ?DEFAULT_GROUP_TIMEOUT,
+		 fun () -> tests(T, St) end, St).
+
+with_context(#group{context = undefined, tests = T}, F) ->
+    F(T);
+with_context(#group{context = #context{} = C, tests = I}, F) ->
+    eunit_data:enter_context(C, I, F).
+
+%% Implementation of buffering I/O for the insulator process. (Note that
+%% each batch of characters is just pushed on the buffer, so it needs to
+%% be reversed when it is flushed.)
+
+io_request(From, ReplyAs, Req, Buf) ->
+    {Reply, Buf1} = io_request(Req, Buf),
+    io_reply(From, ReplyAs, Reply),
+    Buf1.
+
+io_reply(From, ReplyAs, Reply) ->
+    From ! {io_reply, ReplyAs, Reply}.
+
+io_request({put_chars, Chars}, Buf) ->
+    {ok, [Chars | Buf]};
+io_request({put_chars, M, F, As}, Buf) ->
+    try apply(M, F, As) of
+	Chars -> {ok, [Chars | Buf]}
+    catch
+	C:T -> {{error, {C,T,erlang:get_stacktrace()}}, Buf}
+    end;
+io_request({get_chars, _Prompt, _N}, Buf) ->
+    {eof, Buf};
+io_request({get_chars, _Prompt, _M, _F, _Xs}, Buf) ->
+    {eof, Buf};
+io_request({get_line, _Prompt}, Buf) ->
+    {eof, Buf};
+io_request({get_until, _Prompt, _M, _F, _As}, Buf) ->
+    {eof, Buf};
+io_request({setopts, _Opts}, Buf) ->
+    {ok, Buf};
+io_request({requests, Reqs}, Buf) ->
+    io_requests(Reqs, {ok, Buf});
+io_request(_, Buf) ->
+    {{error, request}, Buf}.
+
+io_requests([R | Rs], {ok, Buf}) ->
+    io_requests(Rs, io_request(R, Buf));
+io_requests(_, Result) ->
+    Result.

data/lib/erlang/messenger/lib/eunit/src/eunit_serial.erl

@@ -0,0 +1,157 @@
+%% This library is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Lesser General Public License as
+%% published by the Free Software Foundation; either version 2 of the
+%% License, or (at your option) any later version.
+%%
+%% This library is distributed in the hope that it will be useful, but
+%% WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+%% Lesser General Public License for more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public
+%% License along with this library; if not, write to the Free Software
+%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+%% USA
+%%
+%% $Id: eunit_serial.erl 249 2008-05-11 20:06:45Z rcarlsson $ 
+%%
+%% @author Richard Carlsson <richardc@it.uu.se>
+%% @copyright 2006 Richard Carlsson
+%% @private
+%% @see eunit
+%% @doc Event serializing process which works as an adapter and
+%% multiplexer for "supervisor" processes
+
+-module(eunit_serial).
+
+-include("eunit.hrl").
+-include("eunit_internal.hrl").
+
+-export([start/1]).
+
+%% Notes:
+%% * Due to concurrency, there are no guarantees that we will receive
+%% all status messages for the items within a group before we receive
+%% the 'end' message of the group itself.
+%% 
+%% * A cancelling event may arrive at any time, and may concern items we
+%% are not yet expecting (if tests are executed in parallel), or may
+%% concern not only the current item but possibly a group ancestor of
+%% the current item (as in the case of a group timeout).
+%% 
+%% * It is not possible to use selective receive to extract only those
+%% cancelling messages that affect the current item and its parents;
+%% basically, because we cannot have a dynamically computed prefix as a
+%% pattern in a receive. Hence, we must extract each cancelling event as
+%% it arrives and keep track of them separately.
+%% 
+%% * Before we wait for a new item, we must check whether it (and thus
+%% also all its subitems, if any) is already cancelled.
+%% 
+%% * When a new cancelling event arrives, we must either store it for
+%% future use, and/or cancel the current item and possibly one or more
+%% of its parent groups.
+
+-record(state, {listeners,
+		cancelled = eunit_lib:trie_new(),
+		messages = dict:new()}).
+
+start(Pids) ->
+    spawn(fun () -> serializer(Pids) end).
+
+serializer(Pids) ->
+    St = #state{listeners = sets:from_list(Pids),
+		cancelled = eunit_lib:trie_new(),
+		messages = dict:new()},
+    item([], none, none, St),
+    exit(normal).
+
+item(Id, ParentId, N0, St0) ->
+    case wait(Id, 'begin', ParentId, N0, St0) of
+	{none, St1} ->
+	    {true, St1};
+	{{cancel, Done, undefined}, St1} ->
+	    {Done, cast({status, Id, {cancel, undefined}}, St1)};
+	{{cancel, Done, Msg}, St1} ->
+	    {Done, cast(Msg, St1)};
+	{{ok, Msg}, St1} ->
+	    %%?debugVal({got_begin, Id, Msg}),
+	    cast(Msg, St1),
+	    St2 = case Msg of
+		      {status, _, {progress, 'begin', group}} ->
+			  items(Id, 0, St1);
+		      _ -> St1
+		  end,
+	    case wait(Id, 'end', ParentId, N0, St2) of
+		{{cancel, Done, undefined}, St3} ->
+		    {Done, cast({status, Id, {cancel, undefined}}, St3)};
+		{{cancel, Done, Msg1}, St3} ->
+		    {Done, cast(Msg1, St3)};
+		{{ok, Msg1}, St3} ->
+		    %%?debugVal({got_end, Id, Msg1}),
+		    {false, cast(Msg1, St3)}
+	    end
+    end.
+
+items(ParentId, N0, St) ->
+    N = N0 + 1,
+    case item(ParentId ++ [N], ParentId, N0, St) of
+	{false, St1} ->
+	    items(ParentId, N, St1);
+	{true, St1} ->
+	    St1
+    end.
+
+cast(M, St) ->
+    sets:fold(fun (L, M) -> L ! M end, M, St#state.listeners),
+    St.
+
+wait(Id, Type, ParentId, N0, St) ->
+    %%?debugVal({wait, Id, Type}),
+    case check_cancelled(Id, St) of
+	no ->
+	    case recall(Id, St) of
+		undefined ->
+		    wait_1(Id, Type, ParentId, N0, St);
+		Msg ->
+		    {{ok, Msg}, forget(Id, St)}
+	    end;
+	Why ->
+	    %%?debugVal({cancelled, Why, Id, ParentId}),
+	    Done = (Why =:= prefix),
+	    {{cancel, Done, recall(Id, St)}, forget(Id, St)}
+    end.
+
+wait_1(Id, Type, ParentId, N0, St) ->
+    receive
+	{status, Id, {progress, Type, _}}=Msg ->
+	    %%?debugVal({Type, ParentId, Id}),
+	    {{ok, Msg}, St};
+	{status,ParentId,{progress,'end',{N0,_,_}}}=Msg ->
+	    %%?debugVal({end_group, ParentId, Id}),
+	    {none, remember(ParentId, Msg, St)};
+	{status, SomeId, {cancel, _Cause}}=Msg ->
+	    %%?debugVal({got_cancel, SomeId, ParentId, Id}),
+	    St1 = set_cancelled(SomeId, Msg, St),
+	    wait(Id, Type, ParentId, N0, St1)
+    end.
+
+set_cancelled(Id, Msg, St0) ->
+    St = remember(Id, Msg, St0),
+    St#state{cancelled = eunit_lib:trie_store(Id, St0#state.cancelled)}.
+
+check_cancelled(Id, St) ->
+    eunit_lib:trie_match(Id, St#state.cancelled).
+
+remember(Id, Msg, St) ->
+    St#state{messages = dict:store(Id, Msg, St#state.messages)}.
+
+forget(Id, St) ->
+    %% this is just to enable garbage collection of old messages
+    St#state{messages = dict:store(Id, undefined, St#state.messages)}.
+
+recall(Id, St) ->
+    case dict:find(Id, St#state.messages) of
+	{ok, Msg} -> Msg;
+	error -> undefined
+    end.