1 #include <cppunit/TestAssert.h>
2 #include <cppunit/TestFailure.h>
3 #include "MockTestListener.h"
4 
5 
MockTestListener(std::string name)6 MockTestListener::MockTestListener( std::string name )
7     : m_name( name )
8     , m_hasExpectationForStartTest( false )
9     , m_hasParametersExpectationForStartTest( false )
10     , m_expectedStartTestCallCount( 0 )
11     , m_startTestCall( 0 )
12     , m_hasExpectationForEndTest( false )
13     , m_hasParametersExpectationForEndTest( false )
14     , m_expectedEndTestCallCount( 0 )
15     , m_endTestCall( 0 )
16     , m_hasExpectationForStartSuite( false )
17     , m_hasParametersExpectationForStartSuite( false )
18     , m_expectedStartSuiteCallCount( 0 )
19     , m_startSuiteCall( 0 )
20     , m_hasExpectationForEndSuite( false )
21     , m_hasParametersExpectationForEndSuite( false )
22     , m_expectedEndSuiteCallCount( 0 )
23     , m_endSuiteCall( 0 )
24     , m_hasExpectationForStartTestRun( false )
25     , m_hasParametersExpectationForStartTestRun( false )
26     , m_expectedStartTestRunCallCount( 0 )
27     , m_startTestRunCall( 0 )
28     , m_hasExpectationForEndTestRun( false )
29     , m_hasParametersExpectationForEndTestRun( false )
30     , m_expectedEndTestRunCallCount( 0 )
31     , m_endTestRunCall( 0 )
32     , m_hasExpectationForAddFailure( false )
33     , m_hasExpectationForSomeFailure( false )
34     , m_hasParametersExpectationForAddFailure( false )
35     , m_expectedAddFailureCallCount( 0 )
36     , m_addFailureCall( 0 )
37     , m_expectedFailedTest( NULL )
38     , m_expectedException( NULL )
39     , m_expectedIsError( false )
40 {
41 }
42 
43 
44 void
setExpectFailure(CPPUNIT_NS::Test * failedTest,CPPUNIT_NS::Exception * thrownException,bool isError)45 MockTestListener::setExpectFailure( CPPUNIT_NS::Test *failedTest,
46                                     CPPUNIT_NS::Exception *thrownException,
47                                     bool isError )
48 {
49   m_hasExpectationForAddFailure = true;
50   m_hasParametersExpectationForAddFailure = true;
51   m_expectedAddFailureCallCount = 1;
52   m_expectedFailedTest = failedTest;
53   m_expectedException = thrownException;
54   m_expectedIsError = isError;
55 }
56 
57 
58 void
setExpectNoFailure()59 MockTestListener::setExpectNoFailure()
60 {
61   m_hasExpectationForAddFailure = true;
62   m_expectedAddFailureCallCount = 0;
63 }
64 
65 
66 void
setExpectFailure()67 MockTestListener::setExpectFailure()
68 {
69   m_hasExpectationForSomeFailure = true;
70 }
71 
72 
73 void
setExpectedAddFailureCall(int callCount)74 MockTestListener::setExpectedAddFailureCall( int callCount )
75 {
76   m_hasExpectationForAddFailure = true;
77   m_expectedAddFailureCallCount = callCount;
78 }
79 
80 
81 void
setExpectStartTest(CPPUNIT_NS::Test * test)82 MockTestListener::setExpectStartTest( CPPUNIT_NS::Test *test )
83 {
84   m_hasExpectationForStartTest = true;
85   m_hasParametersExpectationForStartTest = true;
86   m_expectedStartTestCallCount = 1;
87   m_expectedStartTest = test;
88 }
89 
90 
91 void
setExpectedStartTestCall(int callCount)92 MockTestListener::setExpectedStartTestCall( int callCount )
93 {
94   m_hasExpectationForStartTest = true;
95   m_expectedStartTestCallCount = callCount;
96 }
97 
98 
99 void
setExpectEndTest(CPPUNIT_NS::Test * test)100 MockTestListener::setExpectEndTest( CPPUNIT_NS::Test *test )
101 {
102   m_hasExpectationForEndTest = true;
103   m_hasParametersExpectationForEndTest = true;
104   m_expectedEndTestCallCount = 1;
105   m_expectedEndTest = test;
106 }
107 
108 
109 void
setExpectedEndTestCall(int callCount)110 MockTestListener::setExpectedEndTestCall( int callCount )
111 {
112   m_hasExpectationForEndTest = true;
113   m_expectedEndTestCallCount = callCount;
114 }
115 
116 
117 void
setExpectStartSuite(CPPUNIT_NS::Test * test)118 MockTestListener::setExpectStartSuite( CPPUNIT_NS::Test *test )
119 {
120   m_hasExpectationForStartSuite = true;
121   m_hasParametersExpectationForStartSuite = true;
122   m_expectedStartSuiteCallCount = 1;
123   m_expectedStartSuite = test;
124 }
125 
126 
127 void
setExpectedStartSuiteCall(int callCount)128 MockTestListener::setExpectedStartSuiteCall( int callCount )
129 {
130   m_hasExpectationForStartSuite = true;
131   m_expectedStartSuiteCallCount = callCount;
132 }
133 
134 
135 void
setExpectEndSuite(CPPUNIT_NS::Test * test)136 MockTestListener::setExpectEndSuite( CPPUNIT_NS::Test *test )
137 {
138   m_hasExpectationForEndSuite = true;
139   m_hasParametersExpectationForEndSuite = true;
140   m_expectedEndSuiteCallCount = 1;
141   m_expectedEndSuite = test;
142 }
143 
144 
145 void
setExpectedEndSuiteCall(int callCount)146 MockTestListener::setExpectedEndSuiteCall( int callCount )
147 {
148   m_hasExpectationForEndSuite = true;
149   m_expectedEndSuiteCallCount = callCount;
150 }
151 
152 
153 void
setExpectStartTestRun(CPPUNIT_NS::Test * test,CPPUNIT_NS::TestResult * eventManager)154 MockTestListener::setExpectStartTestRun( CPPUNIT_NS::Test *test,
155                                          CPPUNIT_NS::TestResult *eventManager )
156 {
157   m_hasExpectationForStartTestRun = true;
158   m_hasParametersExpectationForStartTestRun = true;
159   m_expectedStartTestRunCallCount = 1;
160   m_expectedStartTestRun = test;
161   m_expectedStartTestRun2 = eventManager;
162 }
163 
164 
165 void
setExpectedStartTestRunCall(int callCount)166 MockTestListener::setExpectedStartTestRunCall( int callCount )
167 {
168   m_hasExpectationForStartTestRun = true;
169   m_expectedStartTestRunCallCount = callCount;
170 }
171 
172 
173 void
setExpectEndTestRun(CPPUNIT_NS::Test * test,CPPUNIT_NS::TestResult * eventManager)174 MockTestListener::setExpectEndTestRun( CPPUNIT_NS::Test *test,
175                                        CPPUNIT_NS::TestResult *eventManager )
176 {
177   m_hasExpectationForEndTestRun = true;
178   m_hasParametersExpectationForEndTestRun = true;
179   m_expectedEndTestRunCallCount = 1;
180   m_expectedEndTestRun = test;
181   m_expectedEndTestRun2 = eventManager;
182 }
183 
184 
185 void
setExpectedEndTestRunCall(int callCount)186 MockTestListener::setExpectedEndTestRunCall( int callCount )
187 {
188   m_hasExpectationForEndTestRun = true;
189   m_expectedEndTestRunCallCount = callCount;
190 }
191 
192 
193 void
addFailure(const CPPUNIT_NS::TestFailure & failure)194 MockTestListener::addFailure( const CPPUNIT_NS::TestFailure &failure )
195 {
196   if ( m_hasExpectationForAddFailure  ||  m_hasExpectationForSomeFailure )
197     ++m_addFailureCall;
198 
199   if ( m_hasExpectationForAddFailure )
200   {
201     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
202                             m_addFailureCall <= m_expectedAddFailureCallCount );
203   }
204 
205   if ( m_hasParametersExpectationForAddFailure )
206   {
207     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
208                             m_expectedFailedTest == failure.failedTest() );
209     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad thrownException",
210                             m_expectedException == failure.thrownException() );
211     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad isError",
212                             m_expectedIsError == failure.isError() );
213   }
214 }
215 
216 
217 void
startTest(CPPUNIT_NS::Test * test)218 MockTestListener::startTest( CPPUNIT_NS::Test *test )
219 {
220   if ( m_hasExpectationForStartTest )
221   {
222     ++m_startTestCall;
223     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
224                             m_startTestCall <= m_expectedStartTestCallCount );
225 
226   }
227 
228   if ( m_hasParametersExpectationForStartTest )
229   {
230     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
231                             m_expectedStartTest == test );
232   }
233 }
234 
235 
236 void
endTest(CPPUNIT_NS::Test * test)237 MockTestListener::endTest( CPPUNIT_NS::Test *test )
238 {
239   if ( m_hasExpectationForEndTest )
240   {
241     ++m_endTestCall;
242     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
243                             m_endTestCall <= m_expectedEndTestCallCount );
244   }
245 
246   if ( m_hasParametersExpectationForEndTest )
247   {
248     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
249                             m_expectedEndTest == test );
250   }
251 }
252 
253 
254 void
startSuite(CPPUNIT_NS::Test * test)255 MockTestListener::startSuite( CPPUNIT_NS::Test *test )
256 {
257   if ( m_hasExpectationForStartSuite )
258   {
259     ++m_startSuiteCall;
260     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
261                             m_startSuiteCall <= m_expectedStartSuiteCallCount );
262   }
263 
264   if ( m_hasParametersExpectationForStartSuite )
265   {
266     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
267                             m_expectedStartSuite == test );
268   }
269 }
270 
271 
272 void
endSuite(CPPUNIT_NS::Test * test)273 MockTestListener::endSuite( CPPUNIT_NS::Test *test )
274 {
275   if ( m_hasExpectationForEndSuite )
276   {
277     ++m_endSuiteCall;
278     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
279                             m_endSuiteCall <= m_expectedEndSuiteCallCount );
280   }
281 
282   if ( m_hasParametersExpectationForEndSuite )
283   {
284     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
285                             m_expectedEndSuite == test );
286   }
287 }
288 
289 
290 void
startTestRun(CPPUNIT_NS::Test * test,CPPUNIT_NS::TestResult * eventManager)291 MockTestListener::startTestRun( CPPUNIT_NS::Test *test,
292                                 CPPUNIT_NS::TestResult *eventManager )
293 {
294   if ( m_hasExpectationForStartTestRun )
295   {
296     ++m_startTestRunCall;
297     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
298                             m_startTestRunCall <= m_expectedStartTestRunCallCount );
299   }
300 
301   if ( m_hasParametersExpectationForStartTestRun )
302   {
303     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
304                             m_expectedStartTestRun == test );
305     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad eventManager",
306                             m_expectedStartTestRun2 == eventManager );
307   }
308 }
309 
310 
311 void
endTestRun(CPPUNIT_NS::Test * test,CPPUNIT_NS::TestResult * eventManager)312 MockTestListener::endTestRun( CPPUNIT_NS::Test *test,
313                               CPPUNIT_NS::TestResult *eventManager )
314 {
315   if ( m_hasExpectationForEndTestRun )
316   {
317     ++m_endTestRunCall;
318     CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
319                             m_endTestRunCall <= m_expectedEndTestRunCallCount );
320   }
321 
322   if ( m_hasParametersExpectationForEndTestRun )
323   {
324     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
325                             m_expectedEndTestRun == test );
326     CPPUNIT_ASSERT_MESSAGE( m_name + ": bad eventManager",
327                             m_expectedEndTestRun2 == eventManager );
328   }
329 }
330 
331 
332 void
verify()333 MockTestListener::verify()
334 {
335   if ( m_hasExpectationForStartTest )
336   {
337     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing startTest calls",
338                                   m_expectedStartTestCallCount,
339                                   m_startTestCall );
340   }
341 
342   if ( m_hasExpectationForEndTest )
343   {
344     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing endTest calls",
345                                   m_expectedEndTestCallCount,
346                                   m_endTestCall );
347   }
348 
349   if ( m_hasExpectationForStartSuite )
350   {
351     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing startSuite calls",
352                                   m_expectedStartSuiteCallCount,
353                                   m_startSuiteCall );
354   }
355 
356   if ( m_hasExpectationForEndSuite )
357   {
358     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing endSuite calls",
359                                   m_expectedEndSuiteCallCount,
360                                   m_endSuiteCall );
361   }
362 
363   if ( m_hasExpectationForStartTestRun )
364   {
365     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing startTestRun calls",
366                                   m_expectedStartTestRunCallCount,
367                                   m_startTestRunCall );
368   }
369 
370   if ( m_hasExpectationForEndTestRun )
371   {
372     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing endTestRun calls",
373                                   m_expectedEndTestRunCallCount,
374                                   m_endTestRunCall );
375   }
376 
377   if ( m_hasExpectationForAddFailure )
378   {
379     CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing addFailure calls",
380                                   m_expectedAddFailureCallCount,
381                                   m_addFailureCall );
382   }
383 
384   if ( m_hasExpectationForSomeFailure )
385   {
386     CPPUNIT_ASSERT_MESSAGE( m_name + ": there was no call to "
387                                 "MockTestListener::addFailure()",
388                             m_addFailureCall > 0 );
389   }
390 }
391