← Back to branch summary

~clint-fewbar/ubuntu/precise/squid3/ignore-sighup-early

« back to all changes in this revision

Viewing changes to lib/cppunit-1.10.0/examples/cppunittest/XmlOutputterTest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Luigi Gangitano
  • Date: 2006-11-11 10:32:06 UTC
  • Revision ID: james.westby@ubuntu.com-20061111103206-f3p0r9g0vq44rp3r
Tags: upstream-3.0.PRE5
Import upstream version 3.0.PRE5

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/cppunit-1.10.0/examples/cppunittest/XmlOutputterTest.cpp
 
1
#include <cppunit/XmlOutputter.h>
 
2
#include <cppunit/TestFailure.h>
 
3
#include <cppunit/XmlOutputter.h>
 
4
#include <cppunit/XmlOutputterHook.h>
 
5
#include "OutputSuite.h"
 
6
#include "XmlOutputterTest.h"
 
7
#include "XmlUniformiser.h"
 
8
 
 
9
 
 
10
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( XmlOutputterTest, 
 
11
                                       outputSuiteName() );
 
12
 
 
13
 
 
14
XmlOutputterTest::XmlOutputterTest()
 
15
{
 
16
}
 
17
 
 
18
 
 
19
XmlOutputterTest::~XmlOutputterTest()
 
20
{
 
21
}
 
22
 
 
23
 
 
24
void 
 
25
XmlOutputterTest::setUp()
 
26
{
 
27
  m_dummyTests.clear();
 
28
  m_result = new CPPUNIT_NS::TestResultCollector();
 
29
}
 
30
 
 
31
 
 
32
void 
 
33
XmlOutputterTest::tearDown()
 
34
{
 
35
  delete m_result;
 
36
  for ( unsigned int index =0; index < m_dummyTests.size(); ++index )
 
37
    delete m_dummyTests[index];
 
38
  m_dummyTests.clear();
 
39
}
 
40
 
 
41
 
 
42
void 
 
43
XmlOutputterTest::testWriteXmlResultWithNoTest()
 
44
{
 
45
  CPPUNIT_NS::OStringStream stream;
 
46
  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );
 
47
  outputter.write();
 
48
 
 
49
  std::string actualXml = stream.str();
 
50
  std::string expectedXml = 
 
51
    "<TestRun>"
 
52
      "<FailedTests></FailedTests>"
 
53
      "<SuccessfulTests></SuccessfulTests>"
 
54
      "<Statistics>"
 
55
        "<Tests>0</Tests>"
 
56
        "<FailuresTotal>0</FailuresTotal>"
 
57
        "<Errors>0</Errors>"
 
58
        "<Failures>0</Failures>"
 
59
      "</Statistics>"
 
60
    "</TestRun>";
 
61
  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );
 
62
}
 
63
 
 
64
 
 
65
void 
 
66
XmlOutputterTest::testWriteXmlResultWithOneFailure()
 
67
{
 
68
  addTestFailure( "test1", "message failure1", CPPUNIT_NS::SourceLine( "test.cpp", 3 ) );
 
69
 
 
70
  CPPUNIT_NS::OStringStream stream;
 
71
  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );
 
72
  outputter.write();
 
73
 
 
74
  std::string actualXml = stream.str();
 
75
  std::string expectedXml = 
 
76
    "<TestRun>"
 
77
      "<FailedTests>"
 
78
        "<FailedTest id=\"1\">"
 
79
          "<Name>test1</Name>"
 
80
          "<FailureType>Assertion</FailureType>"
 
81
          "<Location>"
 
82
            "<File>test.cpp</File>"
 
83
            "<Line>3</Line>"
 
84
          "</Location>"
 
85
          "<Message>message failure1</Message>"
 
86
        "</FailedTest>"
 
87
      "</FailedTests>"
 
88
      "<SuccessfulTests></SuccessfulTests>"
 
89
      "<Statistics>"
 
90
        "<Tests>1</Tests>"
 
91
        "<FailuresTotal>1</FailuresTotal>"
 
92
        "<Errors>0</Errors>"
 
93
        "<Failures>1</Failures>"
 
94
      "</Statistics>"
 
95
    "</TestRun>";
 
96
  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );
 
97
}
 
98
 
 
99
 
 
100
void 
 
101
XmlOutputterTest::testWriteXmlResultWithOneError()
 
102
{
 
103
  addTestError( "test1", "message error1" );
 
104
 
 
105
  CPPUNIT_NS::OStringStream stream;
 
106
  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );
 
107
  outputter.write();
 
108
 
 
109
  std::string actualXml = stream.str();
 
110
  std::string expectedXml = 
 
111
    "<TestRun>"
 
112
      "<FailedTests>"
 
113
        "<FailedTest id=\"1\">"
 
114
          "<Name>test1</Name>"
 
115
          "<FailureType>Error</FailureType>"
 
116
          "<Message>message error1</Message>"
 
