cxxtest/cxxtest/TestSuite.h

   1 #ifndef __cxxtest__TestSuite_h__
   2 #define __cxxtest__TestSuite_h__
   3
   4 //
   5 // class TestSuite is the base class for all test suites.
   6 // To define a test suite, derive from this class and add
   7 // member functions called void test*();
   8 //
   9
  10 #include <cxxtest/Flags.h>
  11 #include <cxxtest/TestTracker.h>
  12 #include <cxxtest/Descriptions.h>
  13 #include <cxxtest/ValueTraits.h>
  14
  15 #ifdef _CXXTEST_HAVE_STD
  16 #   include <stdexcept>
  17 #endif // _CXXTEST_HAVE_STD
  18
  19 namespace CxxTest
  20 {
  21     class TestSuite
  22     {
  23     public:
  24         virtual ~TestSuite();
  25         virtual void setUp();
  26         virtual void tearDown();
  27     };
  28
  29     class AbortTest {};
  30     void doAbortTest();
  31 #   define TS_ABORT() CxxTest::doAbortTest()
  32
  33     bool abortTestOnFail();
  34     void setAbortTestOnFail( bool value = CXXTEST_DEFAULT_ABORT );
  35
  36     unsigned maxDumpSize();
  37     void setMaxDumpSize( unsigned value = CXXTEST_MAX_DUMP_SIZE );
  38
  39     void doTrace( const char *file, unsigned line, const char *message );
  40     void doWarn( const char *file, unsigned line, const char *message );
  41     void doFailTest( const char *file, unsigned line, const char *message );
  42     void doFailAssert( const char *file, unsigned line, const char *expression, const char *message );
  43
  44     template<class X, class Y>
  45     bool equals( X x, Y y )
  46     {
  47         return (x == y);
  48     }
  49
  50     template<class X, class Y>
  51     void doAssertEquals( const char *file, unsigned line,
  52                          const char *xExpr, X x,
  53                          const char *yExpr, Y y,
  54                          const char *message )
  55     {
  56         if ( !equals( x, y ) ) {
  57             if ( message )
  58                 tracker().failedTest( file, line, message );
  59             tracker().failedAssertEquals( file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
  60             TS_ABORT();
  61         }
  62     }
  63
  64     void doAssertSameData( const char *file, unsigned line,
  65                            const char *xExpr, const void *x,
  66                            const char *yExpr, const void *y,
  67                            const char *sizeExpr, unsigned size,
  68                            const char *message );
  69
  70     template<class X, class Y>
  71     bool differs( X x, Y y )
  72     {
  73         return !(x == y);
  74     }
  75
  76     template<class X, class Y>
  77     void doAssertDiffers( const char *file, unsigned line,
  78                           const char *xExpr, X x,
  79                           const char *yExpr, Y y,
  80                           const char *message )
  81     {
  82         if ( !differs( x, y ) ) {
  83             if ( message )
  84                 tracker().failedTest( file, line, message );
  85             tracker().failedAssertDiffers( file, line, xExpr, yExpr, TS_AS_STRING(x) );
  86             TS_ABORT();
  87         }
  88     }
  89
  90     template<class X, class Y>
  91     bool lessThan( X x, Y y )
  92     {
  93         return (x < y);
  94     }
  95
  96     template<class X, class Y>
  97     void doAssertLessThan( const char *file, unsigned line,
  98                            const char *xExpr, X x,
  99                            const char *yExpr, Y y,
 100                            const char *message )
 101     {
 102         if ( !lessThan(x, y) ) {
 103             if ( message )
 104                 tracker().failedTest( file, line, message );
 105             tracker().failedAssertLessThan( file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
 106             TS_ABORT();
 107         }
 108     }
 109
 110     template<class X, class Y>
 111     bool lessThanEquals( X x, Y y )
 112     {
 113         return (x <= y);
 114     }
 115
 116     template<class X, class Y>
 117     void doAssertLessThanEquals( const char *file, unsigned line,
 118                                  const char *xExpr, X x,
 119                                  const char *yExpr, Y y,
 120                                  const char *message )
 121     {
 122         if ( !lessThanEquals( x, y ) ) {
 123             if ( message )
 124                 tracker().failedTest( file, line, message );
 125             tracker().failedAssertLessThanEquals( file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
 126             TS_ABORT();
 127         }
 128     }
 129
 130     template<class X, class P>
 131     void doAssertPredicate( const char *file, unsigned line,
 132                             const char *pExpr, const P &p,
 133                             const char *xExpr, X x,
 134                             const char *message )
 135     {
 136         if ( !p( x ) ) {
 137             if ( message )
 138                 tracker().failedTest( file, line, message );
 139             tracker().failedAssertPredicate( file, line, pExpr, xExpr, TS_AS_STRING(x) );
 140             TS_ABORT();
 141         }
 142     }
 143
 144     template<class X, class Y, class R>
 145     void doAssertRelation( const char *file, unsigned line,
 146                            const char *rExpr, const R &r,
 147                            const char *xExpr, X x,
 148                            const char *yExpr, Y y,
 149                            const char *message )
 150     {
 151         if ( !r( x, y ) ) {
 152             if ( message )
 153                 tracker().failedTest( file, line, message );
 154             tracker().failedAssertRelation( file, line, rExpr, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
 155             TS_ABORT();
 156         }
 157     }
 158
 159     template<class X, class Y, class D>
 160     bool delta( X x, Y y, D d )
 161     {
 162         return ((y >= x - d) && (y <= x + d));
 163     }
 164
 165     template<class X, class Y, class D>
 166     void doAssertDelta( const char *file, unsigned line,
 167                         const char *xExpr, X x,
 168                         const char *yExpr, Y y,
 169                         const char *dExpr, D d,
 170                         const char *message )
 171     {
 172         if ( !delta( x, y, d ) ) {
 173             if ( message )
 174                 tracker().failedTest( file, line, message );
 175
 176             tracker().failedAssertDelta( file, line, xExpr, yExpr, dExpr,
 177                                          TS_AS_STRING(x), TS_AS_STRING(y), TS_AS_STRING(d) );
 178             TS_ABORT();
 179         }
 180     }
 181
 182     void doFailAssertThrows( const char *file, unsigned line,
 183                              const char *expr, const char *type,
 184                              bool otherThrown,
 185                              const char *message );
 186
 187     void doFailAssertThrowsNot( const char *file, unsigned line,
 188                                 const char *expression, const char *message );
 189
 190 #   ifdef _CXXTEST_HAVE_EH
 191 #       define _TS_TRY try
 192 #       define _TS_CATCH_TYPE(t, b) catch t b
 193 #       define _TS_CATCH_ABORT(b) _TS_CATCH_TYPE( (const CxxTest::AbortTest &), b )
 194 #       define _TS_LAST_CATCH(b) _TS_CATCH_TYPE( (...), b )
 195 #       define _TSM_LAST_CATCH(f,l,m) _TS_LAST_CATCH( { (CxxTest::tracker()).failedTest(f,l,m); } )
 196 #       ifdef _CXXTEST_HAVE_STD
 197 #           define ___TSM_CATCH(f,l,m) \
 198                     catch(const std::exception &e) { (CxxTest::tracker()).failedTest(f,l,e.what()); } \
 199                     _TSM_LAST_CATCH(f,l,m)
 200 #       else // !_CXXTEST_HAVE_STD
 201 #           define ___TSM_CATCH(f,l,m) _TSM_LAST_CATCH(f,l,m)
 202 #       endif // _CXXTEST_HAVE_STD
 203 #       define __TSM_CATCH(f,l,m) \
 204                 _TS_CATCH_ABORT( { throw; } ) \
 205                 ___TSM_CATCH(f,l,m)
 206 #       define __TS_CATCH(f,l) __TSM_CATCH(f,l,"Unhandled exception")
 207 #       define _TS_CATCH __TS_CATCH(__FILE__,__LINE__)
 208 #   else // !_CXXTEST_HAVE_EH
 209 #       define _TS_TRY
 210 #       define ___TSM_CATCH(f,l,m)
 211 #       define __TSM_CATCH(f,l,m)
 212 #       define __TS_CATCH(f,l)
 213 #       define _TS_CATCH
 214 #       define _TS_CATCH_TYPE(t, b)
 215 #       define _TS_LAST_CATCH(b)
 216 #       define _TS_CATCH_ABORT(b)
 217 #   endif // _CXXTEST_HAVE_EH
 218
 219     // TS_TRACE
 220 #   define _TS_TRACE(f,l,e) CxxTest::doTrace( (f), (l), TS_AS_STRING(e) )
 221 #   define TS_TRACE(e) _TS_TRACE( __FILE__, __LINE__, e )
 222
 223     // TS_WARN
 224 #   define _TS_WARN(f,l,e) CxxTest::doWarn( (f), (l), TS_AS_STRING(e) )
 225 #   define TS_WARN(e) _TS_WARN( __FILE__, __LINE__, e )
 226
 227     // TS_FAIL
 228 #   define _TS_FAIL(f,l,e) CxxTest::doFailTest( (f), (l), TS_AS_STRING(e) )
 229 #   define TS_FAIL(e) _TS_FAIL( __FILE__, __LINE__, e )
 230
 231     // TS_ASSERT
 232 #   define ___ETS_ASSERT(f,l,e,m) { if ( !(e) ) CxxTest::doFailAssert( (f), (l), #e, (m) ); }
 233 #   define ___TS_ASSERT(f,l,e,m) { _TS_TRY { ___ETS_ASSERT(f,l,e,m); } __TS_CATCH(f,l) }
 234
 235 #   define _ETS_ASSERT(f,l,e) ___ETS_ASSERT(f,l,e,0)
 236 #   define _TS_ASSERT(f,l,e) ___TS_ASSERT(f,l,e,0)
 237
 238 #   define ETS_ASSERT(e) _ETS_ASSERT(__FILE__,__LINE__,e)
 239 #   define TS_ASSERT(e) _TS_ASSERT(__FILE__,__LINE__,e)
 240
 241 #   define _ETSM_ASSERT(f,l,m,e) ___ETS_ASSERT(f,l,e,TS_AS_STRING(m) )
 242 #   define _TSM_ASSERT(f,l,m,e) ___TS_ASSERT(f,l,e,TS_AS_STRING(m) )
 243
 244 #   define ETSM_ASSERT(m,e) _ETSM_ASSERT(__FILE__,__LINE__,m,e)
 245 #   define TSM_ASSERT(m,e) _TSM_ASSERT(__FILE__,__LINE__,m,e)
 246
 247     // TS_ASSERT_EQUALS
 248 #   define ___ETS_ASSERT_EQUALS(f,l,x,y,m) CxxTest::doAssertEquals( (f), (l), #x, (x), #y, (y), (m) )
 249 #   define ___TS_ASSERT_EQUALS(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_EQUALS(f,l,x,y,m); } __TS_CATCH(f,l) }
 250
 251 #   define _ETS_ASSERT_EQUALS(f,l,x,y) ___ETS_ASSERT_EQUALS(f,l,x,y,0)
 252 #   define _TS_ASSERT_EQUALS(f,l,x,y) ___TS_ASSERT_EQUALS(f,l,x,y,0)
 253
 254 #   define ETS_ASSERT_EQUALS(x,y) _ETS_ASSERT_EQUALS(__FILE__,__LINE__,x,y)
 255 #   define TS_ASSERT_EQUALS(x,y) _TS_ASSERT_EQUALS(__FILE__,__LINE__,x,y)
 256
 257 #   define _ETSM_ASSERT_EQUALS(f,l,m,x,y) ___ETS_ASSERT_EQUALS(f,l,x,y,TS_AS_STRING(m))
 258 #   define _TSM_ASSERT_EQUALS(f,l,m,x,y) ___TS_ASSERT_EQUALS(f,l,x,y,TS_AS_STRING(m))
 259
 260 #   define ETSM_ASSERT_EQUALS(m,x,y) _ETSM_ASSERT_EQUALS(__FILE__,__LINE__,m,x,y)
 261 #   define TSM_ASSERT_EQUALS(m,x,y) _TSM_ASSERT_EQUALS(__FILE__,__LINE__,m,x,y)
 262
 263     // TS_ASSERT_SAME_DATA
 264 #   define ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,m) CxxTest::doAssertSameData( (f), (l), #x, (x), #y, (y), #s, (s), (m) )
 265 #   define ___TS_ASSERT_SAME_DATA(f,l,x,y,s,m) { _TS_TRY { ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,m); } __TS_CATCH(f,l) }
 266
 267 #   define _ETS_ASSERT_SAME_DATA(f,l,x,y,s) ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,0)
 268 #   define _TS_ASSERT_SAME_DATA(f,l,x,y,s) ___TS_ASSERT_SAME_DATA(f,l,x,y,s,0)
 269
 270 #   define ETS_ASSERT_SAME_DATA(x,y,s) _ETS_ASSERT_SAME_DATA(__FILE__,__LINE__,x,y,s)
 271 #   define TS_ASSERT_SAME_DATA(x,y,s) _TS_ASSERT_SAME_DATA(__FILE__,__LINE__,x,y,s)
 272
 273 #   define _ETSM_ASSERT_SAME_DATA(f,l,m,x,y,s) ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,TS_AS_STRING(m))
 274 #   define _TSM_ASSERT_SAME_DATA(f,l,m,x,y,s) ___TS_ASSERT_SAME_DATA(f,l,x,y,s,TS_AS_STRING(m))
 275
 276 #   define ETSM_ASSERT_SAME_DATA(m,x,y,s) _ETSM_ASSERT_SAME_DATA(__FILE__,__LINE__,m,x,y,s)
 277 #   define TSM_ASSERT_SAME_DATA(m,x,y,s) _TSM_ASSERT_SAME_DATA(__FILE__,__LINE__,m,x,y,s)
 278
 279     // TS_ASSERT_DIFFERS
 280 #   define ___ETS_ASSERT_DIFFERS(f,l,x,y,m) CxxTest::doAssertDiffers( (f), (l), #x, (x), #y, (y), (m) )
 281 #   define ___TS_ASSERT_DIFFERS(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_DIFFERS(f,l,x,y,m); } __TS_CATCH(f,l) }
 282
 283 #   define _ETS_ASSERT_DIFFERS(f,l,x,y) ___ETS_ASSERT_DIFFERS(f,l,x,y,0)
 284 #   define _TS_ASSERT_DIFFERS(f,l,x,y) ___TS_ASSERT_DIFFERS(f,l,x,y,0)
 285
 286 #   define ETS_ASSERT_DIFFERS(x,y) _ETS_ASSERT_DIFFERS(__FILE__,__LINE__,x,y)
 287 #   define TS_ASSERT_DIFFERS(x,y) _TS_ASSERT_DIFFERS(__FILE__,__LINE__,x,y)
 288
 289 #   define _ETSM_ASSERT_DIFFERS(f,l,m,x,y) ___ETS_ASSERT_DIFFERS(f,l,x,y,TS_AS_STRING(m))
 290 #   define _TSM_ASSERT_DIFFERS(f,l,m,x,y) ___TS_ASSERT_DIFFERS(f,l,x,y,TS_AS_STRING(m))
 291
 292 #   define ETSM_ASSERT_DIFFERS(m,x,y) _ETSM_ASSERT_DIFFERS(__FILE__,__LINE__,m,x,y)
 293 #   define TSM_ASSERT_DIFFERS(m,x,y) _TSM_ASSERT_DIFFERS(__FILE__,__LINE__,m,x,y)
 294
 295     // TS_ASSERT_LESS_THAN
 296 #   define ___ETS_ASSERT_LESS_THAN(f,l,x,y,m) CxxTest::doAssertLessThan( (f), (l), #x, (x), #y, (y), (m) )
 297 #   define ___TS_ASSERT_LESS_THAN(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_LESS_THAN(f,l,x,y,m); } __TS_CATCH(f,l) }
 298
 299 #   define _ETS_ASSERT_LESS_THAN(f,l,x,y) ___ETS_ASSERT_LESS_THAN(f,l,x,y,0)
 300 #   define _TS_ASSERT_LESS_THAN(f,l,x,y) ___TS_ASSERT_LESS_THAN(f,l,x,y,0)
 301
 302 #   define ETS_ASSERT_LESS_THAN(x,y) _ETS_ASSERT_LESS_THAN(__FILE__,__LINE__,x,y)
 303 #   define TS_ASSERT_LESS_THAN(x,y) _TS_ASSERT_LESS_THAN(__FILE__,__LINE__,x,y)
 304
 305 #   define _ETSM_ASSERT_LESS_THAN(f,l,m,x,y) ___ETS_ASSERT_LESS_THAN(f,l,x,y,TS_AS_STRING(m))
 306 #   define _TSM_ASSERT_LESS_THAN(f,l,m,x,y) ___TS_ASSERT_LESS_THAN(f,l,x,y,TS_AS_STRING(m))
 307
 308 #   define ETSM_ASSERT_LESS_THAN(m,x,y) _ETSM_ASSERT_LESS_THAN(__FILE__,__LINE__,m,x,y)
 309 #   define TSM_ASSERT_LESS_THAN(m,x,y) _TSM_ASSERT_LESS_THAN(__FILE__,__LINE__,m,x,y)
 310
 311     // TS_ASSERT_LESS_THAN_EQUALS
 312 #   define ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m) \
 313         CxxTest::doAssertLessThanEquals( (f), (l), #x, (x), #y, (y), (m) )
 314 #   define ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m) \
 315         { _TS_TRY { ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m); } __TS_CATCH(f,l) }
 316
 317 #   define _ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y) ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,0)
 318 #   define _TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y) ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,0)
 319
 320 #   define ETS_ASSERT_LESS_THAN_EQUALS(x,y) _ETS_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,x,y)
 321 #   define TS_ASSERT_LESS_THAN_EQUALS(x,y) _TS_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,x,y)
 322
 323 #   define _ETSM_ASSERT_LESS_THAN_EQUALS(f,l,m,x,y) ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,TS_AS_STRING(m))
 324 #   define _TSM_ASSERT_LESS_THAN_EQUALS(f,l,m,x,y) ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,TS_AS_STRING(m))
 325
 326 #   define ETSM_ASSERT_LESS_THAN_EQUALS(m,x,y) _ETSM_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,m,x,y)
 327 #   define TSM_ASSERT_LESS_THAN_EQUALS(m,x,y) _TSM_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,m,x,y)
 328
 329     // TS_ASSERT_PREDICATE
 330 #   define ___ETS_ASSERT_PREDICATE(f,l,p,x,m) \
 331         CxxTest::doAssertPredicate( (f), (l), #p, p(), #x, (x), (m) )
 332 #   define ___TS_ASSERT_PREDICATE(f,l,p,x,m) \
 333         { _TS_TRY { ___ETS_ASSERT_PREDICATE(f,l,p,x,m); } __TS_CATCH(f,l) }
 334
 335 #   define _ETS_ASSERT_PREDICATE(f,l,p,x) ___ETS_ASSERT_PREDICATE(f,l,p,x,0)
 336 #   define _TS_ASSERT_PREDICATE(f,l,p,x) ___TS_ASSERT_PREDICATE(f,l,p,x,0)
 337
 338 #   define ETS_ASSERT_PREDICATE(p,x) _ETS_ASSERT_PREDICATE(__FILE__,__LINE__,p,x)
 339 #   define TS_ASSERT_PREDICATE(p,x) _TS_ASSERT_PREDICATE(__FILE__,__LINE__,p,x)
 340
 341 #   define _ETSM_ASSERT_PREDICATE(f,l,m,p,x) ___ETS_ASSERT_PREDICATE(f,l,p,x,TS_AS_STRING(m))
 342 #   define _TSM_ASSERT_PREDICATE(f,l,m,p,x) ___TS_ASSERT_PREDICATE(f,l,p,x,TS_AS_STRING(m))
 343
 344 #   define ETSM_ASSERT_PREDICATE(m,p,x) _ETSM_ASSERT_PREDICATE(__FILE__,__LINE__,m,p,x)
 345 #   define TSM_ASSERT_PREDICATE(m,p,x) _TSM_ASSERT_PREDICATE(__FILE__,__LINE__,m,p,x)
 346
 347     // TS_ASSERT_RELATION
 348 #   define ___ETS_ASSERT_RELATION(f,l,r,x,y,m) \
 349         CxxTest::doAssertRelation( (f), (l), #r, r(), #x, (x), #y, (y), (m) )
 350 #   define ___TS_ASSERT_RELATION(f,l,r,x,y,m) \
 351         { _TS_TRY { ___ETS_ASSERT_RELATION(f,l,r,x,y,m); } __TS_CATCH(f,l) }
 352
 353 #   define _ETS_ASSERT_RELATION(f,l,r,x,y) ___ETS_ASSERT_RELATION(f,l,r,x,y,0)
 354 #   define _TS_ASSERT_RELATION(f,l,r,x,y) ___TS_ASSERT_RELATION(f,l,r,x,y,0)
 355
 356 #   define ETS_ASSERT_RELATION(r,x,y) _ETS_ASSERT_RELATION(__FILE__,__LINE__,r,x,y)
 357 #   define TS_ASSERT_RELATION(r,x,y) _TS_ASSERT_RELATION(__FILE__,__LINE__,r,x,y)
 358
 359 #   define _ETSM_ASSERT_RELATION(f,l,m,r,x,y) ___ETS_ASSERT_RELATION(f,l,r,x,y,TS_AS_STRING(m))
 360 #   define _TSM_ASSERT_RELATION(f,l,m,r,x,y) ___TS_ASSERT_RELATION(f,l,r,x,y,TS_AS_STRING(m))
 361
 362 #   define ETSM_ASSERT_RELATION(m,r,x,y) _ETSM_ASSERT_RELATION(__FILE__,__LINE__,m,r,x,y)
 363 #   define TSM_ASSERT_RELATION(m,r,x,y) _TSM_ASSERT_RELATION(__FILE__,__LINE__,m,r,x,y)
 364
 365     // TS_ASSERT_DELTA
 366 #   define ___ETS_ASSERT_DELTA(f,l,x,y,d,m) CxxTest::doAssertDelta( (f), (l), #x, (x), #y, (y), #d, (d), (m) )
 367 #   define ___TS_ASSERT_DELTA(f,l,x,y,d,m) { _TS_TRY { ___ETS_ASSERT_DELTA(f,l,x,y,d,m); } __TS_CATCH(f,l) }
 368
 369 #   define _ETS_ASSERT_DELTA(f,l,x,y,d) ___ETS_ASSERT_DELTA(f,l,x,y,d,0)
 370 #   define _TS_ASSERT_DELTA(f,l,x,y,d) ___TS_ASSERT_DELTA(f,l,x,y,d,0)
 371
 372 #   define ETS_ASSERT_DELTA(x,y,d) _ETS_ASSERT_DELTA(__FILE__,__LINE__,x,y,d)
 373 #   define TS_ASSERT_DELTA(x,y,d) _TS_ASSERT_DELTA(__FILE__,__LINE__,x,y,d)
 374
 375 #   define _ETSM_ASSERT_DELTA(f,l,m,x,y,d) ___ETS_ASSERT_DELTA(f,l,x,y,d,TS_AS_STRING(m))
 376 #   define _TSM_ASSERT_DELTA(f,l,m,x,y,d) ___TS_ASSERT_DELTA(f,l,x,y,d,TS_AS_STRING(m))
 377
 378 #   define ETSM_ASSERT_DELTA(m,x,y,d) _ETSM_ASSERT_DELTA(__FILE__,__LINE__,m,x,y,d)
 379 #   define TSM_ASSERT_DELTA(m,x,y,d) _TSM_ASSERT_DELTA(__FILE__,__LINE__,m,x,y,d)
 380
 381     // TS_ASSERT_THROWS
 382 #   define ___TS_ASSERT_THROWS(f,l,e,t,m) { \
 383             bool _ts_threw_expected = false, _ts_threw_else = false; \
 384             _TS_TRY { e; } \
 385             _TS_CATCH_TYPE( (t), { _ts_threw_expected = true; } ) \
 386             _TS_CATCH_ABORT( { throw; } ) \
 387             _TS_LAST_CATCH( { _ts_threw_else = true; } ) \
 388             if ( !_ts_threw_expected ) { CxxTest::doFailAssertThrows( (f), (l), #e, #t, _ts_threw_else, (m) ); } }
 389
 390 #   define _TS_ASSERT_THROWS(f,l,e,t) ___TS_ASSERT_THROWS(f,l,e,t,0)
 391 #   define TS_ASSERT_THROWS(e,t) _TS_ASSERT_THROWS(__FILE__,__LINE__,e,t)
 392
 393 #   define _TSM_ASSERT_THROWS(f,l,m,e,t) ___TS_ASSERT_THROWS(f,l,e,t,TS_AS_STRING(m))
 394 #   define TSM_ASSERT_THROWS(m,e,t) _TSM_ASSERT_THROWS(__FILE__,__LINE__,m,e,t)
 395
 396     // TS_ASSERT_THROWS_ASSERT
 397 #   define ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,m) { \
 398             bool _ts_threw_expected = false, _ts_threw_else = false; \
 399             _TS_TRY { e; } \
 400             _TS_CATCH_TYPE( (t), { a; _ts_threw_expected = true; } ) \
 401             _TS_CATCH_ABORT( { throw; } ) \
 402             _TS_LAST_CATCH( { _ts_threw_else = true; } ) \
 403             if ( !_ts_threw_expected ) { CxxTest::doFailAssertThrows( (f), (l), #e, #t, _ts_threw_else, (m) ); } }
 404
 405 #   define _TS_ASSERT_THROWS_ASSERT(f,l,e,t,a) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,0)
 406 #   define TS_ASSERT_THROWS_ASSERT(e,t,a) _TS_ASSERT_THROWS_ASSERT(__FILE__,__LINE__,e,t,a)
 407
 408 #   define _TSM_ASSERT_THROWS_ASSERT(f,l,m,e,t,a) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,TS_AS_STRING(m))
 409 #   define TSM_ASSERT_THROWS_ASSERT(m,e,t,a) _TSM_ASSERT_THROWS_ASSERT(__FILE__,__LINE__,m,e,t,a)
 410
 411     // TS_ASSERT_THROWS_EQUALS
 412 #   define TS_ASSERT_THROWS_EQUALS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_EQUALS(x,y))
 413 #   define TSM_ASSERT_THROWS_EQUALS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_EQUALS(m,x,y))
 414
 415     // TS_ASSERT_THROWS_DIFFERS
 416 #   define TS_ASSERT_THROWS_DIFFERS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_DIFFERS(x,y))
 417 #   define TSM_ASSERT_THROWS_DIFFERS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_DIFFERS(m,x,y))
 418
 419     // TS_ASSERT_THROWS_DELTA
 420 #   define TS_ASSERT_THROWS_DELTA(e,t,x,y,d) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_DELTA(x,y,d))
 421 #   define TSM_ASSERT_THROWS_DELTA(m,e,t,x,y,d) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_DELTA(m,x,y,d))
 422
 423     // TS_ASSERT_THROWS_SAME_DATA
 424 #   define TS_ASSERT_THROWS_SAME_DATA(e,t,x,y,s) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_SAME_DATA(x,y,s))
 425 #   define TSM_ASSERT_THROWS_SAME_DATA(m,e,t,x,y,s) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_SAME_DATA(m,x,y,s))
 426
 427     // TS_ASSERT_THROWS_LESS_THAN
 428 #   define TS_ASSERT_THROWS_LESS_THAN(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_LESS_THAN(x,y))
 429 #   define TSM_ASSERT_THROWS_LESS_THAN(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_LESS_THAN(m,x,y))
 430
 431     // TS_ASSERT_THROWS_LESS_THAN_EQUALS
 432 #   define TS_ASSERT_THROWS_LESS_THAN_EQUALS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_LESS_THAN_EQUALS(x,y))
 433 #   define TSM_ASSERT_THROWS_LESS_THAN_EQUALS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_LESS_THAN_EQUALS(m,x,y))
 434
 435     // TS_ASSERT_THROWS_PREDICATE
 436 #   define TS_ASSERT_THROWS_PREDICATE(e,t,p,v) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_PREDICATE(p,v))
 437 #   define TSM_ASSERT_THROWS_PREDICATE(m,e,t,p,v) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_PREDICATE(m,p,v))
 438
 439     // TS_ASSERT_THROWS_RELATION
 440 #   define TS_ASSERT_THROWS_RELATION(e,t,r,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_RELATION(r,x,y))
 441 #   define TSM_ASSERT_THROWS_RELATION(m,e,t,r,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_RELATION(m,r,x,y))
 442
 443     // TS_ASSERT_THROWS_ANYTHING
 444 #   define ___TS_ASSERT_THROWS_ANYTHING(f,l,e,m) { \
 445             bool _ts_threw = false; \
 446             _TS_TRY { e; } \
 447             _TS_LAST_CATCH( { _ts_threw = true; } ) \
 448             if ( !_ts_threw ) { CxxTest::doFailAssertThrows( (f), (l), #e, "...", false, (m) ); } }
 449
 450 #   define _TS_ASSERT_THROWS_ANYTHING(f,l,e) ___TS_ASSERT_THROWS_ANYTHING(f,l,e,0)
 451 #   define TS_ASSERT_THROWS_ANYTHING(e) _TS_ASSERT_THROWS_ANYTHING(__FILE__, __LINE__, e)
 452
 453 #   define _TSM_ASSERT_THROWS_ANYTHING(f,l,m,e) ___TS_ASSERT_THROWS_ANYTHING(f,l,e,TS_AS_STRING(m))
 454 #   define TSM_ASSERT_THROWS_ANYTHING(m,e) _TSM_ASSERT_THROWS_ANYTHING(__FILE__,__LINE__,m,e)
 455
 456     // TS_ASSERT_THROWS_NOTHING
 457 #   define ___TS_ASSERT_THROWS_NOTHING(f,l,e,m) { \
 458             _TS_TRY { e; } \
 459             _TS_CATCH_ABORT( { throw; } ) \
 460             _TS_LAST_CATCH( { CxxTest::doFailAssertThrowsNot( (f), (l), #e, (m) ); } ) }
 461
 462 #   define _TS_ASSERT_THROWS_NOTHING(f,l,e) ___TS_ASSERT_THROWS_NOTHING(f,l,e,0)
 463 #   define TS_ASSERT_THROWS_NOTHING(e) _TS_ASSERT_THROWS_NOTHING(__FILE__,__LINE__,e)
 464
 465 #   define _TSM_ASSERT_THROWS_NOTHING(f,l,m,e) ___TS_ASSERT_THROWS_NOTHING(f,l,e,TS_AS_STRING(m))
 466 #   define TSM_ASSERT_THROWS_NOTHING(m,e) _TSM_ASSERT_THROWS_NOTHING(__FILE__,__LINE__,m,e)
 467
 468
 469     //
 470     // This takes care of "signed <-> unsigned" warnings
 471     //
 472 #   define CXXTEST_COMPARISONS(CXXTEST_X, CXXTEST_Y, CXXTEST_T) \
 473     inline bool equals( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) == ((CXXTEST_T)y)); } \
 474     inline bool equals( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) == ((CXXTEST_T)x)); } \
 475     inline bool differs( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) != ((CXXTEST_T)y)); } \
 476     inline bool differs( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) != ((CXXTEST_T)x)); } \
 477     inline bool lessThan( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) < ((CXXTEST_T)y)); } \
 478     inline bool lessThan( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) < ((CXXTEST_T)x)); } \
 479     inline bool lessThanEquals( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) <= ((CXXTEST_T)y)); } \
 480     inline bool lessThanEquals( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) <= ((CXXTEST_T)x)); }
 481
 482 #   define CXXTEST_INTEGRAL(CXXTEST_T) \
 483     CXXTEST_COMPARISONS( signed CXXTEST_T, unsigned CXXTEST_T, unsigned CXXTEST_T )
 484
 485     CXXTEST_INTEGRAL( char )
 486     CXXTEST_INTEGRAL( short )
 487     CXXTEST_INTEGRAL( int )
 488     CXXTEST_INTEGRAL( long )
 489 #   ifdef _CXXTEST_LONGLONG
 490     CXXTEST_INTEGRAL( _CXXTEST_LONGLONG )
 491 #   endif // _CXXTEST_LONGLONG
 492
 493 #   define CXXTEST_SMALL_BIG(CXXTEST_SMALL, CXXTEST_BIG) \
 494     CXXTEST_COMPARISONS( signed CXXTEST_SMALL, unsigned CXXTEST_BIG, unsigned CXXTEST_BIG ) \
 495     CXXTEST_COMPARISONS( signed CXXTEST_BIG, unsigned CXXTEST_SMALL, unsigned CXXTEST_BIG )
 496
 497     CXXTEST_SMALL_BIG( char, short )
 498     CXXTEST_SMALL_BIG( char, int )
 499     CXXTEST_SMALL_BIG( short, int )
 500     CXXTEST_SMALL_BIG( char, long )
 501     CXXTEST_SMALL_BIG( short, long )
 502     CXXTEST_SMALL_BIG( int, long )
 503
 504 #   ifdef _CXXTEST_LONGLONG
 505     CXXTEST_SMALL_BIG( char, _CXXTEST_LONGLONG )
 506     CXXTEST_SMALL_BIG( short, _CXXTEST_LONGLONG )
 507     CXXTEST_SMALL_BIG( int, _CXXTEST_LONGLONG )
 508     CXXTEST_SMALL_BIG( long, _CXXTEST_LONGLONG )
 509 #   endif // _CXXTEST_LONGLONG
 510 }
 511
 512 #endif // __cxxtest__TestSuite_h__