← Back to branch summary

~valavanisalex/ubuntu/precise/inkscape/fix-943984

« back to all changes in this revision

Viewing changes to inkscape-0.47pre1/cxxtest/cxxtest/TestSuite.h

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2009-07-02 17:09:45 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20090702170945-nn6d6zswovbwju1t
Tags: 0.47~pre1-0ubuntu1
https://launchpad.net/bugs/348842
https://launchpad.net/bugs/391149
* New upstream release.
  - Don't constrain maximization on small resolution devices (pre0)
    (LP: #348842)
  - Fixes segfault on startup (pre0)
    (LP: #391149)

Show diffs side-by-side

added added

removed removed

Lines of Context:
inkscape-0.47pre1/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__