1 #ifndef  __cxxtest__Mock_h__
2 #define  __cxxtest__Mock_h__
3 
4 //
5 // The default namespace is T::
6 //
7 #ifndef CXXTEST_MOCK_NAMESPACE
8 #define CXXTEST_MOCK_NAMESPACE T
9 #endif  // CXXTEST_MOCK_NAMESPACE
10 
11 //
12 // MockTraits: What to return when no mock object has been created
13 //
14 #define  __CXXTEST_MOCK__TRAITS              \
15   namespace CXXTEST_MOCK_NAMESPACE {        \
16     template <class T>                      \
17     class MockTraits {                      \
18       public:                               \
19       static T defaultValue() { return 0; } \
20     };                                      \
21   };
22 
23 //
24 // extern "C" when needed
25 //
26 #ifdef  __cplusplus
27 #define CXXTEST_EXTERN_C extern "C"
28 #else
29 #define CXXTEST_EXTERN_C
30 #endif  //  __cplusplus
31 
32 //
33 // Prototypes: For "normal" headers
34 //
35 #define  __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
36   namespace CXXTEST_MOCK_NAMESPACE {                                    \
37     TYPE NAME ARGS;                                                     \
38   }
39 
40 #define  __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
41    __CXXTEST_MOCK__PROTOTYPE( MOCK, void, NAME, ARGS, REAL, CALL )
42 
43 #define  __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
44   TYPE REAL ARGS;
45 
46 #define  __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
47    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, void, NAME, ARGS, REAL, CALL )
48 
49 //
50 // Class declarations: For test files
51 //
52 #define  __CXXTEST_MOCK_CLASS__DECLARATION(             \
53     MOCK, TYPE, NAME, ARGS, REAL, CALL )               \
54   namespace CXXTEST_MOCK_NAMESPACE {                   \
55     class Base_##MOCK : public CxxTest::Link {         \
56       public:                                          \
57       Base_##MOCK();                                   \
58       ~Base_##MOCK();                                  \
59       bool setUp();                                    \
60       bool tearDown();                                 \
61                                                        \
62       static Base_##MOCK& current();                   \
63                                                        \
64       virtual TYPE NAME ARGS = 0;                      \
65                                                        \
66       private:                                         \
67       static CxxTest::List _list;                      \
68     };                                                 \
69                                                        \
70     class Real_##MOCK : public Base_##MOCK {           \
71       public:                                          \
72       TYPE NAME ARGS;                                  \
73     };                                                 \
74                                                        \
75     class _Unimplemented_##MOCK : public Base_##MOCK { \
76       public:                                          \
77       TYPE NAME ARGS;                                  \
78     };                                                 \
79   }
80 
81 #define  __CXXTEST_MOCK_VOID_CLASS__DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
82    __CXXTEST_MOCK_CLASS__DECLARATION( MOCK, void, NAME, ARGS, REAL, CALL )
83 
84 #define  __CXXTEST_SUPPLY_CLASS__DECLARATION(           \
85     MOCK, TYPE, NAME, ARGS, REAL, CALL )               \
86   namespace CXXTEST_MOCK_NAMESPACE {                   \
87     class Base_##MOCK : public CxxTest::Link {         \
88       public:                                          \
89       Base_##MOCK();                                   \
90       ~Base_##MOCK();                                  \
91       bool setUp();                                    \
92       bool tearDown();                                 \
93                                                        \
94       static Base_##MOCK& current();                   \
95                                                        \
96       virtual TYPE NAME ARGS = 0;                      \
97                                                        \
98       private:                                         \
99       static CxxTest::List _list;                      \
100     };                                                 \
101                                                        \
102     class _Unimplemented_##MOCK : public Base_##MOCK { \
103       public:                                          \
104       TYPE NAME ARGS;                                  \
105     };                                                 \
106   }
107 
108 #define  __CXXTEST_SUPPLY_VOID_CLASS__DECLARATION( \
109     MOCK, NAME, ARGS, REAL, CALL )                \
110    __CXXTEST_SUPPLY_CLASS__DECLARATION( MOCK, void, NAME, ARGS, REAL, CALL )
111 
112 //
113 // Class implementation: For test source files
114 //
115 #define  __CXXTEST_MOCK_COMMON_CLASS__IMPLEMENTATION( MOCK, NAME )      \
116   namespace CXXTEST_MOCK_NAMESPACE {                                   \
117                                                                        \
118     CxxTest::List Base_##MOCK::_list = {0, 0};                         \
119                                                                        \
120     Base_##MOCK::Base_##MOCK() { attach( _list ); }                    \
121     Base_##MOCK::~Base_##MOCK() { detach( _list ); }                   \
122     bool Base_##MOCK::setUp() { return true; }                         \
123     bool Base_##MOCK::tearDown() { return true; }                      \
124                                                                        \
125     Base_##MOCK& Base_##MOCK::current() {                              \
126       if ( _list.empty() ) static _Unimplemented_##MOCK unimplemented; \
127       return *(Base_##MOCK*)_list.tail();                              \
128     }                                                                  \
129   }
130 
131 #define  __CXXTEST_MOCK_CLASS__IMPLEMENTATION(                   \
132     MOCK, TYPE, NAME, ARGS, REAL, CALL )                        \
133    __CXXTEST_MOCK_COMMON_CLASS__IMPLEMENTATION( MOCK, NAME )     \
134   namespace CXXTEST_MOCK_NAMESPACE {                            \
135     TYPE Real_##MOCK::NAME ARGS { return REAL CALL; }           \
136                                                                 \
137     TYPE _Unimplemented_##MOCK::NAME ARGS {                     \
138       while ( false )                                           \
139         return NAME CALL;                                       \
140        __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS );               \
141       return MockTraits<TYPE>::defaultValue();                  \
142     }                                                           \
143                                                                 \
144     TYPE NAME ARGS { return Base_##MOCK::current().NAME CALL; } \
145   }
146 
147 #define  __CXXTEST_MOCK_VOID_CLASS__IMPLEMENTATION(          \
148     MOCK, NAME, ARGS, REAL, CALL )                          \
149    __CXXTEST_MOCK_COMMON_CLASS__IMPLEMENTATION( MOCK, NAME ) \
150   namespace CXXTEST_MOCK_NAMESPACE {                        \
151     void Real_##MOCK::NAME ARGS { REAL CALL; }              \
152                                                             \
153     void _Unimplemented_##MOCK::NAME ARGS {                 \
154       while ( false )                                       \
155         NAME CALL;                                          \
156        __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS );           \
157     }                                                       \
158                                                             \
159     void NAME ARGS { Base_##MOCK::current().NAME CALL; }    \
160   }
161 
162 #define  __CXXTEST_SUPPLY_CLASS__IMPLEMENTATION(                      \
163     MOCK, TYPE, NAME, ARGS, REAL, CALL )                             \
164    __CXXTEST_MOCK_COMMON_CLASS__IMPLEMENTATION( MOCK, NAME )          \
165   namespace CXXTEST_MOCK_NAMESPACE {                                 \
166     TYPE _Unimplemented_##MOCK::NAME ARGS {                          \
167       while ( false )                                                \
168         return NAME CALL;                                            \
169        __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS );                    \
170       return MockTraits<TYPE>::defaultValue();                       \
171     }                                                                \
172   }                                                                  \
173                                                                      \
174   TYPE REAL ARGS {                                                   \
175     return CXXTEST_MOCK_NAMESPACE::Base_##MOCK::current().NAME CALL; \
176   }
177 
178 #define  __CXXTEST_SUPPLY_VOID_CLASS__IMPLEMENTATION(        \
179     MOCK, NAME, ARGS, REAL, CALL )                          \
180    __CXXTEST_MOCK_COMMON_CLASS__IMPLEMENTATION( MOCK, NAME ) \
181   namespace CXXTEST_MOCK_NAMESPACE {                        \
182     void _Unimplemented_##MOCK::NAME ARGS {                 \
183       while ( false )                                       \
184         NAME CALL;                                          \
185        __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS );           \
186     }                                                       \
187   }                                                         \
188                                                             \
189   void REAL ARGS { CXXTEST_MOCK_NAMESPACE::Base_##MOCK::current().NAME CALL; }
190 
191 //
192 // Error for calling mock function w/o object
193 //
194 #define  __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS )                     \
195   TS_FAIL( CXXTEST_MOCK_NAMESPACE_STR #NAME #ARGS                      \
196            " called with no " CXXTEST_MOCK_NAMESPACE_STR "Base_" #NAME \
197            " object" );
198 
199 #define CXXTEST_MOCK_NAMESPACE_STR  __CXXTEST_STR( CXXTEST_MOCK_NAMESPACE ) "::"
200 #define  __CXXTEST_STR( X )  __CXXTEST_XSTR( X )
201 #define  __CXXTEST_XSTR( X ) #X
202 
203 #if defined( CXXTEST_MOCK_TEST_SOURCE_FILE )
204 //
205 // Test source file: Prototypes, class declarations and implementation
206 //
207 #include <cxxtest/TestSuite.h>
208 
209  __CXXTEST_MOCK__TRAITS;
210 
211 #define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL )                \
212    __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL )         \
213    __CXXTEST_MOCK_CLASS__DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
214    __CXXTEST_MOCK_CLASS__IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
215 
216 #define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL )                \
217    __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL )         \
218    __CXXTEST_MOCK_VOID_CLASS__DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
219    __CXXTEST_MOCK_VOID_CLASS__IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL )
220 
221 #define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL )                \
222    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL )         \
223    __CXXTEST_SUPPLY_CLASS__DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
224    __CXXTEST_SUPPLY_CLASS__IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
225 
226 #define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL )                \
227    __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL )         \
228    __CXXTEST_SUPPLY_VOID_CLASS__DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
229    __CXXTEST_SUPPLY_VOID_CLASS__IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL )
230 
231 #elif defined( CXXTEST_FLAGS ) || defined( CXXTEST_RUNNING )
232 //
233 // Test file other than source: Prototypes and class declarations
234 //
235 #include <cxxtest/TestSuite.h>
236 
237  __CXXTEST_MOCK__TRAITS;
238 
239 #define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL )        \
240    __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
241    __CXXTEST_MOCK_CLASS__DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
242 
243 #define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL )        \
244    __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
245    __CXXTEST_MOCK_VOID_CLASS__DECLARATION( MOCK, NAME, ARGS, REAL, CALL )
246 
247 #define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL )        \
248    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
249    __CXXTEST_SUPPLY_CLASS__DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
250 
251 #define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL )        \
252    __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
253    __CXXTEST_SUPPLY_VOID_CLASS__DECLARATION( MOCK, NAME, ARGS, REAL, CALL )
254 
255 #elif defined( CXXTEST_MOCK_REAL_SOURCE_FILE )
256 //
257 // Real source file: "Real" implementations
258 //
259 #define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
260   namespace CXXTEST_MOCK_NAMESPACE {                       \
261     TYPE NAME ARGS { return REAL CALL; }                   \
262   }
263 
264 #define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
265   namespace CXXTEST_MOCK_NAMESPACE {                      \
266     void NAME ARGS { REAL CALL; }                         \
267   }
268 
269 #else
270 //
271 // Ordinary header file: Just prototypes
272 //
273 
274 #define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
275    __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL )
276 
277 #define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
278    __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL )
279 
280 #define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
281    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL )
282 
283 #define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
284    __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL )
285 
286 #endif  // Ordinary header file
287 
288 //
289 // How to supply extern "C" functions
290 //
291 #define CXXTEST_SUPPLY_C( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
292   CXXTEST_EXTERN_C  __CXXTEST_SUPPLY__PROTOTYPE(                \
293       MOCK, TYPE, NAME, ARGS, REAL, CALL )                     \
294       CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL )
295 
296 #define CXXTEST_SUPPLY_VOID_C( MOCK, NAME, ARGS, REAL, CALL ) \
297   CXXTEST_EXTERN_C  __CXXTEST_SUPPLY_VOID__PROTOTYPE(          \
298       MOCK, NAME, ARGS, REAL, CALL )                          \
299       CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL )
300 
301 //
302 // Usually we mean the global namespace
303 //
304 #define CXXTEST_MOCK_GLOBAL( TYPE, NAME, ARGS, CALL ) \
305   CXXTEST_MOCK( NAME, TYPE, NAME, ARGS, ::NAME, CALL )
306 
307 #define CXXTEST_MOCK_VOID_GLOBAL( NAME, ARGS, CALL ) \
308   CXXTEST_MOCK_VOID( NAME, NAME, ARGS, ::NAME, CALL )
309 
310 #define CXXTEST_SUPPLY_GLOBAL( TYPE, NAME, ARGS, CALL ) \
311   CXXTEST_SUPPLY( NAME, TYPE, NAME, ARGS, NAME, CALL )
312 
313 #define CXXTEST_SUPPLY_VOID_GLOBAL( NAME, ARGS, CALL ) \
314   CXXTEST_SUPPLY_VOID( NAME, NAME, ARGS, NAME, CALL )
315 
316 #define CXXTEST_SUPPLY_GLOBAL_C( TYPE, NAME, ARGS, CALL ) \
317   CXXTEST_SUPPLY_C( NAME, TYPE, NAME, ARGS, NAME, CALL )
318 
319 #define CXXTEST_SUPPLY_VOID_GLOBAL_C( NAME, ARGS, CALL ) \
320   CXXTEST_SUPPLY_VOID_C( NAME, NAME, ARGS, NAME, CALL )
321 
322 //
323 // What to return when no mock object has been created.
324 // The default value of 0 usually works, but some cases may need this.
325 //
326 #define CXXTEST_MOCK_DEFAULT_VALUE( TYPE, VALUE )  \
327   namespace CXXTEST_MOCK_NAMESPACE {               \
328     template <>                                    \
329     class MockTraits<TYPE> {                       \
330       public:                                      \
331       static TYPE defaultValue() { return VALUE; } \
332     };                                             \
333   }
334 
335 #endif  //  __cxxtest__Mock_h__
336