]> git.stg.codes - stg.git/blob - tests/tut/tut_console_reporter.hpp
Ticket 37. The true parameter changed to false in ensure_equals()
[stg.git] / tests / tut / tut_console_reporter.hpp
1 #ifndef TUT_CONSOLE_REPORTER
2 #define TUT_CONSOLE_REPORTER
3 #include <tut/tut.hpp>
4 #include <cassert>
5
6 /**
7  * Template Unit Tests Framework for C++.
8  * http://tut.dozen.ru
9  *
10  * @author Vladimir Dyuzhev, Vladimir.Dyuzhev@gmail.com
11  */
12 namespace
13 {
14
15 std::ostream& operator<<(std::ostream& os, const tut::test_result& tr)
16 {
17     switch(tr.result)
18     {
19         case tut::test_result::ok:
20             os << '.';
21             break;
22         case tut::test_result::fail:
23             os << '[' << tr.test << "=F]";
24             break;
25         case tut::test_result::ex_ctor:
26             os << '[' << tr.test << "=C]";
27             break;
28         case tut::test_result::ex:
29             os << '[' << tr.test << "=X]";
30             break;
31         case tut::test_result::warn:
32             os << '[' << tr.test << "=W]";
33             break;
34         case tut::test_result::term:
35             os << '[' << tr.test << "=T]";
36             break;
37         case tut::test_result::rethrown:
38             os << '[' << tr.test << "=P]";
39             break;
40         case tut::test_result::skipped:
41             os << '[' << tr.test << "=S]";
42             break;
43         case tut::test_result::dummy:
44             throw tut::tut_error("console reporter called for dummy test result");
45     }
46
47     return os;
48 }
49
50 } // end of namespace
51
52 namespace tut
53 {
54
55 /**
56  * Default TUT callback handler.
57  */
58 class console_reporter : public tut::callback
59 {
60     std::string current_group;
61     typedef std::vector<tut::test_result> not_passed_list;
62     not_passed_list not_passed;
63     std::ostream& os;
64
65     console_reporter(const console_reporter &);
66     console_reporter &operator=(const console_reporter &);
67 public:
68
69     int ok_count;
70     int exceptions_count;
71     int failures_count;
72     int terminations_count;
73     int warnings_count;
74     int skipped_count;
75
76     console_reporter()
77         : current_group(),
78           not_passed(),
79           os(std::cout),
80           ok_count(0),
81           exceptions_count(0),
82           failures_count(0),
83           terminations_count(0),
84           warnings_count(0),
85           skipped_count(0)
86     {
87         init();
88     }
89
90     console_reporter(std::ostream& out)
91         : current_group(),
92           not_passed(),
93           os(out),
94           ok_count(0),
95           exceptions_count(0),
96           failures_count(0),
97           terminations_count(0),
98           warnings_count(0),
99           skipped_count(0)
100
101     {
102         init();
103     }
104
105     void run_started()
106     {
107         init();
108     }
109
110     void test_completed(const tut::test_result& tr)
111     {
112         if (tr.group != current_group)
113         {
114             os << std::endl << tr.group << ": " << std::flush;
115             current_group = tr.group;
116         }
117
118         os << tr << std::flush;
119
120         // update global statistics
121         switch (tr.result) {
122             case test_result::ok:
123                 ok_count++;
124                 break;
125             case test_result::fail:
126             case test_result::rethrown:
127                 failures_count++;
128                 break;
129             case test_result::ex:
130             case test_result::ex_ctor:
131                 exceptions_count++;
132                 break;
133             case test_result::warn:
134                 warnings_count++;
135                 break;
136             case test_result::term:
137                 terminations_count++;
138                 break;
139             case test_result::skipped:
140                 skipped_count++;
141                 break;
142             case tut::test_result::dummy:
143                 assert( (tr.result != tut::test_result::dummy) && "Should never be called");
144         } // switch
145
146         if ( (tr.result != tut::test_result::ok) &&
147              (tr.result != tut::test_result::skipped) )
148         {
149             not_passed.push_back(tr);
150         }
151     }
152
153     void run_completed()
154     {
155         os << std::endl;
156
157         if (not_passed.size() > 0)
158         {
159             not_passed_list::const_iterator i = not_passed.begin();
160             while (i != not_passed.end())
161             {
162                 tut::test_result tr = *i;
163
164                 os << std::endl;
165
166                 os << "---> " << "group: " << tr.group
167                 << ", test: test<" << tr.test << ">"
168                 << (!tr.name.empty() ? (std::string(" : ") + tr.name) : std::string())
169                 << std::endl;
170
171 #if defined(TUT_USE_POSIX)
172                 if(tr.pid != getpid())
173                 {
174                     os << "     child pid: " << tr.pid << std::endl;
175                 }
176 #endif
177                 os << "     problem: ";
178                 switch(tr.result)
179                 {
180                 case test_result::rethrown:
181                     os << "assertion failed in child" << std::endl;
182                     break;
183                 case test_result::fail:
184                     os << "assertion failed" << std::endl;
185                     break;
186                 case test_result::ex:
187                 case test_result::ex_ctor:
188                     os << "unexpected exception" << std::endl;
189                     if( tr.exception_typeid != "" )
190                     {
191                         os << "     exception typeid: "
192                         << tr.exception_typeid << std::endl;
193                     }
194                     break;
195                 case test_result::term:
196                     os << "would be terminated" << std::endl;
197                     break;
198                 case test_result::warn:
199                     os << "test passed, but cleanup code (destructor) raised"
200                         " an exception" << std::endl;
201                     break;
202                 default:
203                     break;
204                 }
205
206                 if (!tr.message.empty())
207                 {
208                     if (tr.result == test_result::fail)
209                     {
210                         os << "     failed assertion: `" << tr.message << "`"
211                             << std::endl;
212                     }
213                     else
214                     {
215                         os << "     message: `" << tr.message << "`"
216                             << std::endl;
217                     }
218                 }
219
220                 ++i;
221             }
222         }
223
224         os << std::endl;
225
226         os << "tests summary:";
227         if (terminations_count > 0)
228         {
229             os << " terminations:" << terminations_count;
230         }
231         if (exceptions_count > 0)
232         {
233             os << " exceptions:" << exceptions_count;
234         }
235         if (failures_count > 0)
236         {
237             os << " failures:" << failures_count;
238         }
239         if (warnings_count > 0)
240         {
241             os << " warnings:" << warnings_count;
242         }
243
244         os << " ok:" << ok_count;
245
246         if(skipped_count > 0)
247         {
248             os << " skipped:" << skipped_count;
249         }
250         os << std::endl;
251     }
252
253     virtual bool all_ok() const
254     {
255         return not_passed.empty();
256     }
257
258 private:
259
260     void init()
261     {
262         ok_count = 0;
263         exceptions_count = 0;
264         failures_count = 0;
265         terminations_count = 0;
266         warnings_count = 0;
267         skipped_count = 0;
268         not_passed.clear();
269     }
270 };
271
272 }
273
274 #endif