]> git.stg.codes - stg.git/blob - tests/tut/tut_restartable.hpp
Log all SIGHUP-related activity.
[stg.git] / tests / tut / tut_restartable.hpp
1 #ifndef TUT_RESTARTABLE_H_GUARD
2 #define TUT_RESTARTABLE_H_GUARD
3
4 #include <tut/tut.hpp>
5 #include <fstream>
6 #include <iostream>
7 #include <stdexcept>
8 #include <cassert>
9
10 /**
11  * Optional restartable wrapper for test_runner.
12  *
13  * Allows to restart test runs finished due to abnormal
14  * test application termination (such as segmentation
15  * fault or math error).
16  *
17  * @author Vladimir Dyuzhev, Vladimir.Dyuzhev@gmail.com
18  */
19
20 namespace tut
21 {
22
23 namespace util
24 {
25
26 /**
27  * Escapes non-alphabetical characters in string.
28  */
29 std::string escape(const std::string& orig)
30 {
31     std::string rc;
32     std::string::const_iterator i,e;
33     i = orig.begin();
34     e = orig.end();
35
36     while (i != e)
37     {
38         if ((*i >= 'a' && *i <= 'z') ||
39                 (*i >= 'A' && *i <= 'Z') ||
40                 (*i >= '0' && *i <= '9') )
41         {
42             rc += *i;
43         }
44         else
45         {
46             rc += '\\';
47             rc += ('a'+(((unsigned int)*i) >> 4));
48             rc += ('a'+(((unsigned int)*i) & 0xF));
49         }
50
51         ++i;
52     }
53     return rc;
54 }
55
56 /**
57  * Un-escapes string.
58  */
59 std::string unescape(const std::string& orig)
60 {
61     std::string rc;
62     std::string::const_iterator i,e;
63     i = orig.begin();
64     e = orig.end();
65
66     while (i != e)
67     {
68         if (*i != '\\')
69         {
70             rc += *i;
71         }
72         else
73         {
74             ++i;
75             if (i == e)
76             {
77                 throw std::invalid_argument("unexpected end of string");
78             }
79             unsigned int c1 = *i;
80             ++i;
81             if (i == e)
82             {
83                 throw std::invalid_argument("unexpected end of string");
84             }
85             unsigned int c2 = *i;
86             rc += (((c1 - 'a') << 4) + (c2 - 'a'));
87         }
88
89         ++i;
90     }
91     return rc;
92 }
93
94 /**
95  * Serialize test_result avoiding interfering with operator <<.
96  */
97 void serialize(std::ostream& os, const tut::test_result& tr)
98 {
99     os << escape(tr.group) << std::endl;
100     os << tr.test << ' ';
101     switch(tr.result)
102     {
103     case test_result::ok:
104         os << 0;
105         break;
106     case test_result::fail:
107         os << 1;
108         break;
109     case test_result::ex:
110         os << 2;
111         break;
112     case test_result::warn:
113         os << 3;
114         break;
115     case test_result::term:
116         os << 4;
117         break;
118     case test_result::rethrown:
119         os << 5;
120         break;
121     case test_result::ex_ctor:
122         os << 6;
123         break;
124     case test_result::dummy:
125         assert(!"Should never be called");
126     default:
127         throw std::logic_error("operator << : bad result_type");
128     }
129     os << ' ' << escape(tr.message) << std::endl;
130 }
131
132 /**
133  * deserialization for test_result
134  */
135 bool deserialize(std::istream& is, tut::test_result& tr)
136 {
137     std::getline(is,tr.group);
138     if (is.eof())
139     {
140         return false;
141     }
142     tr.group = unescape(tr.group);
143
144     tr.test = -1;
145     is >> tr.test;
146     if (tr.test < 0)
147     {
148         throw std::logic_error("operator >> : bad test number");
149     }
150
151     int n = -1;
152     is >> n;
153     switch(n)
154     {
155     case 0:
156         tr.result = test_result::ok;
157         break;
158     case 1:
159         tr.result = test_result::fail;
160         break;
161     case 2:
162         tr.result = test_result::ex;
163         break;
164     case 3:
165         tr.result = test_result::warn;
166         break;
167     case 4:
168         tr.result = test_result::term;
169         break;
170     case 5:
171         tr.result = test_result::rethrown;
172         break;
173     case 6:
174         tr.result = test_result::ex_ctor;
175         break;
176     default:
177         throw std::logic_error("operator >> : bad result_type");
178     }
179
180     is.ignore(1); // space
181     std::getline(is,tr.message);
182     tr.message = unescape(tr.message);
183     if (!is.good())
184     {
185         throw std::logic_error("malformed test result");
186     }
187     return true;
188 }
189 }
190
191 /**
192  * Restartable test runner wrapper.
193  */
194 class restartable_wrapper
195 {
196     test_runner& runner_;
197     callbacks callbacks_;
198
199     std::string dir_;
200     std::string log_; // log file: last test being executed
201     std::string jrn_; // journal file: results of all executed tests
202
203 public:
204     /**
205      * Default constructor.
206      * @param dir Directory where to search/put log and journal files
207      */
208     restartable_wrapper(const std::string& dir = ".")
209         : runner_(runner.get()),
210           callbacks_(),
211           dir_(dir),
212           log_( dir + '/' + "log.tut" ),
213           jrn_( dir + '/' + "journal.tut" )
214     {
215         // dozen: it works, but it would be better to use system path separator
216     }
217
218     /**
219      * Stores another group for getting by name.
220      */
221     void register_group(const std::string& name, group_base* gr)
222     {
223         runner_.register_group(name,gr);
224     }
225
226     /**
227      * Stores callback object.
228      */
229     void set_callback(callback* cb)
230     {
231         callbacks_.clear();
232         callbacks_.insert(cb);
233     }
234
235     void insert_callback(callback* cb)
236     {
237         callbacks_.insert(cb);
238     }
239
240     void erase_callback(callback* cb)
241     {
242         callbacks_.erase(cb);
243     }
244
245     void set_callbacks(const callbacks& cb)
246     {
247         callbacks_ = cb;
248     }
249
250     const callbacks& get_callbacks() const
251     {
252         return runner_.get_callbacks();
253     }
254
255     /**
256      * Returns list of known test groups.
257      */
258     groupnames list_groups() const
259     {
260         return runner_.list_groups();
261     }
262
263     /**
264      * Runs all tests in all groups.
265      */
266     void run_tests() const
267     {
268         // where last run was failed
269         std::string fail_group;
270         int fail_test;
271         read_log_(fail_group,fail_test);
272         bool fail_group_reached = (fail_group == "");
273
274         // iterate over groups
275         tut::groupnames gn = list_groups();
276         tut::groupnames::const_iterator gni,gne;
277         gni = gn.begin();
278         gne = gn.end();
279         while (gni != gne)
280         {
281             // skip all groups before one that failed
282             if (!fail_group_reached)
283             {
284                 if (*gni != fail_group)
285                 {
286                     ++gni;
287                     continue;
288                 }
289                 fail_group_reached = true;
290             }
291
292             // first or restarted run
293             int test = (*gni == fail_group && fail_test >= 0) ? fail_test + 1 : 1;
294             while(true)
295             {
296                 // last executed test pos
297                 register_execution_(*gni,test);
298
299                 tut::test_result tr;
300                 if( !runner_.run_test(*gni,test, tr) || tr.result == test_result::dummy )
301                 {
302                     break;
303                 }
304                 register_test_(tr);
305
306                 ++test;
307             }
308
309             ++gni;
310         }
311
312         // show final results to user
313         invoke_callback_();
314
315         // truncate files as mark of successful finish
316         truncate_();
317     }
318
319 private:
320     /**
321      * Shows results from journal file.
322      */
323     void invoke_callback_() const
324     {
325         runner_.set_callbacks(callbacks_);
326         runner_.cb_run_started_();
327
328         std::string current_group;
329         std::ifstream ijournal(jrn_.c_str());
330         while (ijournal.good())
331         {
332             tut::test_result tr;
333             if( !util::deserialize(ijournal,tr) )
334             {
335                 break;
336             }
337             runner_.cb_test_completed_(tr);
338         }
339
340         runner_.cb_run_completed_();
341     }
342
343     /**
344      * Register test into journal.
345      */
346     void register_test_(const test_result& tr) const
347     {
348         std::ofstream ojournal(jrn_.c_str(), std::ios::app);
349         util::serialize(ojournal, tr);
350         ojournal << std::flush;
351         if (!ojournal.good())
352         {
353             throw std::runtime_error("unable to register test result in file "
354                 + jrn_);
355         }
356     }
357
358     /**
359      * Mark the fact test going to be executed
360      */
361     void register_execution_(const std::string& grp, int test) const
362     {
363         // last executed test pos
364         std::ofstream olog(log_.c_str());
365         olog << util::escape(grp) << std::endl << test << std::endl << std::flush;
366         if (!olog.good())
367         {
368             throw std::runtime_error("unable to register execution in file "
369                 + log_);
370         }
371     }
372
373     /**
374      * Truncate tests.
375      */
376     void truncate_() const
377     {
378         std::ofstream olog(log_.c_str());
379         std::ofstream ojournal(jrn_.c_str());
380     }
381
382     /**
383      * Read log file
384      */
385     void read_log_(std::string& fail_group, int& fail_test) const
386     {
387         // read failure point, if any
388         std::ifstream ilog(log_.c_str());
389         std::getline(ilog,fail_group);
390         fail_group = util::unescape(fail_group);
391         ilog >> fail_test;
392         if (!ilog.good())
393         {
394             fail_group = "";
395             fail_test = -1;
396             truncate_();
397         }
398         else
399         {
400             // test was terminated...
401             tut::test_result tr(fail_group, fail_test, "", tut::test_result::term);
402             register_test_(tr);
403         }
404     }
405 };
406
407 }
408
409 #endif
410