anchor.diff:          end
       end)(Expect))).
   
  --define(assertReceived(Expect), ?assertReceived(Expect, 0)).
  -
  --define(assertReceived(Expect, Timeout),
  +-undef(assert).
  +-define(assert(Expr), ?assertEqual(true, Expr)).
  +
  +-define(assertReceivedMatch(Expect), ?assertReceivedMatch(Expect, 0)).
  +
  +-define(assertReceivedMatch(Expect, Timeout),
       ((fun() ->
           receive
               Expect = Result -> Result
  
positive.code: -define(TEST, true).
  -include_lib("eunit/include/eunit.hrl").
  
  -undef(assert).
  -define(assert(BoolExpr),
      ((fun() ->
          case (BoolExpr) of
              true -> ok;
              __V ->
                  __Args = [{module, ?MODULE},
                      {line, ?LINE},
                      {expression, (??BoolExpr)},
                      {expected, true},
                      {value, __V}],
                  ct:print("assertion_failed: ~p~n", [__Args]),
                  erlang:error({assertion_failed, __Args})
          end
      end)())).
  
  -undef(assertMatch).
  -define(assertMatch(Guard, Expr),
      ((fun() ->
  
negative.code:                     {line, ?LINE},
                      {expected, (??Expect)},
                      {value, timeout}],
                  ct:print("assertReceivedMatch_failed: ~p~n", [__Args]),
                  erlang:error({assertReceivedMatch_failed, __Args})
          end
      end)())).
  
  -define(assertReceivedNextMatch(Expect), ?assertReceivedNextMatch(Expect, 0)).
  
  -define(assertReceivedNextMatch(Expect, Timeout),
      ((fun() ->
          receive
              Expect = Result -> Result;
              __V ->
                  __Args = [{module, ?MODULE},
                      {line, ?LINE},
                      {expected, (??Expect)},
                      {value, __V}],
                  ct:print("assertReceivedNextMatch_failed: ~p~n", [__Args]),
                  erlang:error({assertReceivedNextMatch_failed, __Args})
          after
              Timeout ->
                  __Args = [{module, ?MODULE},
                      {line, ?LINE},
                      {expected, (??Expect)},
                      {value, timeout}],
                  ct:print("assertReceivedNextMatch_failed: ~p~n", [__Args]),
                  erlang:error({assertReceivedNextMatch_failed, __Args})
          end
      end)())).
  
  -define(assertNotReceivedMatch(Expect), ?assertNotReceivedMatch(Expect, 0)).
  
  -define(assertNotReceivedMatch(Expect, Timeout),
      ((fun() ->
          receive
              Expect = Result ->
  