1 #include "CoreSuite.h"
2 #include "TestResultCollectorTest.h"
3
4
5
6 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TestResultCollectorTest,
7 coreSuiteName() );
8
9
TestResultCollectorTest()10 TestResultCollectorTest::TestResultCollectorTest()
11 {
12 }
13
14
~TestResultCollectorTest()15 TestResultCollectorTest::~TestResultCollectorTest()
16 {
17 }
18
19
20 void
setUp()21 TestResultCollectorTest::setUp()
22 {
23 m_lockCount = 0;
24 m_unlockCount = 0;
25 m_result = new CPPUNIT_NS::TestResultCollector();
26 m_synchronizedResult = new SynchronizedTestResult( this );
27 m_test = new CPPUNIT_NS::TestCase();
28 m_test2 = new CPPUNIT_NS::TestCase();
29 }
30
31
32 void
tearDown()33 TestResultCollectorTest::tearDown()
34 {
35 delete m_test2;
36 delete m_test;
37 delete m_synchronizedResult;
38 delete m_result;
39 }
40
41
42 void
testConstructor()43 TestResultCollectorTest::testConstructor()
44 {
45 checkResult( 0, 0, 0 );
46 }
47
48
49 void
testAddTwoErrors()50 TestResultCollectorTest::testAddTwoErrors()
51 {
52 CPPUNIT_NS::Message errorMessage1( "First Error" );
53 CPPUNIT_NS::Message errorMessage2( "Second Error" );
54 {
55 CPPUNIT_NS::TestFailure failure1( m_test,
56 new CPPUNIT_NS::Exception( errorMessage1 ),
57 true );
58 m_result->addFailure( failure1 );
59
60 CPPUNIT_NS::TestFailure failure2( m_test2,
61 new CPPUNIT_NS::Exception( errorMessage2 ),
62 true );
63 m_result->addFailure( failure2 );
64 } // ensure that the test result duplicate the failures.
65
66 checkResult( 0, 2, 0 );
67 checkFailure( m_result->failures()[0],
68 errorMessage1,
69 m_test,
70 true );
71 checkFailure( m_result->failures()[1],
72 errorMessage2,
73 m_test2,
74 true );
75 }
76
77
78 void
testAddTwoFailures()79 TestResultCollectorTest::testAddTwoFailures()
80 {
81 CPPUNIT_NS::Message errorMessage1( "First Failure" );
82 CPPUNIT_NS::Message errorMessage2( "Second Failure" );
83 {
84 CPPUNIT_NS::TestFailure failure1( m_test,
85 new CPPUNIT_NS::Exception( errorMessage1 ),
86 false );
87 m_result->addFailure( failure1 );
88
89 CPPUNIT_NS::TestFailure failure2( m_test2,
90 new CPPUNIT_NS::Exception( errorMessage2 ),
91 false );
92 m_result->addFailure( failure2 );
93 } // ensure that the test result duplicate the failures.
94 checkResult( 2, 0, 0 );
95 checkFailure( m_result->failures()[0],
96 errorMessage1,
97 m_test,
98 false );
99 checkFailure( m_result->failures()[1],
100 errorMessage2,
101 m_test2,
102 false );
103 }
104
105
106 void
testStartTest()107 TestResultCollectorTest::testStartTest()
108 {
109 m_result->startTest( m_test );
110 m_result->startTest( m_test );
111 checkResult( 0, 0, 2 );
112 }
113
114
115 void
testWasSuccessfulWithNoTest()116 TestResultCollectorTest::testWasSuccessfulWithNoTest()
117 {
118 checkWasSuccessful( true );
119 }
120
121
122 void
testWasSuccessfulWithErrors()123 TestResultCollectorTest::testWasSuccessfulWithErrors()
124 {
125 addError( "Error1" );
126 addError( "Error2" );
127 checkWasSuccessful( false );
128 }
129
130
131 void
testWasSuccessfulWithFailures()132 TestResultCollectorTest::testWasSuccessfulWithFailures()
133 {
134 addFailure( "Failure1" );
135 addFailure( "Failure2" );
136 checkWasSuccessful( false );
137 }
138
139
140 void
testWasSuccessfulWithErrorsAndFailures()141 TestResultCollectorTest::testWasSuccessfulWithErrorsAndFailures()
142 {
143 addError( "Error1" );
144 addFailure( "Failure2" );
145 checkWasSuccessful( false );
146 }
147
148
149 void
testWasSuccessfulWithSuccessfulTest()150 TestResultCollectorTest::testWasSuccessfulWithSuccessfulTest()
151 {
152 m_result->startTest( m_test );
153 m_result->endTest( m_test );
154 m_result->startTest( m_test2 );
155 m_result->endTest( m_test2 );
156 checkWasSuccessful( true );
157 }
158
159
160 void
testSynchronizationAddFailure()161 TestResultCollectorTest::testSynchronizationAddFailure()
162 {
163 addFailure( "Failure1", m_test, false, m_synchronizedResult );
164 checkSynchronization();
165 }
166
167
168 void
testSynchronizationStartTest()169 TestResultCollectorTest::testSynchronizationStartTest()
170 {
171 m_synchronizedResult->startTest( m_test );
172 checkSynchronization();
173 }
174
175
176 void
testSynchronizationRunTests()177 TestResultCollectorTest::testSynchronizationRunTests()
178 {
179 m_synchronizedResult->runTests();
180 checkSynchronization();
181 }
182
183
184 void
testSynchronizationTestErrors()185 TestResultCollectorTest::testSynchronizationTestErrors()
186 {
187 m_synchronizedResult->testErrors();
188 checkSynchronization();
189 }
190
191
192 void
testSynchronizationTestFailures()193 TestResultCollectorTest::testSynchronizationTestFailures()
194 {
195 m_synchronizedResult->testFailures();
196 checkSynchronization();
197 }
198
199
200 void
testSynchronizationFailures()201 TestResultCollectorTest::testSynchronizationFailures()
202 {
203 m_synchronizedResult->failures();
204 checkSynchronization();
205 }
206
207
208 void
testSynchronizationWasSuccessful()209 TestResultCollectorTest::testSynchronizationWasSuccessful()
210 {
211 m_synchronizedResult->wasSuccessful();
212 checkSynchronization();
213 }
214
215
216 void
checkResult(int failures,int errors,int testsRun)217 TestResultCollectorTest::checkResult( int failures,
218 int errors,
219 int testsRun )
220 {
221 CPPUNIT_ASSERT_EQUAL( testsRun, m_result->runTests() );
222 CPPUNIT_ASSERT_EQUAL( errors, m_result->testErrors() );
223 CPPUNIT_ASSERT_EQUAL( failures, m_result->testFailures() );
224 CPPUNIT_ASSERT_EQUAL( errors + failures,
225 m_result->testFailuresTotal() );
226 }
227
228
229 void
checkFailure(CPPUNIT_NS::TestFailure * failure,CPPUNIT_NS::Message expectedMessage,CPPUNIT_NS::Test * expectedTest,bool expectedIsError)230 TestResultCollectorTest::checkFailure( CPPUNIT_NS::TestFailure *failure,
231 CPPUNIT_NS::Message expectedMessage,
232 CPPUNIT_NS::Test *expectedTest,
233 bool expectedIsError )
234 {
235 CPPUNIT_NS::Message actualMessage( failure->thrownException()->message() );
236 CPPUNIT_ASSERT( expectedMessage == actualMessage );
237 CPPUNIT_ASSERT_EQUAL( expectedTest, failure->failedTest() );
238 CPPUNIT_ASSERT_EQUAL( expectedIsError, failure->isError() );
239 }
240
241
242 void
checkWasSuccessful(bool shouldBeSuccessful)243 TestResultCollectorTest::checkWasSuccessful( bool shouldBeSuccessful )
244 {
245 CPPUNIT_ASSERT_EQUAL( shouldBeSuccessful, m_result->wasSuccessful() );
246 }
247
248
249 void
locked()250 TestResultCollectorTest::locked()
251 {
252 CPPUNIT_ASSERT_EQUAL( m_lockCount, m_unlockCount );
253 ++m_lockCount;
254 }
255
256
257 void
unlocked()258 TestResultCollectorTest::unlocked()
259 {
260 ++m_unlockCount;
261 CPPUNIT_ASSERT_EQUAL( m_lockCount, m_unlockCount );
262 }
263
264
265 void
checkSynchronization()266 TestResultCollectorTest::checkSynchronization()
267 {
268 CPPUNIT_ASSERT_EQUAL( m_lockCount, m_unlockCount );
269 CPPUNIT_ASSERT( m_lockCount > 0 );
270 }
271
272
273 void
addFailure(std::string message)274 TestResultCollectorTest::addFailure( std::string message )
275 {
276 addFailure( message, m_test, false, m_result );
277 }
278
279
280 void
addError(std::string message)281 TestResultCollectorTest::addError( std::string message )
282 {
283 addFailure( message, m_test, true, m_result );
284 }
285
286
287 void
addFailure(std::string message,CPPUNIT_NS::Test * failedTest,bool isError,CPPUNIT_NS::TestResultCollector * result)288 TestResultCollectorTest::addFailure( std::string message,
289 CPPUNIT_NS::Test *failedTest,
290 bool isError,
291 CPPUNIT_NS::TestResultCollector *result )
292 {
293 CPPUNIT_NS::TestFailure failure( failedTest,
294 new CPPUNIT_NS::Exception( CPPUNIT_NS::Message( message ) ),
295 isError );
296 result->addFailure( failure );
297 }
298