xref: /freebsd/contrib/atf/atf-sh/atf-check.cpp (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a)
1 // Copyright (c) 2008 The NetBSD Foundation, Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions
6 // are met:
7 // 1. Redistributions of source code must retain the above copyright
8 //    notice, this list of conditions and the following disclaimer.
9 // 2. Redistributions in binary form must reproduce the above copyright
10 //    notice, this list of conditions and the following disclaimer in the
11 //    documentation and/or other materials provided with the distribution.
12 //
13 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
14 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
15 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
16 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
18 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
20 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
22 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
24 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 
26 extern "C" {
27 #include <sys/types.h>
28 #include <sys/wait.h>
29 
30 #include <limits.h>
31 #include <signal.h>
32 #include <stdint.h>
33 #include <unistd.h>
34 }
35 
36 #include <cerrno>
37 #include <cstdlib>
38 #include <cstring>
39 #include <fstream>
40 #include <ios>
41 #include <iostream>
42 #include <iterator>
43 #include <list>
44 #include <memory>
45 #include <utility>
46 
47 #include "atf-c++/check.hpp"
48 #include "atf-c++/detail/application.hpp"
49 #include "atf-c++/detail/auto_array.hpp"
50 #include "atf-c++/detail/env.hpp"
51 #include "atf-c++/detail/exceptions.hpp"
52 #include "atf-c++/detail/fs.hpp"
53 #include "atf-c++/detail/process.hpp"
54 #include "atf-c++/detail/sanity.hpp"
55 #include "atf-c++/detail/text.hpp"
56 
57 static const useconds_t seconds_in_useconds = (1000 * 1000);
58 static const useconds_t mseconds_in_useconds = 1000;
59 static const useconds_t useconds_in_nseconds = 1000;
60 
61 // ------------------------------------------------------------------------
62 // Auxiliary functions.
63 // ------------------------------------------------------------------------
64 
65 namespace {
66 
67 enum status_check_t {
68     sc_exit,
69     sc_ignore,
70     sc_signal,
71 };
72 
73 struct status_check {
74     status_check_t type;
75     bool negated;
76     int value;
77 
78     status_check(const status_check_t& p_type, const bool p_negated,
79                  const int p_value) :
80         type(p_type),
81         negated(p_negated),
82         value(p_value)
83     {
84     }
85 };
86 
87 enum output_check_t {
88     oc_ignore,
89     oc_inline,
90     oc_file,
91     oc_empty,
92     oc_match,
93     oc_save
94 };
95 
96 struct output_check {
97     output_check_t type;
98     bool negated;
99     std::string value;
100 
101     output_check(const output_check_t& p_type, const bool p_negated,
102                  const std::string& p_value) :
103         type(p_type),
104         negated(p_negated),
105         value(p_value)
106     {
107     }
108 };
109 
110 class temp_file : public std::ostream {
111     std::auto_ptr< atf::fs::path > m_path;
112     int m_fd;
113 
114 public:
115     temp_file(const char* pattern) :
116         std::ostream(NULL),
117         m_fd(-1)
118     {
119         const atf::fs::path file = atf::fs::path(
120             atf::env::get("TMPDIR", "/tmp")) / pattern;
121 
122         atf::auto_array< char > buf(new char[file.str().length() + 1]);
123         std::strcpy(buf.get(), file.c_str());
124 
125         m_fd = ::mkstemp(buf.get());
126         if (m_fd == -1)
127             throw atf::system_error("atf_check::temp_file::temp_file(" +
128                                     file.str() + ")", "mkstemp(3) failed",
129                                     errno);
130 
131         m_path.reset(new atf::fs::path(buf.get()));
132     }
133 
134     ~temp_file(void)
135     {
136         close();
137         try {
138             remove(*m_path);
139         } catch (const atf::system_error&) {
140             // Ignore deletion errors.
141         }
142     }
143 
144     const atf::fs::path&
145     get_path(void) const
146     {
147         return *m_path;
148     }
149 
150     void
151     write(const std::string& text)
152     {
153         if (::write(m_fd, text.c_str(), text.size()) == -1)
154             throw atf::system_error("atf_check", "write(2) failed", errno);
155     }
156 
157     void
158     close(void)
159     {
160         if (m_fd != -1) {
161             flush();
162             ::close(m_fd);
163             m_fd = -1;
164         }
165     }
166 };
167 
168 } // anonymous namespace
169 
170 static useconds_t
171 get_monotonic_useconds(void)
172 {
173     struct timespec ts;
174     useconds_t res;
175     int rc;
176 
177     rc = clock_gettime(CLOCK_MONOTONIC, &ts);
178     if (rc != 0)
179         throw std::runtime_error("clock_gettime: " +
180             std::string(strerror(errno)));
181 
182     res = ts.tv_sec * seconds_in_useconds;
183     res += ts.tv_nsec / useconds_in_nseconds;
184     return res;
185 }
186 
187 static bool
188 timo_expired(useconds_t timeout)
189 {
190 
191     if (get_monotonic_useconds() >= timeout)
192         return true;
193     return false;
194 }
195 
196 
197 static int
198 parse_exit_code(const std::string& str)
199 {
200     try {
201         const int value = atf::text::to_type< int >(str);
202         if (value < 0 || value > 255)
203             throw std::runtime_error("Unused reason");
204         return value;
205     } catch (const std::runtime_error&) {
206         throw atf::application::usage_error("Invalid exit code for -s option; "
207             "must be an integer in range 0-255");
208     }
209 }
210 
211 static struct name_number {
212     const char *name;
213     int signo;
214 } signal_names_to_numbers[] = {
215     { "hup", SIGHUP },
216     { "int", SIGINT },
217     { "quit", SIGQUIT },
218     { "trap", SIGTRAP },
219     { "abrt", SIGABRT },
220     { "kill", SIGKILL },
221     { "segv", SIGSEGV },
222     { "pipe", SIGPIPE },
223     { "alrm", SIGALRM },
224     { "term", SIGTERM },
225     { "usr1", SIGUSR1 },
226     { "usr2", SIGUSR2 },
227     { NULL, INT_MIN },
228 };
229 
230 static int
231 signal_name_to_number(const std::string& str)
232 {
233     struct name_number* iter = signal_names_to_numbers;
234     int signo = INT_MIN;
235     while (signo == INT_MIN && iter->name != NULL) {
236         if (str == iter->name || str == std::string("sig") + iter->name)
237             signo = iter->signo;
238         else
239             iter++;
240     }
241     return signo;
242 }
243 
244 static int
245 parse_signal(const std::string& str)
246 {
247     const int signo = signal_name_to_number(str);
248     if (signo == INT_MIN) {
249         try {
250             return atf::text::to_type< int >(str);
251         } catch (const std::runtime_error&) {
252             throw atf::application::usage_error("Invalid signal name or number "
253                 "in -s option");
254         }
255     }
256     INV(signo != INT_MIN);
257     return signo;
258 }
259 
260 static status_check
261 parse_status_check_arg(const std::string& arg)
262 {
263     const std::string::size_type delimiter = arg.find(':');
264     bool negated = (arg.compare(0, 4, "not-") == 0);
265     const std::string action_str = arg.substr(0, delimiter);
266     const std::string action = negated ? action_str.substr(4) : action_str;
267     const std::string value_str = (
268         delimiter == std::string::npos ? "" : arg.substr(delimiter + 1));
269     int value;
270 
271     status_check_t type;
272     if (action == "eq") {
273         // Deprecated; use exit instead.  TODO: Remove after 0.10.
274         type = sc_exit;
275         if (negated)
276             throw atf::application::usage_error("Cannot negate eq checker");
277         negated = false;
278         value = parse_exit_code(value_str);
279     } else if (action == "exit") {
280         type = sc_exit;
281         if (value_str.empty())
282             value = INT_MIN;
283         else
284             value = parse_exit_code(value_str);
285     } else if (action == "ignore") {
286         if (negated)
287             throw atf::application::usage_error("Cannot negate ignore checker");
288         type = sc_ignore;
289         value = INT_MIN;
290     } else if (action == "ne") {
291         // Deprecated; use not-exit instead.  TODO: Remove after 0.10.
292         type = sc_exit;
293         if (negated)
294             throw atf::application::usage_error("Cannot negate ne checker");
295         negated = true;
296         value = parse_exit_code(value_str);
297     } else if (action == "signal") {
298         type = sc_signal;
299         if (value_str.empty())
300             value = INT_MIN;
301         else
302             value = parse_signal(value_str);
303     } else
304         throw atf::application::usage_error("Invalid status checker");
305 
306     return status_check(type, negated, value);
307 }
308 
309 static
310 output_check
311 parse_output_check_arg(const std::string& arg)
312 {
313     const std::string::size_type delimiter = arg.find(':');
314     const bool negated = (arg.compare(0, 4, "not-") == 0);
315     const std::string action_str = arg.substr(0, delimiter);
316     const std::string action = negated ? action_str.substr(4) : action_str;
317 
318     output_check_t type;
319     if (action == "empty")
320         type = oc_empty;
321     else if (action == "file")
322         type = oc_file;
323     else if (action == "ignore") {
324         if (negated)
325             throw atf::application::usage_error("Cannot negate ignore checker");
326         type = oc_ignore;
327     } else if (action == "inline")
328         type = oc_inline;
329     else if (action == "match")
330         type = oc_match;
331     else if (action == "save") {
332         if (negated)
333             throw atf::application::usage_error("Cannot negate save checker");
334         type = oc_save;
335     } else
336         throw atf::application::usage_error("Invalid output checker");
337 
338     return output_check(type, negated, arg.substr(delimiter + 1));
339 }
340 
341 static void
342 parse_repeat_check_arg(const std::string& arg, useconds_t *m_timo,
343     useconds_t *m_interval)
344 {
345     const std::string::size_type delimiter = arg.find(':');
346     const bool has_interval = (delimiter != std::string::npos);
347     const std::string timo_str = arg.substr(0, delimiter);
348 
349     long l;
350     char *end;
351 
352     // There is no reason this couldn't be a non-integer number of seconds,
353     // this was just easy to do for now.
354     errno = 0;
355     l = strtol(timo_str.c_str(), &end, 10);
356     if (errno == ERANGE)
357         throw atf::application::usage_error("Bogus timeout in seconds");
358     else if (errno != 0)
359         throw atf::application::usage_error("Timeout must be a number");
360 
361     if (*end != 0)
362         throw atf::application::usage_error("Timeout must be a number");
363 
364     *m_timo = get_monotonic_useconds() + (l * seconds_in_useconds);
365     // 50 milliseconds is chosen arbitrarily.  There is a tradeoff between
366     // longer and shorter poll times.  A shorter poll time makes for faster
367     // tests.  A longer poll time makes for lower CPU overhead for the polled
368     // operation.  50ms is chosen with these tradeoffs in mind: on
369     // microcontrollers, the hope is that we can still avoid meaningful CPU use
370     // with a small test every 50ms.  And on typical fast x86 hardware, our
371     // tests can be much more precise with time wasted than they typically are
372     // without this feature.
373     *m_interval = 50 * mseconds_in_useconds;
374 
375     if (!has_interval)
376         return;
377 
378     const std::string intv_str = arg.substr(delimiter + 1, std::string::npos);
379 
380     // Same -- this could be non-integer milliseconds.
381     errno = 0;
382     l = strtol(intv_str.c_str(), &end, 10);
383     if (errno == ERANGE)
384         throw atf::application::usage_error(
385             "Bogus repeat interval in milliseconds");
386     else if (errno != 0)
387         throw atf::application::usage_error(
388             "Repeat interval must be a number");
389 
390     if (*end != 0)
391         throw atf::application::usage_error(
392             "Repeat interval must be a number");
393 
394     *m_interval = l * mseconds_in_useconds;
395 }
396 
397 static
398 std::string
399 flatten_argv(char* const* argv)
400 {
401     std::string cmdline;
402 
403     char* const* arg = &argv[0];
404     while (*arg != NULL) {
405         if (arg != &argv[0])
406             cmdline += ' ';
407 
408         cmdline += *arg;
409 
410         arg++;
411     }
412 
413     return cmdline;
414 }
415 
416 static
417 std::auto_ptr< atf::check::check_result >
418 execute(const char* const* argv)
419 {
420     // TODO: This should go to stderr... but fixing it now may be hard as test
421     // cases out there might be relying on stderr being silent.
422     std::cout << "Executing command [ ";
423     for (int i = 0; argv[i] != NULL; ++i)
424         std::cout << argv[i] << " ";
425     std::cout << "]\n";
426     std::cout.flush();
427 
428     atf::process::argv_array argva(argv);
429     return atf::check::exec(argva);
430 }
431 
432 static
433 std::auto_ptr< atf::check::check_result >
434 execute_with_shell(char* const* argv)
435 {
436     const std::string cmd = flatten_argv(argv);
437     const std::string shell = atf::env::get("ATF_SHELL", ATF_SHELL);
438 
439     const char* sh_argv[4];
440     sh_argv[0] = shell.c_str();
441     sh_argv[1] = "-c";
442     sh_argv[2] = cmd.c_str();
443     sh_argv[3] = NULL;
444     return execute(sh_argv);
445 }
446 
447 static
448 void
449 cat_file(const atf::fs::path& path)
450 {
451     std::ifstream stream(path.c_str());
452     if (!stream)
453         throw std::runtime_error("Failed to open " + path.str());
454 
455     stream >> std::noskipws;
456     std::istream_iterator< char > begin(stream), end;
457     std::ostream_iterator< char > out(std::cerr);
458     std::copy(begin, end, out);
459 
460     stream.close();
461 }
462 
463 static
464 bool
465 grep_file(const atf::fs::path& path, const std::string& regexp)
466 {
467     std::ifstream stream(path.c_str());
468     if (!stream)
469         throw std::runtime_error("Failed to open " + path.str());
470 
471     bool found = false;
472 
473     std::string line;
474     while (!found && !std::getline(stream, line).fail()) {
475         if (atf::text::match(line, regexp))
476             found = true;
477     }
478 
479     stream.close();
480 
481     return found;
482 }
483 
484 static
485 bool
486 file_empty(const atf::fs::path& p)
487 {
488     atf::fs::file_info f(p);
489 
490     return (f.get_size() == 0);
491 }
492 
493 static bool
494 compare_files(const atf::fs::path& p1, const atf::fs::path& p2)
495 {
496     bool equal = false;
497 
498     std::ifstream f1(p1.c_str());
499     if (!f1)
500         throw std::runtime_error("Failed to open " + p1.str());
501 
502     std::ifstream f2(p2.c_str());
503     if (!f2)
504         throw std::runtime_error("Failed to open " + p2.str());
505 
506     for (;;) {
507         char buf1[512], buf2[512];
508 
509         f1.read(buf1, sizeof(buf1));
510         if (f1.bad())
511             throw std::runtime_error("Failed to read from " + p1.str());
512 
513         f2.read(buf2, sizeof(buf2));
514         if (f2.bad())
515             throw std::runtime_error("Failed to read from " + p2.str());
516 
517         if ((f1.gcount() == 0) && (f2.gcount() == 0)) {
518             equal = true;
519             break;
520         }
521 
522         if ((f1.gcount() != f2.gcount()) ||
523             (std::memcmp(buf1, buf2, f1.gcount()) != 0)) {
524             break;
525         }
526     }
527 
528     return equal;
529 }
530 
531 static
532 void
533 print_diff(const atf::fs::path& p1, const atf::fs::path& p2)
534 {
535     const atf::process::status s =
536         atf::process::exec(atf::fs::path("diff"),
537                            atf::process::argv_array("diff", "-u", p1.c_str(),
538                                                     p2.c_str(), NULL),
539                            atf::process::stream_connect(STDOUT_FILENO,
540                                                         STDERR_FILENO),
541                            atf::process::stream_inherit());
542 
543     if (!s.exited())
544         std::cerr << "Failed to run diff(3)\n";
545 
546     if (s.exitstatus() != 1)
547         std::cerr << "Error while running diff(3)\n";
548 }
549 
550 static
551 std::string
552 decode(const std::string& s)
553 {
554     size_t i;
555     std::string res;
556 
557     res.reserve(s.length());
558 
559     i = 0;
560     while (i < s.length()) {
561         char c = s[i++];
562 
563         if (c == '\\') {
564             switch (s[i++]) {
565             case 'a': c = '\a'; break;
566             case 'b': c = '\b'; break;
567             case 'c': break;
568             case 'e': c = 033; break;
569             case 'f': c = '\f'; break;
570             case 'n': c = '\n'; break;
571             case 'r': c = '\r'; break;
572             case 't': c = '\t'; break;
573             case 'v': c = '\v'; break;
574             case '\\': break;
575             case '0':
576                 {
577                     int count = 3;
578                     c = 0;
579                     while (--count >= 0 && (unsigned)(s[i] - '0') < 8)
580                         c = (c << 3) + (s[i++] - '0');
581                     break;
582                 }
583             default:
584                 --i;
585                 break;
586             }
587         }
588 
589         res.push_back(c);
590     }
591 
592     return res;
593 }
594 
595 static
596 bool
597 run_status_check(const status_check& sc, const atf::check::check_result& cr)
598 {
599     bool result;
600 
601     if (sc.type == sc_exit) {
602         if (cr.exited() && sc.value != INT_MIN) {
603             const int status = cr.exitcode();
604 
605             if (!sc.negated && sc.value != status) {
606                 std::cerr << "Fail: incorrect exit status: "
607                           << status << ", expected: "
608                           << sc.value << "\n";
609                 result = false;
610             } else if (sc.negated && sc.value == status) {
611                 std::cerr << "Fail: incorrect exit status: "
612                           << status << ", expected: "
613                           << "anything else\n";
614                 result = false;
615             } else
616                 result = true;
617         } else if (cr.exited() && sc.value == INT_MIN) {
618             result = true;
619         } else {
620             std::cerr << "Fail: program did not exit cleanly\n";
621             result = false;
622         }
623     } else if (sc.type == sc_ignore) {
624         result = true;
625     } else if (sc.type == sc_signal) {
626         if (cr.signaled() && sc.value != INT_MIN) {
627             const int status = cr.termsig();
628 
629             if (!sc.negated && sc.value != status) {
630                 std::cerr << "Fail: incorrect signal received: "
631                           << status << ", expected: " << sc.value << "\n";
632                 result = false;
633             } else if (sc.negated && sc.value == status) {
634                 std::cerr << "Fail: incorrect signal received: "
635                           << status << ", expected: "
636                           << "anything else\n";
637                 result = false;
638             } else
639                 result = true;
640         } else if (cr.signaled() && sc.value == INT_MIN) {
641             result = true;
642         } else {
643             std::cerr << "Fail: program did not receive a signal\n";
644             result = false;
645         }
646     } else {
647         UNREACHABLE;
648         result = false;
649     }
650 
651     if (result == false) {
652         std::cerr << "stdout:\n";
653         cat_file(atf::fs::path(cr.stdout_path()));
654         std::cerr << "\n";
655 
656         std::cerr << "stderr:\n";
657         cat_file(atf::fs::path(cr.stderr_path()));
658         std::cerr << "\n";
659     }
660 
661     return result;
662 }
663 
664 static
665 bool
666 run_status_checks(const std::vector< status_check >& checks,
667                   const atf::check::check_result& result)
668 {
669     bool ok = false;
670 
671     for (std::vector< status_check >::const_iterator iter = checks.begin();
672          !ok && iter != checks.end(); iter++) {
673          ok |= run_status_check(*iter, result);
674     }
675 
676     return ok;
677 }
678 
679 static
680 bool
681 run_output_check(const output_check oc, const atf::fs::path& path,
682                  const std::string& stdxxx)
683 {
684     bool result;
685 
686     if (oc.type == oc_empty) {
687         const bool is_empty = file_empty(path);
688         if (!oc.negated && !is_empty) {
689             std::cerr << "Fail: " << stdxxx << " not empty\n";
690             print_diff(atf::fs::path("/dev/null"), path);
691             result = false;
692         } else if (oc.negated && is_empty) {
693             std::cerr << "Fail: " << stdxxx << " is empty\n";
694             result = false;
695         } else
696             result = true;
697     } else if (oc.type == oc_file) {
698         const bool equals = compare_files(path, atf::fs::path(oc.value));
699         if (!oc.negated && !equals) {
700             std::cerr << "Fail: " << stdxxx << " does not match golden "
701                 "output\n";
702             print_diff(atf::fs::path(oc.value), path);
703             result = false;
704         } else if (oc.negated && equals) {
705             std::cerr << "Fail: " << stdxxx << " matches golden output\n";
706             cat_file(atf::fs::path(oc.value));
707             result = false;
708         } else
709             result = true;
710     } else if (oc.type == oc_ignore) {
711         result = true;
712     } else if (oc.type == oc_inline) {
713         temp_file temp("atf-check.XXXXXX");
714         temp.write(decode(oc.value));
715         temp.close();
716 
717         const bool equals = compare_files(path, temp.get_path());
718         if (!oc.negated && !equals) {
719             std::cerr << "Fail: " << stdxxx << " does not match expected "
720                 "value\n";
721             print_diff(temp.get_path(), path);
722             result = false;
723         } else if (oc.negated && equals) {
724             std::cerr << "Fail: " << stdxxx << " matches expected value\n";
725             cat_file(temp.get_path());
726             result = false;
727         } else
728             result = true;
729     } else if (oc.type == oc_match) {
730         const bool matches = grep_file(path, oc.value);
731         if (!oc.negated && !matches) {
732             std::cerr << "Fail: regexp " + oc.value + " not in " << stdxxx
733                       << "\n";
734             cat_file(path);
735             result = false;
736         } else if (oc.negated && matches) {
737             std::cerr << "Fail: regexp " + oc.value + " is in " << stdxxx
738                       << "\n";
739             cat_file(path);
740             result = false;
741         } else
742             result = true;
743     } else if (oc.type == oc_save) {
744         INV(!oc.negated);
745         std::ifstream ifs(path.c_str(), std::fstream::binary);
746         ifs >> std::noskipws;
747         std::istream_iterator< char > begin(ifs), end;
748 
749         std::ofstream ofs(oc.value.c_str(), std::fstream::binary
750                                      | std::fstream::trunc);
751         std::ostream_iterator <char> obegin(ofs);
752 
753         std::copy(begin, end, obegin);
754         result = true;
755     } else {
756         UNREACHABLE;
757         result = false;
758     }
759 
760     return result;
761 }
762 
763 static
764 bool
765 run_output_checks(const std::vector< output_check >& checks,
766                   const atf::fs::path& path, const std::string& stdxxx)
767 {
768     bool ok = true;
769 
770     for (std::vector< output_check >::const_iterator iter = checks.begin();
771          iter != checks.end(); iter++) {
772          ok &= run_output_check(*iter, path, stdxxx);
773     }
774 
775     return ok;
776 }
777 
778 // ------------------------------------------------------------------------
779 // The "atf_check" application.
780 // ------------------------------------------------------------------------
781 
782 namespace {
783 
784 class atf_check : public atf::application::app {
785     bool m_rflag;
786     bool m_xflag;
787 
788     useconds_t m_timo;
789     useconds_t m_interval;
790 
791     std::vector< status_check > m_status_checks;
792     std::vector< output_check > m_stdout_checks;
793     std::vector< output_check > m_stderr_checks;
794 
795     static const char* m_description;
796 
797     bool run_output_checks(const atf::check::check_result&,
798                            const std::string&) const;
799 
800     std::string specific_args(void) const;
801     options_set specific_options(void) const;
802     void process_option(int, const char*);
803     void process_option_s(const std::string&);
804 
805 public:
806     atf_check(void);
807     int main(void);
808 };
809 
810 } // anonymous namespace
811 
812 const char* atf_check::m_description =
813     "atf-check executes given command and analyzes its results.";
814 
815 atf_check::atf_check(void) :
816     app(m_description, "atf-check(1)"),
817     m_rflag(false),
818     m_xflag(false)
819 {
820 }
821 
822 bool
823 atf_check::run_output_checks(const atf::check::check_result& r,
824                              const std::string& stdxxx)
825     const
826 {
827     if (stdxxx == "stdout") {
828         return ::run_output_checks(m_stdout_checks,
829             atf::fs::path(r.stdout_path()), "stdout");
830     } else if (stdxxx == "stderr") {
831         return ::run_output_checks(m_stderr_checks,
832             atf::fs::path(r.stderr_path()), "stderr");
833     } else {
834         UNREACHABLE;
835         return false;
836     }
837 }
838 
839 std::string
840 atf_check::specific_args(void)
841     const
842 {
843     return "<command>";
844 }
845 
846 atf_check::options_set
847 atf_check::specific_options(void)
848     const
849 {
850     using atf::application::option;
851     options_set opts;
852 
853     opts.insert(option('s', "qual:value", "Handle status. Qualifier "
854                 "must be one of: ignore exit:<num> signal:<name|num>"));
855     opts.insert(option('o', "action:arg", "Handle stdout. Action must be "
856                 "one of: empty ignore file:<path> inline:<val> match:regexp "
857                 "save:<path>"));
858     opts.insert(option('e', "action:arg", "Handle stderr. Action must be "
859                 "one of: empty ignore file:<path> inline:<val> match:regexp "
860                 "save:<path>"));
861     opts.insert(option('r', "timeout[:interval]", "Repeat failed check until "
862                 "the timeout expires."));
863     opts.insert(option('x', "", "Execute command as a shell command"));
864 
865     return opts;
866 }
867 
868 void
869 atf_check::process_option(int ch, const char* arg)
870 {
871     switch (ch) {
872     case 's':
873         m_status_checks.push_back(parse_status_check_arg(arg));
874         break;
875 
876     case 'o':
877         m_stdout_checks.push_back(parse_output_check_arg(arg));
878         break;
879 
880     case 'e':
881         m_stderr_checks.push_back(parse_output_check_arg(arg));
882         break;
883 
884     case 'r':
885         m_rflag = true;
886         parse_repeat_check_arg(arg, &m_timo, &m_interval);
887         break;
888 
889     case 'x':
890         m_xflag = true;
891         break;
892 
893     default:
894         UNREACHABLE;
895     }
896 }
897 
898 int
899 atf_check::main(void)
900 {
901     if (m_argc < 1)
902         throw atf::application::usage_error("No command specified");
903 
904     int status = EXIT_FAILURE;
905 
906     if (m_status_checks.empty())
907         m_status_checks.push_back(status_check(sc_exit, false, EXIT_SUCCESS));
908     else if (m_status_checks.size() > 1) {
909         // TODO: Remove this restriction.
910         throw atf::application::usage_error("Cannot specify -s more than once");
911     }
912 
913     if (m_stdout_checks.empty())
914         m_stdout_checks.push_back(output_check(oc_empty, false, ""));
915     if (m_stderr_checks.empty())
916         m_stderr_checks.push_back(output_check(oc_empty, false, ""));
917 
918     do {
919         std::auto_ptr< atf::check::check_result > r =
920             m_xflag ? execute_with_shell(m_argv) : execute(m_argv);
921 
922         if ((run_status_checks(m_status_checks, *r) == false) ||
923             (run_output_checks(*r, "stderr") == false) ||
924             (run_output_checks(*r, "stdout") == false))
925             status = EXIT_FAILURE;
926         else
927             status = EXIT_SUCCESS;
928 
929         if (m_rflag && status == EXIT_FAILURE) {
930             if (timo_expired(m_timo))
931                 break;
932             usleep(m_interval);
933         }
934     } while (m_rflag && status == EXIT_FAILURE);
935 
936     return status;
937 }
938 
939 int
940 main(int argc, char* const* argv)
941 {
942     return atf_check().run(argc, argv);
943 }
944