source: git/libpolys/tests/cxxtest/TestSuite.h @ 405407

spielwiese
Last change on this file since 405407 was 1820e7, checked in by Oleksandr Motsak <motsak@…>, 13 years ago
ADD: more unit tests via CxxTest and related changes FIX: NULLp for (void*)NULL + minor changes
  • Property mode set to 100644
File size: 22.6 KB
Line 
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
19namespace 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__
Note: See TracBrowser for help on using the repository browser.