Asserter.h

Go to the documentation of this file.

/**************************************************************************

   begin                : Sat Dec 21 2002
   copyright            : (C) 2002-2010 by Ewald Arnold
   email                : mockpp at ewald-arnold dot de

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 **/

#ifndef MOCKPP_ASSERT_H
#define MOCKPP_ASSERT_H

#include <mockpp/mockpp.h> // always first

#include <mockpp/compat/AssertionFailedError.h>


MOCKPP_NS_START


  MOCKPP_API_DECL(void) assertTrue(unsigned srcline, const char* srcfile,
                                   const String &message, bool condition);

  MOCKPP_API_DECL(void) assertTrue(unsigned srcline, const char* srcfile,
                                   bool condition);

  MOCKPP_API_DECL(void) assertFalse(unsigned srcline, const char* srcfile,
                                    const String &message, bool condition);

  MOCKPP_API_DECL(void) assertFalse(unsigned srcline, const char* srcfile,
                                    bool condition);

  MOCKPP_API_DECL(void) fail(unsigned srcline, const char* srcfile,
                             const String &message);

  MOCKPP_API_DECL(void) fail(unsigned srcline, const char* srcfile);

  MOCKPP_API_DECL(void) assertDelta(unsigned srcline, const char* srcfile,
                                    const String &message,
                                    double expected, double actual, double delta);

  MOCKPP_API_DECL(void) assertDelta(unsigned srcline, const char* srcfile,
                                    double expected, double actual, double delta);

  MOCKPP_API_DECL(void) assertDelta(unsigned srcline, const char* srcfile,
                                    const String &message,
                                    float expected, float actual, float delta);


  MOCKPP_API_DECL(void) assertDelta(unsigned srcline, const char* srcfile,
                                    float expected, float actual, float delta);

  MOCKPP_API_DECL(void) assertEquals(unsigned srcline, const char* srcfile,
                                     const String &message,
                                     const char *expected, const char *actual);

  MOCKPP_API_DECL(void) assertEquals(unsigned srcline, const char* srcfile,
                                     const char *expected, const char *actual);

#ifdef MOCKPP_UNICODE

  MOCKPP_API_DECL(void) 
     assertEquals(unsigned srcline, const char* srcfile,
                  const String &message,
                  const wchar_t *expected, const wchar_t *actual);

  MOCKPP_API_DECL(void)
     assertEquals(unsigned srcline, const char* srcfile,
                  const wchar_t *expected, const wchar_t *actual);

#endif

  template <class T>
  void assertEquals(unsigned srcline, const char* srcfile,
                    const String &message, const T &expected, const T &actual)
  {
    if (expected != actual)
      fail(srcline, srcfile, message);
  }


  template <class T>
  void assertEquals(unsigned srcline, const char* srcfile,
                    const T &expected, const T &actual)
  {
    assertEquals(srcline, srcfile, MOCKPP_PCHAR(""), expected, actual);
  }


template <class T>
void assertDelta(unsigned srcline, const char* srcfile,
                 const String &message,
                 const T &expected, const T &actual, const T &delta)
{
  T diff = expected < actual
         ? actual   - expected
         : expected - actual;
  if (diff > delta)
    fail(srcline, srcfile, message);
}


  template <class T>
  void assertDelta(unsigned srcline, const char* srcfile,
                   const T &expected, const T &actual, const T &delta)
  {
    assertDelta(srcline, srcfile, MOCKPP_PCHAR(""), expected, actual, delta);
  }


  template <class T>
  void assertBoundary(unsigned srcline, const char* srcfile,
                      const String &message,
                      const T &lo, const T &up, const T &actual)
  {
    if ((actual < lo) || (up < actual))
      fail(srcline, srcfile, message);
  }


  template <class T>
  void assertBoundary(unsigned srcline, const char* srcfile,
                      const T &lo, const T &up, const T &actual)
  {
    assertBoundary(srcline, srcfile, MOCKPP_PCHAR(""), lo, up, actual);
  }


MOCKPP_NS_END


#define MOCKPP_ASSERT_EQUALS_MESSAGE(msg, a, b)  MOCKPP_NS::assertEquals(__LINE__, __FILE__, msg, a, b)

#define MOCKPP_ASSERT_EQUALS(a, b)  MOCKPP_NS::assertEquals(__LINE__, __FILE__, MOCKPP_PCHAR("invalid: ") \
                                                          MOCKPP_PCHAR(#a) MOCKPP_PCHAR(" == ") MOCKPP_PCHAR(#b), a, b)

#define MOCKPP_ASSERT_DELTA_MESSAGE(msg, a, b, delta)  MOCKPP_NS::assertDelta(__LINE__, __FILE__, msg, a, b, delta)

# define MOCKPP_ASSERT_DELTA(a, b, delta)  MOCKPP_NS::assertDelta(__LINE__, __FILE__, MOCKPP_PCHAR("invalid: ") \
                                                               MOCKPP_PCHAR(#a) MOCKPP_PCHAR(" +- ") MOCKPP_PCHAR(#delta) \
                                                               MOCKPP_PCHAR(" == ") MOCKPP_PCHAR(#b), a, b, delta)

#define MOCKPP_ASSERT_BOUNDARY_MESSAGE(msg, lo, up, a)  MOCKPP_NS::assertBoundary(__LINE__, __FILE__, msg, lo, up, a)

# define MOCKPP_ASSERT_BOUNDARY(lo, up, a)  MOCKPP_NS::assertBoundary(__LINE__, __FILE__, MOCKPP_PCHAR("invalid: ") \
                                                                   MOCKPP_PCHAR(#lo) MOCKPP_PCHAR(" < ") MOCKPP_PCHAR(#a) \
                                                                   MOCKPP_PCHAR(" < ") MOCKPP_PCHAR(#up), lo, up, a)

#define MOCKPP_ASSERT_TRUE_MESSAGE(msg, cond) MOCKPP_NS::assertTrue(__LINE__, __FILE__, msg, cond)

# define MOCKPP_ASSERT_TRUE(cond) MOCKPP_NS::assertTrue(__LINE__, __FILE__, MOCKPP_PCHAR("!true: ") MOCKPP_PCHAR(#cond), cond)

#define MOCKPP_ASSERT_FALSE_MESSAGE(msg, cond) MOCKPP_NS::assertFalse(__LINE__, __FILE__, msg, cond)

# define MOCKPP_ASSERT_FALSE(cond) MOCKPP_NS::assertFalse(__LINE__, __FILE__, MOCKPP_PCHAR("!false: ") MOCKPP_PCHAR(#cond), cond)

#define MOCKPP_FAIL(msg)  MOCKPP_NS::fail(__LINE__, __FILE__, msg)


#endif // MOCKPP_ASSERT_H

---