TestAssert.h

Go to the documentation of this file.

#ifndef CPPUNIT_TESTASSERT_H
#define CPPUNIT_TESTASSERT_H
 
#include <cppunit/Portability.h>
#include <cppunit/Exception.h>
#include <cppunit/Asserter.h>
#include <cppunit/portability/Stream.h>
#include <cppunit/tools/StringHelper.h>
#include <stdio.h>
#include <float.h> // For struct assertion_traits<double>
 
// Work around "passing 'T' chooses 'int' over 'unsigned int'" warnings when T
// is an enum type:
#if defined __GNUC__ && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6))
#pragma GCC system_header
#endif
 
 
CPPUNIT_NS_BEGIN
 
template <class T>
struct assertion_traits 
{  
    static bool equal( const T& x, const T& y )
    {
        return x == y;
    }
 
    static bool less( const T& x, const T& y )
    {
        return x < y;
    }
 
    static bool lessEqual( const T& x, const T& y )
    {
        return x <= y;
    }
 
    static std::string toString( const T& x )
    {
        return CPPUNIT_NS::StringHelper::toString(x);
    }
};
 
template <>
struct assertion_traits<double>
{  
    static bool equal( double x, double y )
    {
        return x == y;
    }
 
    static bool less( double x, double y )
    {
        return x < y;
    }
 
    static bool lessEqual( double x, double y )
    {
        return x <= y;
    }
 
    static std::string toString( double x )
    {
#ifdef DBL_DIG
       const int precision = DBL_DIG;
#else
       const int precision = 15;
#endif  // #ifdef DBL_DIG
       char buffer[128];
#ifdef __STDC_SECURE_LIB__ // Use secure version with visual studio 2005 to avoid warning.
       sprintf_s(buffer, sizeof(buffer), "%.*g", precision, x); 
#else   
       sprintf(buffer, "%.*g", precision, x); 
#endif
       return buffer;
    }
};
 
 
inline std::string message_to_string( const std::string& s )
{
    return s;
}
inline std::string message_to_string( const OStream& out )
{
    OStringStream ost;
    ost << out.rdbuf();
    return ost.str();
}
inline AdditionalMessage message_to_string( const AdditionalMessage& msg )
{
    return msg;
}
inline std::string message_to_string( const char * s )
{
    return s;
}
 
template <class T>
void assertEquals( const T& expected,
                   const T& actual,
                   SourceLine sourceLine,
                   const std::string &message )
{
  if ( !assertion_traits<T>::equal(expected,actual) ) // lazy toString conversion...
  {
    Asserter::failNotEqual( assertion_traits<T>::toString(expected),
                            assertion_traits<T>::toString(actual),
                            sourceLine,
                            message );
  }
}
 
 
void CPPUNIT_API assertDoubleEquals( double expected,
                                     double actual,
                                     double delta,
                                     SourceLine sourceLine, 
                                     const std::string &message );
 
 
template <class T>
void assertLess( const T& expected,
                 const T& actual,
                 SourceLine sourceLine,
                 const std::string& message )
{
    if ( !assertion_traits<T>::less(actual,expected) )
    {
        Asserter::failNotLess( assertion_traits<T>::toString(expected),
                               assertion_traits<T>::toString(actual),
                               sourceLine,
                               message );
    }
}
 
 
template <class T>
void assertGreater( const T& expected,
                 const T& actual,
                 SourceLine sourceLine,
                 const std::string& message )
{
    if ( !assertion_traits<T>::less(expected,actual) )
    {
        Asserter::failNotGreater( assertion_traits<T>::toString(expected),
                               assertion_traits<T>::toString(actual),
                               sourceLine,
                               message );
    }
}
 
template <class T>
void assertLessEqual( const T& expected,
                      const T& actual,
                      SourceLine sourceLine,
                      const std::string& message )
{
    if ( !assertion_traits<T>::lessEqual(actual,expected) )
    {
        Asserter::failNotLessEqual( assertion_traits<T>::toString(expected),
                               assertion_traits<T>::toString(actual),
                               sourceLine,
                               message );
    }
}
 
template <class T>
void assertGreaterEqual( const T& expected,
                      const T& actual,
                      SourceLine sourceLine,
                      const std::string& message )
{
    if ( !assertion_traits<T>::lessEqual(expected,actual) )
    {
        Asserter::failNotGreaterEqual( assertion_traits<T>::toString(expected),
                               assertion_traits<T>::toString(actual),
                               sourceLine,
                               message );
    }
}
/* A set of macros which allow us to get the line number
 * and file name at the point of an error.
 * Just goes to show that preprocessors do have some
 * redeeming qualities.
 */