117
        "</FailedTest>"
 
118
      "</FailedTests>"
 
119
      "<SuccessfulTests></SuccessfulTests>"
 
120
      "<Statistics>"
 
121
        "<Tests>1</Tests>"
 
122
        "<FailuresTotal>1</FailuresTotal>"
 
123
        "<Errors>1</Errors>"
 
124
        "<Failures>0</Failures>"
 
125
      "</Statistics>"
 
126
    "</TestRun>";
 
127
  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );
 
128
}
 
129
 
 
130
 
 
131
void 
 
132
XmlOutputterTest::testWriteXmlResultWithOneSuccess()
 
133
{
 
134
  addTest( "test1" );
 
135
 
 
136
  CPPUNIT_NS::OStringStream stream;
 
137
  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );
 
138
  outputter.write();
 
139
 
 
140
  std::string actualXml = stream.str();
 
141
  std::string expectedXml = 
 
142
    "<TestRun>"
 
143
      "<FailedTests></FailedTests>"
 
144
      "<SuccessfulTests>"
 
145
        "<Test id=\"1\">"
 
146
          "<Name>test1</Name>"
 
147
        "</Test>"
 
148
      "</SuccessfulTests>"
 
149
      "<Statistics>"
 
150
        "<Tests>1</Tests>"
 
151
        "<FailuresTotal>0</FailuresTotal>"
 
152
        "<Errors>0</Errors>"
 
153
        "<Failures>0</Failures>"
 
154
      "</Statistics>"
 
155
    "</TestRun>";
 
156
  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );
 
157
}
 
158
 
 
159
 
 
160
void 
 
161
XmlOutputterTest::testWriteXmlResultWithThreeFailureTwoErrorsAndTwoSuccess()
 
162
{
 
163
  addTestFailure( "test1", "failure1" );
 
164
  addTestError( "test2", "error1" );
 
165
  addTestFailure( "test3", "failure2" );
 
166
  addTestFailure( "test4", "failure3" );
 
167
  addTest( "test5" );
 
168
  addTestError( "test6", "error2" );
 
169
  addTest( "test7" );
 
170
 
 
171
  CPPUNIT_NS::OStringStream stream;
 
172
  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );
 
173
  outputter.write();
 
174
 
 
175
  std::string actualXml = stream.str();
 
176
  std::string expectedXml = 
 
177
    "<TestRun>"
 
178
       "<FailedTests>"
 
179
        "<FailedTest id=\"1\">"
 
180
          "<Name>test1</Name>"
 
181
          "<FailureType>Assertion</FailureType>"
 
182
          "<Message>failure1</Message>"
 
183
        "</FailedTest>"
 
184
        "<FailedTest id=\"2\">"
 
185
          "<Name>test2</Name>"
 
186
          "<FailureType>Error</FailureType>"
 
187
          "<Message>error1</Message>"
 
188
        "</FailedTest>"
 
189
        "<FailedTest id=\"3\">"
 
190
          "<Name>test3</Name>"
 
191
          "<FailureType>Assertion</FailureType>"
 
192
          "<Message>failure2</Message>"
 
193
        "</FailedTest>"
 
194
        "<FailedTest id=\"4\">"
 
195
          "<Name>test4</Name>"
 
196
          "<FailureType>Assertion</FailureType>"
 
197
          "<Message>failure3</Message>"
 
198
        "</FailedTest>"
 
199
        "<FailedTest id=\"6\">"
 
200
          "<Name>test6</Name>"
 
201
          "<FailureType>Error</FailureType>"
 
202
          "<Message>error2</Message>"
 
203
        "</FailedTest>"
 
204
      "</FailedTests>"
 
205
     "<SuccessfulTests>"
 
206
        "<Test id=\"5\">"
 
207
          "<Name>test5</Name>"
 
208
        "</Test>"
 
209
        "<Test id=\"7\">"
 
210
          "<Name>test7</Name>"
 
211
        "</Test>"
 
212
      "</SuccessfulTests>"
 
213
      "<Statistics>"
 
214
        "<Tests>7</Tests>"
 
215
        "<FailuresTotal>5</FailuresTotal>"
 
216
        "<Errors>2</Errors>"
 
217
        "<Failures>3</Failures>"
 
218
      "</Statistics>"
 
219
    "</TestRun>";
 
220
  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );
 
221
}
 
222
 
 
223
 
 
224
class XmlOutputterTest::MockHook : public CPPUNIT_NS::XmlOutputterHook
 
