]> git.stg.codes - stg.git/blob - tests/tut/tut_posix.hpp
Merge branch 'master' into full-month-stats
[stg.git] / tests / tut / tut_posix.hpp
1 #ifndef TUT_FORK_H_GUARD
2 #define TUT_FORK_H_GUARD
3 #include <tut/tut_config.hpp>
4
5 #if defined(TUT_USE_POSIX)
6 #include <errno.h>
7 #include <unistd.h>
8 #include <signal.h>
9 #include <sys/wait.h>
10 #include <sys/time.h>
11 #include <sys/types.h>
12
13 #include <cstring>
14 #include <cstdlib>
15 #include <map>
16 #include <iterator>
17 #include <functional>
18
19 #include "tut_result.hpp"
20 #include "tut_assert.hpp"
21 #include "tut_runner.hpp"
22
23 namespace tut
24 {
25
26 template<typename, int>
27 class test_group;
28
29 template<typename T>
30 class test_object;
31
32 class test_group_posix
33 {
34 private:
35     template<typename, int>
36     friend class test_group;
37
38     template<typename T>
39     void send_result_(const T *obj, const test_result &tr)
40     {
41         if(obj->get_pipe_() == -1)
42         {
43             return;
44         }
45
46         if(tr.result != test_result::ok)
47         {
48             std::ostringstream ss;
49             ss << int(tr.result) << "\n"
50                 << tr.group << "\n"
51                 << tr.test << "\n"
52                 << tr.name << "\n"
53                 << tr.exception_typeid << "\n";
54             std::copy( tr.message.begin(), tr.message.end(), std::ostreambuf_iterator<char>(ss.rdbuf()) );
55
56             int size = ss.str().length();
57             int w = write(obj->get_pipe_(), ss.str().c_str(), size);
58             ensure_errno("write() failed", w == size);
59         }
60     }
61
62     virtual ~test_group_posix()
63     {
64     }
65 };
66
67 template<typename T>
68 struct tut_posix
69 {
70     pid_t fork()
71     {
72         test_object<T> *self = dynamic_cast< tut::test_object<T>* >(this);
73         ensure("trying to call 'tut_fork' in ctor of test object", self != NULL);
74
75         return self->fork_();
76     }
77
78     pid_t waitpid(pid_t pid, int *status, int flags = 0)
79     {
80         test_object<T> *self = dynamic_cast< tut::test_object<T>* >(this);
81         ensure("trying to call 'tut_waitpid' in ctor of test object", self != NULL);
82
83         return self->waitpid_(pid, status, flags);
84     }
85
86     void ensure_child_exit(pid_t pid, int exit_status = 0)
87     {
88         test_object<T> *self = dynamic_cast< tut::test_object<T>* >(this);
89         ensure("trying to call 'ensure_child_exit' in ctor of test object", self != NULL);
90
91         int status;
92         self->waitpid_(pid, &status);
93
94         self->ensure_child_exit_(status, exit_status);
95     }
96
97
98     void ensure_child_signal(pid_t pid, int signal = SIGTERM)
99     {
100         test_object<T> *self = dynamic_cast< tut::test_object<T>* >(this);
101         ensure("trying to call 'ensure_child_signal' in ctor of test object", self != NULL);
102
103         int status;
104         self->waitpid_(pid, &status);
105
106         self->ensure_child_signal_(status, signal);
107     }
108
109     std::set<pid_t> get_pids() const
110     {
111         using namespace std;
112
113         const test_object<T> *self = dynamic_cast< const tut::test_object<T>* >(this);
114         ensure("trying to call 'get_pids' in ctor of test object", self != NULL);
115
116         return self->get_pids_();
117     }
118
119     virtual ~tut_posix()
120     {
121     }
122
123 };
124
125 class test_object_posix
126 {
127 public:
128     typedef std::map<pid_t, int> pid_map;
129
130     /**
131      * Default constructor
132      */
133     test_object_posix()
134         : pids_(),
135           pipe_(-1)
136     {
137     }
138
139
140     virtual ~test_object_posix()
141     {
142         // we have forked
143         if(pipe_ != -1)
144         {
145             // in child, force exit
146             std::exit(0);
147         }
148
149         if(!pids_.empty())
150         {
151             std::ostringstream ss;
152
153             // in parent, reap children
154             for(std::map<pid_t, int>::iterator i = pids_.begin(); i != pids_.end(); ++i)
155             {
156                 try {
157                     kill_child_(i->first);
158                 } catch(const rethrown &ex) {
159                     ss << std::endl << "child " << ex.tr.pid << " has thrown an exception: " << ex.what();
160                 } catch(const failure &ex) {
161                     ss << std::endl << ex.what();
162                 }
163             }
164
165             if(!ss.str().empty())
166             {
167                 fail(ss.str().c_str());
168             }
169         }
170     }
171
172 private:
173     template<typename T>
174     friend class tut_posix;
175
176     friend class test_group_posix;
177
178     int get_pipe_() const
179     {
180         return pipe_;
181     }
182
183
184     pid_t fork_()
185     {
186         // create pipe
187         int fds[2];
188         ensure_errno("pipe() failed", ::pipe(fds) == 0);
189
190         pid_t pid = ::fork();
191
192         ensure_errno("fork() failed", pid >= 0);
193
194         if(pid != 0)
195         {
196             // in parent, register pid
197             ensure("duplicated child", pids_.insert( std::make_pair(pid, fds[0]) ).second);
198
199             // close writing side
200             close(fds[1]);
201         }
202         else
203         {
204             // in child, shutdown reporter
205             tut::runner.get().clear_callbacks();
206
207             // close reading side
208             close(fds[0]);
209             pipe_ = fds[1];
210         }
211
212         return pid;
213     }
214
215     void kill_child_(pid_t pid)
216     {
217         int status;
218
219         if(waitpid_(pid, &status, WNOHANG) == pid)
220         {
221             ensure_child_exit_(status, 0);
222             return;
223         }
224
225         if(::kill(pid, SIGTERM) != 0)
226         {
227             if(errno == ESRCH)
228             {
229                 // no such process
230                 return;
231             }
232             else
233             {
234                 // cannot kill, we are in trouble
235                 std::ostringstream ss;
236                 char e[1024];
237                 ss << "child " << pid << " could not be killed with SIGTERM, " << strerror_r(errno, e, sizeof(e)) << std::endl;
238                 fail(ss.str());
239             }
240         }
241
242         if(waitpid_(pid, &status, WNOHANG) == pid)
243         {
244             // child killed, check signal
245             ensure_child_signal_(status, SIGTERM);
246
247             ensure_equals("child process exists after SIGTERM", ::kill(pid, 0), -1);
248             return;
249         }
250
251         // child seems to be still exiting, give it some time
252         sleep(2);
253
254         if(waitpid_(pid, &status, WNOHANG) != pid)
255         {
256             // child is still running, kill it
257             if(::kill(pid, SIGKILL) != 0)
258             {
259                 if(errno == ESRCH)
260                 {
261                     // no such process
262                     return;
263                 }
264                 else
265                 {
266                     std::ostringstream ss;
267                     char e[1024];
268                     ss << "child " << pid << " could not be killed with SIGKILL, " << strerror_r(errno, e, sizeof(e)) << std::endl;
269                     fail(ss.str());
270                 }
271             }
272
273             ensure_equals("wait after SIGKILL", waitpid_(pid, &status), pid);
274             ensure_child_signal_(status, SIGKILL);
275
276             ensure_equals("child process exists after SIGKILL", ::kill(pid, 0), -1);
277
278             std::ostringstream ss;
279             ss << "child " << pid << " had to be killed with SIGKILL";
280             fail(ss.str());
281         }
282     }
283
284     test_result receive_result_(std::istream &ss, pid_t pid)
285     {
286         test_result tr;
287
288         int type;
289         ss >> type;
290         tr.result = test_result::result_type(type);
291         ss.ignore(1024, '\n');
292
293         std::getline(ss, tr.group);
294         ss >> tr.test;
295         ss.ignore(1024, '\n');
296         std::getline(ss, tr.name);
297         std::getline(ss, tr.exception_typeid);
298         std::copy( std::istreambuf_iterator<char>(ss.rdbuf()),
299                    std::istreambuf_iterator<char>(),
300                    std::back_inserter(tr.message) );
301
302         tr.pid = pid;
303
304         return tr;
305     }
306
307     struct fdclose
308     {
309         fdclose(int fd): fd_(fd) { }
310         ~fdclose()
311         {
312             close(fd_);
313         }
314     private:
315         int fd_;
316     };
317
318     pid_t waitpid_(pid_t pid, int *status, int flags = 0)
319     {
320
321         ensure("trying to wait for unknown pid", pids_.count(pid) > 0);
322
323         pid_t p = ::waitpid(pid, status, flags);
324         if( (flags & WNOHANG) && (p != pid) )
325         {
326             return p;
327         }
328
329         // read child result from pipe
330         fd_set fdset;
331         timeval tv;
332         tv.tv_sec = 0;
333         tv.tv_usec = 0;
334
335         FD_ZERO(&fdset);
336
337         int pipe = pids_[pid];
338         fdclose guard(pipe);
339
340         FD_SET(pipe, &fdset);
341
342         int result = select(pipe+1, &fdset, NULL, NULL, &tv);
343         ensure_errno("sanity check on select() failed", result >= 0);
344
345         if(result > 0)
346         {
347             ensure("sanity check on FD_ISSET() failed", FD_ISSET(pipe, &fdset) );
348
349             std::stringstream ss;
350
351             //TODO: max failure length
352             char buffer[1024];
353             int r = read(pipe, buffer, sizeof(buffer));
354             ensure_errno("sanity check on read() failed", r >= 0);
355
356             if(r > 0)
357             {
358                 ss.write(buffer, r);
359                 throw rethrown( receive_result_(ss, pid) );
360             }
361         }
362
363         return pid;
364     }
365
366     void ensure_child_exit_(int status, int exit_status)
367     {
368         if(WIFSIGNALED(status))
369         {
370             std::ostringstream ss;
371             ss << "child killed by signal " << WTERMSIG(status)
372                 << ": expected exit with code " << exit_status;
373
374             throw failure(ss.str().c_str());
375         }
376
377         if(WIFEXITED(status))
378         {
379             if(WEXITSTATUS(status) != exit_status)
380             {
381                 std::ostringstream ss;
382                 ss << "child exited, expected '"
383                     << exit_status
384                     << "' actual '"
385                     << WEXITSTATUS(status)
386                     << '\'';
387
388                 throw failure(ss.str().c_str());
389             }
390         }
391
392         if(WIFSTOPPED(status))
393         {
394             std::ostringstream ss;
395             ss << "child stopped by signal " << WTERMSIG(status)
396                 << ": expected exit with code " << exit_status;
397             throw failure(ss.str().c_str());
398         }
399     }
400
401     void ensure_child_signal_(int status, int signal)
402     {
403         if(WIFSIGNALED(status))
404         {
405             if(WTERMSIG(status) != signal)
406             {
407                 std::ostringstream ss;
408                 ss << "child killed by signal, expected '"
409                     << signal
410                     << "' actual '"
411                     << WTERMSIG(status)
412                     << '\'';
413                 throw failure(ss.str().c_str());
414             }
415         }
416
417         if(WIFEXITED(status))
418         {
419             std::ostringstream ss;
420             ss << "child exited with code " << WEXITSTATUS(status)
421                 << ": expected signal " << signal;
422
423             throw failure(ss.str().c_str());
424         }
425
426         if(WIFSTOPPED(status))
427         {
428             std::ostringstream ss;
429             ss << "child stopped by signal " << WTERMSIG(status)
430                 << ": expected kill by signal " << signal;
431
432             throw failure(ss.str().c_str());
433         }
434     }
435
436     std::set<pid_t> get_pids_() const
437     {
438         using namespace std;
439
440         set<pid_t> pids;
441         for(pid_map::const_iterator i = pids_.begin(); i != pids_.end(); ++i)
442         {
443             pids.insert( i->first );
444         }
445
446         return pids;
447     }
448
449     pid_map         pids_;
450     int             pipe_;
451 };
452
453 } // namespace tut
454
455 #else
456
457 namespace tut
458 {
459
460 struct test_object_posix
461 {
462     virtual ~test_object_posix()
463     {
464     }
465 };
466
467 struct test_group_posix
468 {
469     template<typename T>
470     void send_result_(const T*, const test_result &)
471     {
472     }
473
474     virtual ~test_group_posix()
475     {
476     }
477 };
478
479 } // namespace tut
480
481 #endif
482
483
484 #endif
485