#if CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION
#define CPPUNIT_ASSERT(condition)                                                 \
  ( CPPUNIT_NS::Asserter::failIf( !(condition),                                   \
                                 CPPUNIT_NS::Message( "assertion failed",         \
                                                      "Expression: " #condition), \
                                 CPPUNIT_SOURCELINE() ) )
#else
#define CPPUNIT_ASSERT(condition)                                            \
  ( CPPUNIT_NS::Asserter::failIf( !(condition),                              \
                                  CPPUNIT_NS::Message( "assertion failed" ), \
                                  CPPUNIT_SOURCELINE() ) )
#endif
 
#define CPPUNIT_ASSERT_MESSAGE(message,condition)                          \
  ( CPPUNIT_NS::Asserter::failIf( !(condition),                            \
                                  CPPUNIT_NS::Message( "assertion failed", \
                                                       "Expression: "      \
                                                       #condition,         \
                                                       CPPUNIT_NS::message_to_string(message) ),          \
                                  CPPUNIT_SOURCELINE() ) )
 
#define CPPUNIT_FAIL( message )                                         \
  ( CPPUNIT_NS::Asserter::fail( CPPUNIT_NS::Message( "forced failure",  \
                                                     CPPUNIT_NS::message_to_string(message) ),         \
                                CPPUNIT_SOURCELINE() ) )
 
#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
#define CPPUNIT_ASSERT_EQUAL(expected,actual)                     \
  ( CPPUNIT_NS::assertEquals( (expected),             \
                              (actual),               \
                              __LINE__, __FILE__ ) )
#else
#define CPPUNIT_ASSERT_EQUAL(expected,actual)          \
  ( CPPUNIT_NS::assertEquals( (expected),              \
                              (actual),                \
                              CPPUNIT_SOURCELINE(),    \
                              "" ) )
 
#define CPPUNIT_ASSERT_EQUAL_MESSAGE(message,expected,actual)      \
  ( CPPUNIT_NS::assertEquals( (expected),              \
                              (actual),                \
                              CPPUNIT_SOURCELINE(),    \
                              CPPUNIT_NS::message_to_string(message) ) )
#endif
 
#define CPPUNIT_ASSERT_LESS(expected, actual)          \
    ( CPPUNIT_NS::assertLess( (expected),              \
                              (actual),                \
                              CPPUNIT_SOURCELINE(),    \
                              "" ) )
 
#define CPPUNIT_ASSERT_GREATER(expected, actual)       \
    ( CPPUNIT_NS::assertGreater( (expected),           \
                                 (actual),             \
                                 CPPUNIT_SOURCELINE(), \
                                 "" ) )
 
#define CPPUNIT_ASSERT_LESSEQUAL(expected, actual)               \
    ( CPPUNIT_NS::assertLessEqual( (expected),              \
                                   (actual),                \
                                   CPPUNIT_SOURCELINE(),    \
                                   "" ) )
 
#define CPPUNIT_ASSERT_GREATEREQUAL(expected, actual)            \
    ( CPPUNIT_NS::assertGreaterEqual( (expected),                \
                                      (actual),              \
                                      CPPUNIT_SOURCELINE(),    \
                                      "" ) )
#define CPPUNIT_ASSERT_DOUBLES_EQUAL(expected,actual,delta)        \
  ( CPPUNIT_NS::assertDoubleEquals( (expected),            \
                                    (actual),              \
                                    (delta),               \
                                    CPPUNIT_SOURCELINE(),  \
                                    "" ) )
 
 
#define CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(message,expected,actual,delta)  \
  ( CPPUNIT_NS::assertDoubleEquals( (expected),            \
                                    (actual),              \
                                    (delta),               \
                                    CPPUNIT_SOURCELINE(),  \
                                    CPPUNIT_NS::message_to_string(message) ) )
 
 
# define CPPUNIT_ASSERT_THROW( expression, ExceptionType )              \
   CPPUNIT_ASSERT_THROW_MESSAGE( CPPUNIT_NS::AdditionalMessage(),       \
                                 expression,                            \
                                 ExceptionType )
 
 
// implementation detail
#if defined(CPPUNIT_USE_TYPEINFO_NAME)
#define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \
   CPPUNIT_NS::TypeInfoHelper::getClassName( typeid(exception) )
#else
#define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \
   std::string( no_rtti_message )
#endif // CPPUNIT_USE_TYPEINFO_NAME
 
// implementation detail
#define CPPUNIT_GET_PARAMETER_STRING( parameter ) #parameter
 
# define CPPUNIT_ASSERT_THROW_MESSAGE( message, expression, ExceptionType )   \
   do {                                                                       \
      bool cpputCorrectExceptionThrown_ = false;                              \
      CPPUNIT_NS::Message cpputMsg_( "expected exception not thrown" );       \
      cpputMsg_.addDetail( CPPUNIT_NS::message_to_string(message) );                                         \
      cpputMsg_.addDetail( "Expected: "                                       \
                           CPPUNIT_GET_PARAMETER_STRING( ExceptionType ) );   \
                                                                              \
      try {                                                                   \
         expression;                                                          \
      } catch ( const ExceptionType & ) {                                     \
         cpputCorrectExceptionThrown_ = true;                                 \
      } catch ( const std::exception &e) {                                    \
         cpputMsg_.addDetail( "Actual  : " +                                  \
                              CPPUNIT_EXTRACT_EXCEPTION_TYPE_( e,             \
                                          "std::exception or derived") );     \
         cpputMsg_.addDetail( std::string("What()  : ") + e.what() );         \
      } catch ( ... ) {                                                       \
         cpputMsg_.addDetail( "Actual  : unknown.");                          \
      }                                                                       \
                                                                              \
      if ( cpputCorrectExceptionThrown_ )                                     \
            { break; }                                                        \
                                                                              \
      CPPUNIT_NS::Asserter::fail( cpputMsg_,                                  \
                                  CPPUNIT_SOURCELINE() );                     \
   } while ( false )
 
 
# define CPPUNIT_ASSERT_NO_THROW( expression )                             \
   CPPUNIT_ASSERT_NO_THROW_MESSAGE( CPPUNIT_NS::AdditionalMessage(),       \
                                    expression )
 
 
# define CPPUNIT_ASSERT_NO_THROW_MESSAGE( message, expression )               \
   do {                                                                       \
      CPPUNIT_NS::Message cpputMsg_( "unexpected exception caught" );         \
      cpputMsg_.addDetail( CPPUNIT_NS::message_to_string(message) );                                         \
                                                                              \
      try {                                                                   \
         expression;                                                          \
      } catch ( const std::exception &e ) {                                   \
         cpputMsg_.addDetail( "Caught: " +                                    \
                              CPPUNIT_EXTRACT_EXCEPTION_TYPE_( e,             \
                                          "std::exception or derived" ) );    \
         cpputMsg_.addDetail( std::string("What(): ") + e.what() );           \
         CPPUNIT_NS::Asserter::fail( cpputMsg_,                               \
                                     CPPUNIT_SOURCELINE() );                  \
      } catch ( ... ) {                                                       \
         cpputMsg_.addDetail( "Caught: unknown." );                           \
         CPPUNIT_NS::Asserter::fail( cpputMsg_,                               \
                                     CPPUNIT_SOURCELINE() );                  \
      }                                                                       \
   } while ( false )
 
 
# define CPPUNIT_ASSERT_ASSERTION_FAIL( assertion )                 \
   CPPUNIT_ASSERT_THROW( assertion, CPPUNIT_NS::Exception )
 
 
# define CPPUNIT_ASSERT_ASSERTION_FAIL_MESSAGE( message, assertion )    \
   CPPUNIT_ASSERT_THROW_MESSAGE( message, assertion, CPPUNIT_NS::Exception )
 
 
# define CPPUNIT_ASSERT_ASSERTION_PASS( assertion )                 \
   CPPUNIT_ASSERT_NO_THROW( assertion )
 
 
# define CPPUNIT_ASSERT_ASSERTION_PASS_MESSAGE( message, assertion )    \
   CPPUNIT_ASSERT_NO_THROW_MESSAGE( message, assertion )
 
 
 
 
// Backwards compatibility
 
#if CPPUNIT_ENABLE_NAKED_ASSERT
 
#undef assert
#define assert(c)                 CPPUNIT_ASSERT(c)
#define assertEqual(e,a)          CPPUNIT_ASSERT_EQUAL(e,a)
#define assertDoublesEqual(e,a,d) CPPUNIT_ASSERT_DOUBLES_EQUAL(e,a,d)
#define assertLongsEqual(e,a)     CPPUNIT_ASSERT_EQUAL(e,a)
 
#endif
 
 
CPPUNIT_NS_END
 
#endif  // CPPUNIT_TESTASSERT_H