225
{
 
226
public:
 
227
  MockHook( int &beginCalls,
 
228
            int &endCalls,
 
229
            int &statisticsCalls,
 
230
            int &successfulTestCalls,
 
231
            int &failedTestCalls )
 
232
      : m_successfulTestCalls( successfulTestCalls )
 
233
      , m_failedTestCalls( failedTestCalls )
 
234
      , m_beginCalls( beginCalls )
 
235
      , m_endCalls( endCalls )
 
236
      , m_statisticsCalls( statisticsCalls )
 
237
  {
 
238
  }
 
239
 
 
240
  void beginDocument( CPPUNIT_NS::XmlDocument *document )
 
241
  {
 
242
    ++m_beginCalls;
 
243
  }
 
244
 
 
245
  void endDocument( CPPUNIT_NS::XmlDocument *document )
 
246
  {
 
247
    ++m_endCalls;
 
248
  }
 
249
 
 
250
  void failTestAdded( CPPUNIT_NS::XmlDocument *document,
 
251
                      CPPUNIT_NS::XmlElement *testElement,
 
252
                      CPPUNIT_NS::Test *test,
 
253
                      CPPUNIT_NS::TestFailure *failure )
 
254
  {
 
255
    ++m_failedTestCalls;
 
256
  }
 
257
 
 
258
  void successfulTestAdded( CPPUNIT_NS::XmlDocument *document,
 
259
                            CPPUNIT_NS::XmlElement *testElement,
 
260
                            CPPUNIT_NS::Test *test )
 
261
  {
 
262
    ++m_successfulTestCalls;
 
263
  }
 
264
 
 
265
  void statisticsAdded( CPPUNIT_NS::XmlDocument *document,
 
266
                        CPPUNIT_NS::XmlElement *statisticsElement )
 
267
  {
 
268
    ++m_statisticsCalls;
 
269
  }
 
270
 
 
271
private:
 
272
  int &m_beginCalls;
 
273
  int &m_endCalls;
 
274
  int &m_statisticsCalls;
 
275
  int &m_successfulTestCalls;
 
276
  int &m_failedTestCalls;
 
277
};
 
278
 
 
279
 
 
280
void 
 
281
XmlOutputterTest::testHook()
 
282
{
 
283
  int begin =0, end =0, statistics =0, successful =0, failed =0;
 
284
  MockHook hook( begin, end, statistics, successful, failed );
 
285
 
 
286
  addTest( "test1" );
 
287
  addTest( "test2" );
 
288
  addTest( "test3" );
 
289
  addTestFailure( "testfail1", "assertion failed" );
 
290
  addTestError( "testerror1", "exception" );
 
291
 
 
292
  CPPUNIT_NS::OStringStream stream;
 
293
  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );
 
294
  outputter.addHook( &hook );
 
295
  outputter.write();
 
296
 
 
297
  CPPUNIT_ASSERT_EQUAL( 1, begin );
 
298
  CPPUNIT_ASSERT_EQUAL( 1, end );
 
299
  CPPUNIT_ASSERT_EQUAL( 1, statistics );
 
300
  CPPUNIT_ASSERT_EQUAL( 3, successful );
 
301
  CPPUNIT_ASSERT_EQUAL( 2, failed );
 
302
}
 
303
 
 
304
 
 
305
void 
 
306
XmlOutputterTest::addTest( std::string testName )
 
307
{
 
308
  CPPUNIT_NS::Test *test = makeDummyTest( testName );
 
309
  m_result->startTest( test );
 
310
  m_result->endTest( test );
 
311
}
 
312
 
 
313
 
 
314
void 
 
315
XmlOutputterTest::addTestFailure( std::string testName,
 
316
                                  std::string message,
 
317
                                  CPPUNIT_NS::SourceLine sourceLine )
 
318
{
 
319
  addGenericTestFailure( testName, CPPUNIT_NS::Message(message), sourceLine, false );
 
320
}
 
321
 
 
322
 
 
323
void 
 
324
XmlOutputterTest::addTestError( std::string testName,
 
325
                                std::string message,
 
326
                                CPPUNIT_NS::SourceLine sourceLine )
 
327
{
 
328
  addGenericTestFailure( testName, CPPUNIT_NS::Message(message), sourceLine, true );
 
329
}
 
330
 
 
331
 
 
332
void 
 
333
XmlOutputterTest::addGenericTestFailure(  std::string testName,
 
334
                                          CPPUNIT_NS::Message message,
 
335
                                          CPPUNIT_NS::SourceLine sourceLine,
 
336
                                          bool isError )
 
337
{
 
338
  CPPUNIT_NS::Test *test = makeDummyTest( testName );
 
339
  m_result->startTest( test );
 
340
  CPPUNIT_NS::TestFailure failure( test, 
 
341
                                new CPPUNIT_NS::Exception( message, sourceLine ),
 
342
                                isError );
 
343
  m_result->addFailure( failure );
 
344
  m_result->endTest( test );
 
345
}
 
346
 
 
347
 
 
348
CPPUNIT_NS::Test *
 
349
XmlOutputterTest::makeDummyTest( std::string testName )
 
350
{
 
351
  CPPUNIT_NS::Test *test = new CPPUNIT_NS::TestCase( testName );
 
352
  m_dummyTests.push_back( test );
 
353
  return test;
 
354
}
 
355