anchor.diff:                      {expression, (??Expect)},
                       {expected, timeout},
                       {value, (??Result)}],
  -                ct:print("assertNotReceived_failed: ~p~n", [__Args]),
  -                erlang:error({assertNotReceived_failed, __Args})
  +                ct:print("assertNotReceivedMatch_failed: ~p~n", [__Args]),
  +                erlang:error({assertNotReceivedMatch_failed, __Args})
           after
               Timeout -> ok
           end
       end)())).
  +
  +-define(assertReceivedEqual(Expect), ?assertReceivedEqual(Expect, 0)).
  +
  +-define(assertReceivedEqual(Expect, Timeout),
  +    ((fun(__X) ->
  +        receive
  +            __X -> __X
  +        after
  +            Timeout ->
  +                __Args = [{module, ?MODULE},
  +                    {line, ?LINE},
  +                    {expected, (??Expect)},
  +                    {value, timeout}],
  +                ct:print("assertReceivedEqual_failed: ~p~n", [__Args]),
  +                erlang:error({assertReceived_failed, __Args})
  +        end
  +    end)(Expect))).
  +
  +-define(assertReceivedNextEqual(Expect), ?assertReceivedNextEqual(Expect, 0)).
  +
  +-define(assertReceivedNextEqual(Expect, Timeout),
  +    ((fun(__X) ->
  +        receive
  +            __X -> __X;
  +            __V ->
  +                __Args = [{module, ?MODULE},
  +                    {line, ?LINE},
  +                    {expected, __X},
  +                    {value, __V}],
  +                ct:print("assertReceivedNextEqual_failed: ~p~n", [__Args]),
  +                erlang:error({assertReceivedNextEqual_failed, __Args})
  +        after
  +            Timeout ->
  +                __Args = [{module, ?MODULE},
  +                    {line, ?LINE},
  +                    {expected, (??Expect)},
  +                    {value, timeout}],
  +                ct:print("assertReceivedNextEqual_failed: ~p~n", [__Args]),
  +                erlang:error({assertReceivedNextEqual_failed, __Args})
  +        end
  +    end)(Expect))).
  +
  +-define(assertNotReceivedEqual(Expect), ?assertNotReceivedEqual(Expect, 0)).
  +
  +-define(assertNotReceivedEqual(Expect, Timeout),
  +    ((fun(__X) ->
  +        receive
  +            __X ->
  +                __Args = [{module, ?MODULE},
  +                    {line, ?LINE},
  +                    {expected, timeout},
  +                    {value, __X}],
  +                ct:print("assertNotReceivedEqual_failed: ~p~n", [__Args]),
  +                erlang:error({assertNotReceivedEqual_failed, __Args})
  +        after
  +            Timeout -> ok
  +        end
  +    end)(Expect))).
   
   -undef(assertException).
   -define(assertException(Class, Term, Expr),
  
positive.code:         end
      end)(Expect))).
  
  -define(assertReceived(Expect), ?assertReceived(Expect, 0)).
  
  -define(assertReceived(Expect, Timeout),
      ((fun() ->
          receive
              Expect = Result -> Result
  
negative.code: -define(TEST, true).
  -include_lib("eunit/include/eunit.hrl").
  
  -undef(assertMatch).
  -define(assertMatch(Guard, Expr),
      ((fun() ->
  