anchor.diff:  
       i("start tcp (stream) socket"),
       ClientInitState1 = #{},
  -    Client1          = evaluator_start("tcp-client", ClientSeq, ClientInitState1),
  +    #ev{pid = Pid1} = Client1 = evaluator_start("tcp-client", 
  +                                                ClientSeq, ClientInitState1),
       TesterInitState1 = #{domain   => inet, 
                            type     => stream, 
                            protocol => tcp,
  -                         client   => Client1},
  +                         client   => Pid1},
       Tester1          = evaluator_start("tcp-tester", TesterSeq, TesterInitState1),
       i("await tcp evaluator"),
       ok = await_evaluator_finish([Tester1, Client1]),
   
       i("start udp (dgram) socket"),
       ClientInitState2 = #{},
  -    Client2          = evaluator_start("udp-client", ClientSeq, ClientInitState2),
  +    #ev{pid = Pid2} = Client2 = evaluator_start("udp-client", 
  +                                                ClientSeq, ClientInitState2),
       TesterInitState2 = #{domain   => inet, 
                            type     => dgram, 
                            protocol => udp,
  -                         client   => Client2},
  +                         client   => Pid2},
       Tester2          = evaluator_start("udp-tester", TesterSeq, TesterInitState2),
       i("await udp evaluator"),
       ok = await_evaluator_finish([Tester2, Client2]).
  
positive.code: api_b_sendmsg_and_recvmsg_udp4(doc) ->
      [];
  api_b_sendmsg_and_recvmsg_udp4(_Config) when is_list(_Config) ->
      tc_try(api_b_sendmsg_and_recvmsg_udp4,
             fun() ->
                     Send = fun(Sock, Data, Dest) ->
  
negative.code: await_evaluator_finish(Evs, Fails) ->
      receive
          {'DOWN', _MRef, process, Pid, normal} ->
              case lists:keysearch(Pid, #ev.pid, Evs) of
                  {value, #ev{name = Name}} ->
                      i("evaluator '~s' (~p) success", [Name, Pid]),
                      NewEvs = lists:keydelete(Pid, #ev.pid, Evs),
                      await_evaluator_finish(NewEvs, Fails);
                  false ->
                      i("unknown process ~p died (normal)", [Pid]),
                      await_evaluator_finish(Evs, Fails)
                  end;
          {'DOWN', _MRef, process, Pid, Reason} ->
              case lists:keysearch(Pid, #ev.pid, Evs) of
                  {value, #ev{name = Name}} ->
                      i("evaluator '~s' (~p) failed", [Name, Pid]),
                      NewEvs = lists:keydelete(Pid, #ev.pid, Evs),
                      await_evaluator_finish(NewEvs, [{Pid, Reason}|Fails]);
                  false ->
                      i("unknown process ~p died: "
                        "~n   ~p", [Pid, Reason]),
                      await_evaluator_finish(Evs, Fails)
                  end
      end.
  
  
  