anchor.diff:          [{trace, Pid, send, Msg, S}] when TraceEvent ->
               ok;
           [{trace, Pid, send, Msg, S, Message}] when TraceEvent == Message ->
  +            ok;
  +        Else ->
  +            ct:fail({got_unexpected_message, Else})
  +    end.
  +
  +recv(Config) when is_list(Config) ->
  +    {ok, _} = start(),
  +    Node = start_slave(),
  +    rpc:call(Node, code, add_patha,
  +             [filename:join(proplists:get_value(data_dir, Config), "..")]),
  +    try
  +        Echo = fun F() ->
  +                       receive {From, M} ->
  +                               From ! M,
  +                               F()
  +                       end
  +               end,
  +	Rcvr = spawn_link(Echo),
  +        RemoteRcvr = spawn_link(Node, Echo),
  +
  +	{ok, [{matched, _, 1}]} = dbg:p(Rcvr, 'receive'),
  +
  +        recv_test(Rcvr, make_ref(), true),
  +
  +        %% Test that the test case process is the sending process
  +        recv_test(Rcvr, [{[node(), self(), '_'],[],[]}]),
  +
  +        %% Test that self() is the not sending process
  +        {ok, [{matched, _node, 1}, {saved, 2}]} =
  +            dbg:tpe('receive', [{[node(), '$1','_'],[{'==','$1',{self}}],[]}]),
  +        recv_test(Rcvr, make_ref(), false),
  +
  +        %% Test that self() is the receiving process
  +        recv_test(Rcvr, [{'_',[{'==',Rcvr,{self}}],[]}]),
  +
  +        %% Test attaching a message
  +        recv_test(Rcvr, [{'_',[{'==',Rcvr,{self}}],[{message, hello}]}],
  +                  make_ref(), hello),
  +
  +        %% Test using a saved trace pattern
  +        recv_test(Rcvr, 2, make_ref(), false),
  +
  +        %% Test clearing of trace pattern
  +        {ok, [{matched, _node, 1}]} = dbg:ctpe('receive'),
  +        recv_test(Rcvr, make_ref(), true),
  +
  +        %% Test complex message inspection
  +        Ref = make_ref(),
  +        recv_test(Rcvr,
  +                  [{[node(), '_','$2'],[{'==',Ref,{element,1,
  +                                                   {element,2,
  +                                                    {element,2,'$2'}}}}],[]}],
  +                  {test, {Ref}, <<0:(8*1024)>>}, true),
  +
  +        recv_test(Rcvr, {test, {make_ref()}, <<0:(8*1024)>>}, false),
  +
  +        %% Test recv to remote process
  +        remote_recv_test(RemoteRcvr, Rcvr, [], make_ref(), true),
  +
  +        remote_recv_test(RemoteRcvr, Rcvr,
  +                         [{['$1',undefined,'_'],[{'==','$1',{node}}],[]}],
  +                         make_ref(), false),
  +
  +        remote_recv_test(RemoteRcvr, Rcvr,
  +                         [{['$1',undefined,'_'],[{'==','$1',Node}],[]}],
  +                         make_ref(), true),
  +
  +        %% Test that distributed dbg works
  +        dbg:tracer(Node, process, {fun myhandler/2, self()}),
  +        Rcvr2 = spawn_link(Echo),
  +        RemoteRcvr2 = spawn_link(Node, Echo),
  +        dbg:p(Rcvr2, ['receive']),
  +        dbg:p(RemoteRcvr2, ['receive']),
  +        dbg:tpe('receive', [{[node(), '_', '$1'],[{'==',{element,2,'$1'}, hej}],[]}]),
  +
  +        recv_test(Rcvr2, make_ref(), false),
  +        recv_test(RemoteRcvr2, make_ref(), false),
  +        recv_test(Rcvr2, hej, true),
  +        recv_test(RemoteRcvr2, hej, true),
  +
  +        ok
  +
  +    after
  +	stop()
  +    end.
  +
  +recv_test(Pid, Pattern, Msg, TraceEvent) ->
  +    {ok, [{matched, _, _}, _]} = dbg:tpe('receive', Pattern),
  +    recv_test(Pid, Msg, TraceEvent).
  +recv_test(Pid, Pattern) ->
  +    recv_test(Pid, Pattern, make_ref(), true).
  +recv_test(Pid, Msg, TraceEvent) ->
  +    S = self(),
  +    Pid ! {S, Msg},
  +    receive Msg -> ok end,
  +    recv_test_rcv(Pid, {S, Msg}, TraceEvent).
  +
  +remote_recv_test(RPid, Pid, Pattern, Msg, TraceEvent) ->
  +    dbg:tpe('receive', Pattern),
  +    TMsg = {self(), Msg},
  +    RPid ! {Pid, TMsg},
  +    receive Msg -> ok end,
  +    recv_test_rcv(Pid, TMsg, TraceEvent).
  +
  +recv_test_rcv(Pid, Msg, TraceEvent) ->
  +    case flush() of
  +        [] when not TraceEvent ->
  +            ok;
  +        [{trace, Pid, 'receive', Msg}] when TraceEvent ->
  +            ok;
  +        [{trace, Pid, 'receive', Msg, Message}] when TraceEvent == Message ->
               ok;
           Else ->
               ct:fail({got_unexpected_message, Else})
  
positive.code: %% Test functions
  -export([all/0, suite/0,
           big/1, tiny/1, simple/1, message/1, distributed/1, port/1,
  	 send/1,
           ip_port/1, file_port/1, file_port2/1, file_port_schedfix/1,
           ip_port_busy/1, wrap_port/1, wrap_port_time/1,
           with_seq_trace/1, dead_suspend/1, local_trace/1,
  
negative.code: 
  all() -> 
      [big, tiny, simple, message, distributed, port, ip_port,
       send, recv,
       file_port, file_port2, file_port_schedfix, ip_port_busy,
       wrap_port, wrap_port_time, with_seq_trace, dead_suspend,
       local_trace, saved_patterns, tracer_exit_on_stop,
  