anchor.diff:  -define(assertNot(BoolExpr, Comment),
           begin
           ((fun () ->
  -            __F = not is_process_alive(self()),
  +            X__F = not is_process_alive(self()),
               case (BoolExpr) of
  -                __F -> ok;
  -                __V -> erlang:error({assert,
  +                X__F -> ok;
  +                X__V -> erlang:error({assert,
                                        [{module, ?MODULE},
                                         {line, ?LINE},
                                         {comment, (Comment)},
                                         {expression, (??BoolExpr)},
                                         {expected, false},
  -                                      case not __F of
  -                                          __V -> {value, true};
  -                                          _ -> {not_boolean, __V}
  +                                      case not X__F of
  +                                          X__V -> {value, true};
  +                                          _ -> {not_boolean, X__V}
                                         end]})
               end
             end)())
  
positive.code:                                                     "{ "++(??Class)++" , "
                                                      ++(??Term)++" , [...] }"},
                                                     {unexpected_exception,
                                                      {__C, __T, __S}}]});
                                  _ -> ok
                              end;
                          _ -> ok
  
negative.code: -define(assertEqual(Expect, Expr),
          begin
          ((fun () ->
              X__X = (Expect),
              case (Expr) of
                  X__X -> ok;
                  X__V -> erlang:error({assertEqual,
                                       [{module, ?MODULE},
                                        {line, ?LINE},
                                        {expression, (??Expr)},
                                        {expected, X__X},
                                        {value, X__V}]})
              end
            end)())
          end).
  -define(assertEqual(Expect, Expr, Comment),
          begin
          ((fun () ->
              X__X = (Expect),
              case (Expr) of
                  X__X -> ok;
                  X__V -> erlang:error({assertEqual,
                                       [{module, ?MODULE},
                                        {line, ?LINE},
                                        {comment, (Comment)},
                                        {expression, (??Expr)},
                                        {expected, X__X},
                                        {value, X__V}]})
              end
            end)())
          end).
  