1*00b67f09SDavid van Moolenbroek //
2*00b67f09SDavid van Moolenbroek // Automated Testing Framework (atf)
3*00b67f09SDavid van Moolenbroek //
4*00b67f09SDavid van Moolenbroek // Copyright (c) 2007 The NetBSD Foundation, Inc.
5*00b67f09SDavid van Moolenbroek // All rights reserved.
6*00b67f09SDavid van Moolenbroek //
7*00b67f09SDavid van Moolenbroek // Redistribution and use in source and binary forms, with or without
8*00b67f09SDavid van Moolenbroek // modification, are permitted provided that the following conditions
9*00b67f09SDavid van Moolenbroek // are met:
10*00b67f09SDavid van Moolenbroek // 1. Redistributions of source code must retain the above copyright
11*00b67f09SDavid van Moolenbroek // notice, this list of conditions and the following disclaimer.
12*00b67f09SDavid van Moolenbroek // 2. Redistributions in binary form must reproduce the above copyright
13*00b67f09SDavid van Moolenbroek // notice, this list of conditions and the following disclaimer in the
14*00b67f09SDavid van Moolenbroek // documentation and/or other materials provided with the distribution.
15*00b67f09SDavid van Moolenbroek //
16*00b67f09SDavid van Moolenbroek // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17*00b67f09SDavid van Moolenbroek // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18*00b67f09SDavid van Moolenbroek // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19*00b67f09SDavid van Moolenbroek // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20*00b67f09SDavid van Moolenbroek // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21*00b67f09SDavid van Moolenbroek // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22*00b67f09SDavid van Moolenbroek // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23*00b67f09SDavid van Moolenbroek // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24*00b67f09SDavid van Moolenbroek // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25*00b67f09SDavid van Moolenbroek // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26*00b67f09SDavid van Moolenbroek // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27*00b67f09SDavid van Moolenbroek // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28*00b67f09SDavid van Moolenbroek //
29*00b67f09SDavid van Moolenbroek
30*00b67f09SDavid van Moolenbroek extern "C" {
31*00b67f09SDavid van Moolenbroek #include <sys/time.h>
32*00b67f09SDavid van Moolenbroek }
33*00b67f09SDavid van Moolenbroek
34*00b67f09SDavid van Moolenbroek #include <cctype>
35*00b67f09SDavid van Moolenbroek #include <cstdlib>
36*00b67f09SDavid van Moolenbroek #include <fstream>
37*00b67f09SDavid van Moolenbroek #include <iomanip>
38*00b67f09SDavid van Moolenbroek #include <iostream>
39*00b67f09SDavid van Moolenbroek #include <memory>
40*00b67f09SDavid van Moolenbroek #include <sstream>
41*00b67f09SDavid van Moolenbroek #include <utility>
42*00b67f09SDavid van Moolenbroek #include <vector>
43*00b67f09SDavid van Moolenbroek
44*00b67f09SDavid van Moolenbroek #include "atf-c/defs.h"
45*00b67f09SDavid van Moolenbroek
46*00b67f09SDavid van Moolenbroek #include "atf-c++/detail/application.hpp"
47*00b67f09SDavid van Moolenbroek #include "atf-c++/detail/fs.hpp"
48*00b67f09SDavid van Moolenbroek #include "atf-c++/detail/sanity.hpp"
49*00b67f09SDavid van Moolenbroek #include "atf-c++/detail/text.hpp"
50*00b67f09SDavid van Moolenbroek #include "atf-c++/detail/ui.hpp"
51*00b67f09SDavid van Moolenbroek
52*00b67f09SDavid van Moolenbroek #include "reader.hpp"
53*00b67f09SDavid van Moolenbroek
54*00b67f09SDavid van Moolenbroek typedef std::auto_ptr< std::ostream > ostream_ptr;
55*00b67f09SDavid van Moolenbroek
56*00b67f09SDavid van Moolenbroek static ostream_ptr
open_outfile(const atf::fs::path & path)57*00b67f09SDavid van Moolenbroek open_outfile(const atf::fs::path& path)
58*00b67f09SDavid van Moolenbroek {
59*00b67f09SDavid van Moolenbroek ostream_ptr osp;
60*00b67f09SDavid van Moolenbroek if (path.str() == "-")
61*00b67f09SDavid van Moolenbroek osp = ostream_ptr(new std::ofstream("/dev/stdout"));
62*00b67f09SDavid van Moolenbroek else
63*00b67f09SDavid van Moolenbroek osp = ostream_ptr(new std::ofstream(path.c_str()));
64*00b67f09SDavid van Moolenbroek if (!(*osp))
65*00b67f09SDavid van Moolenbroek throw std::runtime_error("Could not create file " + path.str());
66*00b67f09SDavid van Moolenbroek return osp;
67*00b67f09SDavid van Moolenbroek }
68*00b67f09SDavid van Moolenbroek
69*00b67f09SDavid van Moolenbroek static std::string
format_tv(struct timeval * tv)70*00b67f09SDavid van Moolenbroek format_tv(struct timeval* tv)
71*00b67f09SDavid van Moolenbroek {
72*00b67f09SDavid van Moolenbroek std::ostringstream output;
73*00b67f09SDavid van Moolenbroek output << static_cast< long >(tv->tv_sec) << '.'
74*00b67f09SDavid van Moolenbroek << std::setfill('0') << std::setw(6)
75*00b67f09SDavid van Moolenbroek << static_cast< long >(tv->tv_usec);
76*00b67f09SDavid van Moolenbroek return output.str();
77*00b67f09SDavid van Moolenbroek }
78*00b67f09SDavid van Moolenbroek
79*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
80*00b67f09SDavid van Moolenbroek // The "writer" interface.
81*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
82*00b67f09SDavid van Moolenbroek
83*00b67f09SDavid van Moolenbroek //!
84*00b67f09SDavid van Moolenbroek //! \brief A base class that defines an output format.
85*00b67f09SDavid van Moolenbroek //!
86*00b67f09SDavid van Moolenbroek //! The writer base class defines a generic interface to output formats.
87*00b67f09SDavid van Moolenbroek //! This is meant to be subclassed, and each subclass can redefine any
88*00b67f09SDavid van Moolenbroek //! method to format the information as it wishes.
89*00b67f09SDavid van Moolenbroek //!
90*00b67f09SDavid van Moolenbroek //! This class is not tied to a output stream nor a file because, depending
91*00b67f09SDavid van Moolenbroek //! on the output format, we will want to write to a single file or to
92*00b67f09SDavid van Moolenbroek //! multiple ones.
93*00b67f09SDavid van Moolenbroek //!
94*00b67f09SDavid van Moolenbroek class writer {
95*00b67f09SDavid van Moolenbroek public:
writer(void)96*00b67f09SDavid van Moolenbroek writer(void) {}
~writer(void)97*00b67f09SDavid van Moolenbroek virtual ~writer(void) {}
98*00b67f09SDavid van Moolenbroek
write_info(const std::string &,const std::string &)99*00b67f09SDavid van Moolenbroek virtual void write_info(const std::string&, const std::string&) {}
write_ntps(size_t)100*00b67f09SDavid van Moolenbroek virtual void write_ntps(size_t) {}
write_tp_start(const std::string &,size_t)101*00b67f09SDavid van Moolenbroek virtual void write_tp_start(const std::string&, size_t) {}
write_tp_end(struct timeval *,const std::string &)102*00b67f09SDavid van Moolenbroek virtual void write_tp_end(struct timeval*, const std::string&) {}
write_tc_start(const std::string &)103*00b67f09SDavid van Moolenbroek virtual void write_tc_start(const std::string&) {}
write_tc_stdout_line(const std::string &)104*00b67f09SDavid van Moolenbroek virtual void write_tc_stdout_line(const std::string&) {}
write_tc_stderr_line(const std::string &)105*00b67f09SDavid van Moolenbroek virtual void write_tc_stderr_line(const std::string&) {}
write_tc_end(const std::string &,struct timeval *,const std::string &)106*00b67f09SDavid van Moolenbroek virtual void write_tc_end(const std::string&, struct timeval*,
107*00b67f09SDavid van Moolenbroek const std::string&) {}
write_eof(void)108*00b67f09SDavid van Moolenbroek virtual void write_eof(void) {}
109*00b67f09SDavid van Moolenbroek };
110*00b67f09SDavid van Moolenbroek
111*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
112*00b67f09SDavid van Moolenbroek // The "csv_writer" class.
113*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
114*00b67f09SDavid van Moolenbroek
115*00b67f09SDavid van Moolenbroek //!
116*00b67f09SDavid van Moolenbroek //! \brief A very simple plain-text output format.
117*00b67f09SDavid van Moolenbroek //!
118*00b67f09SDavid van Moolenbroek //! The csv_writer class implements a very simple plain-text output
119*00b67f09SDavid van Moolenbroek //! format that summarizes the results of each executed test case. The
120*00b67f09SDavid van Moolenbroek //! results are meant to be easily parseable by third-party tools, hence
121*00b67f09SDavid van Moolenbroek //! they are formatted as a CSV file.
122*00b67f09SDavid van Moolenbroek //!
123*00b67f09SDavid van Moolenbroek class csv_writer : public writer {
124*00b67f09SDavid van Moolenbroek ostream_ptr m_os;
125*00b67f09SDavid van Moolenbroek bool m_failed;
126*00b67f09SDavid van Moolenbroek
127*00b67f09SDavid van Moolenbroek std::string m_tpname;
128*00b67f09SDavid van Moolenbroek std::string m_tcname;
129*00b67f09SDavid van Moolenbroek
130*00b67f09SDavid van Moolenbroek public:
csv_writer(const atf::fs::path & p)131*00b67f09SDavid van Moolenbroek csv_writer(const atf::fs::path& p) :
132*00b67f09SDavid van Moolenbroek m_os(open_outfile(p))
133*00b67f09SDavid van Moolenbroek {
134*00b67f09SDavid van Moolenbroek }
135*00b67f09SDavid van Moolenbroek
136*00b67f09SDavid van Moolenbroek virtual
137*00b67f09SDavid van Moolenbroek void
write_tp_start(const std::string & name,size_t ntcs ATF_DEFS_ATTRIBUTE_UNUSED)138*00b67f09SDavid van Moolenbroek write_tp_start(const std::string& name,
139*00b67f09SDavid van Moolenbroek size_t ntcs ATF_DEFS_ATTRIBUTE_UNUSED)
140*00b67f09SDavid van Moolenbroek {
141*00b67f09SDavid van Moolenbroek m_tpname = name;
142*00b67f09SDavid van Moolenbroek m_failed = false;
143*00b67f09SDavid van Moolenbroek }
144*00b67f09SDavid van Moolenbroek
145*00b67f09SDavid van Moolenbroek virtual
146*00b67f09SDavid van Moolenbroek void
write_tp_end(struct timeval * tv,const std::string & reason)147*00b67f09SDavid van Moolenbroek write_tp_end(struct timeval* tv, const std::string& reason)
148*00b67f09SDavid van Moolenbroek {
149*00b67f09SDavid van Moolenbroek const std::string timestamp = format_tv(tv);
150*00b67f09SDavid van Moolenbroek
151*00b67f09SDavid van Moolenbroek if (!reason.empty())
152*00b67f09SDavid van Moolenbroek (*m_os) << "tp, " << timestamp << ", " << m_tpname << ", bogus, "
153*00b67f09SDavid van Moolenbroek << reason << "\n";
154*00b67f09SDavid van Moolenbroek else if (m_failed)
155*00b67f09SDavid van Moolenbroek (*m_os) << "tp, " << timestamp << ", "<< m_tpname << ", failed\n";
156*00b67f09SDavid van Moolenbroek else
157*00b67f09SDavid van Moolenbroek (*m_os) << "tp, " << timestamp << ", "<< m_tpname << ", passed\n";
158*00b67f09SDavid van Moolenbroek }
159*00b67f09SDavid van Moolenbroek
160*00b67f09SDavid van Moolenbroek virtual
161*00b67f09SDavid van Moolenbroek void
write_tc_start(const std::string & name)162*00b67f09SDavid van Moolenbroek write_tc_start(const std::string& name)
163*00b67f09SDavid van Moolenbroek {
164*00b67f09SDavid van Moolenbroek m_tcname = name;
165*00b67f09SDavid van Moolenbroek }
166*00b67f09SDavid van Moolenbroek
167*00b67f09SDavid van Moolenbroek virtual
168*00b67f09SDavid van Moolenbroek void
write_tc_end(const std::string & state,struct timeval * tv,const std::string & reason)169*00b67f09SDavid van Moolenbroek write_tc_end(const std::string& state, struct timeval* tv,
170*00b67f09SDavid van Moolenbroek const std::string& reason)
171*00b67f09SDavid van Moolenbroek {
172*00b67f09SDavid van Moolenbroek std::string str = m_tpname + ", " + m_tcname + ", " + state;
173*00b67f09SDavid van Moolenbroek if (!reason.empty())
174*00b67f09SDavid van Moolenbroek str += ", " + reason;
175*00b67f09SDavid van Moolenbroek (*m_os) << "tc, " << format_tv(tv) << ", " << str << "\n";
176*00b67f09SDavid van Moolenbroek
177*00b67f09SDavid van Moolenbroek if (state == "failed")
178*00b67f09SDavid van Moolenbroek m_failed = true;
179*00b67f09SDavid van Moolenbroek }
180*00b67f09SDavid van Moolenbroek };
181*00b67f09SDavid van Moolenbroek
182*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
183*00b67f09SDavid van Moolenbroek // The "ticker_writer" class.
184*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
185*00b67f09SDavid van Moolenbroek
186*00b67f09SDavid van Moolenbroek //!
187*00b67f09SDavid van Moolenbroek //! \brief A console-friendly output format.
188*00b67f09SDavid van Moolenbroek //!
189*00b67f09SDavid van Moolenbroek //! The ticker_writer class implements a formatter that is user-friendly
190*00b67f09SDavid van Moolenbroek //! in the sense that it shows the execution of test cases in an easy to
191*00b67f09SDavid van Moolenbroek //! read format. It is not meant to be parseable and its format can
192*00b67f09SDavid van Moolenbroek //! freely change across releases.
193*00b67f09SDavid van Moolenbroek //!
194*00b67f09SDavid van Moolenbroek class ticker_writer : public writer {
195*00b67f09SDavid van Moolenbroek ostream_ptr m_os;
196*00b67f09SDavid van Moolenbroek
197*00b67f09SDavid van Moolenbroek size_t m_curtp, m_ntps;
198*00b67f09SDavid van Moolenbroek size_t m_tcs_passed, m_tcs_failed, m_tcs_skipped, m_tcs_expected_failures;
199*00b67f09SDavid van Moolenbroek std::string m_tcname, m_tpname;
200*00b67f09SDavid van Moolenbroek std::vector< std::string > m_failed_tcs;
201*00b67f09SDavid van Moolenbroek std::map< std::string, std::string > m_expected_failures_tcs;
202*00b67f09SDavid van Moolenbroek std::vector< std::string > m_failed_tps;
203*00b67f09SDavid van Moolenbroek
204*00b67f09SDavid van Moolenbroek void
write_info(const std::string & what,const std::string & val)205*00b67f09SDavid van Moolenbroek write_info(const std::string& what, const std::string& val)
206*00b67f09SDavid van Moolenbroek {
207*00b67f09SDavid van Moolenbroek if (what == "tests.root") {
208*00b67f09SDavid van Moolenbroek (*m_os) << "Tests root: " << val << "\n\n";
209*00b67f09SDavid van Moolenbroek }
210*00b67f09SDavid van Moolenbroek }
211*00b67f09SDavid van Moolenbroek
212*00b67f09SDavid van Moolenbroek void
write_ntps(size_t ntps)213*00b67f09SDavid van Moolenbroek write_ntps(size_t ntps)
214*00b67f09SDavid van Moolenbroek {
215*00b67f09SDavid van Moolenbroek m_curtp = 1;
216*00b67f09SDavid van Moolenbroek m_tcs_passed = 0;
217*00b67f09SDavid van Moolenbroek m_tcs_failed = 0;
218*00b67f09SDavid van Moolenbroek m_tcs_skipped = 0;
219*00b67f09SDavid van Moolenbroek m_tcs_expected_failures = 0;
220*00b67f09SDavid van Moolenbroek m_ntps = ntps;
221*00b67f09SDavid van Moolenbroek }
222*00b67f09SDavid van Moolenbroek
223*00b67f09SDavid van Moolenbroek void
write_tp_start(const std::string & tp,size_t ntcs)224*00b67f09SDavid van Moolenbroek write_tp_start(const std::string& tp, size_t ntcs)
225*00b67f09SDavid van Moolenbroek {
226*00b67f09SDavid van Moolenbroek using atf::text::to_string;
227*00b67f09SDavid van Moolenbroek using atf::ui::format_text;
228*00b67f09SDavid van Moolenbroek
229*00b67f09SDavid van Moolenbroek m_tpname = tp;
230*00b67f09SDavid van Moolenbroek
231*00b67f09SDavid van Moolenbroek (*m_os) << format_text(tp + " (" + to_string(m_curtp) +
232*00b67f09SDavid van Moolenbroek "/" + to_string(m_ntps) + "): " +
233*00b67f09SDavid van Moolenbroek to_string(ntcs) + " test cases")
234*00b67f09SDavid van Moolenbroek << "\n";
235*00b67f09SDavid van Moolenbroek (*m_os).flush();
236*00b67f09SDavid van Moolenbroek }
237*00b67f09SDavid van Moolenbroek
238*00b67f09SDavid van Moolenbroek void
write_tp_end(struct timeval * tv,const std::string & reason)239*00b67f09SDavid van Moolenbroek write_tp_end(struct timeval* tv, const std::string& reason)
240*00b67f09SDavid van Moolenbroek {
241*00b67f09SDavid van Moolenbroek using atf::ui::format_text_with_tag;
242*00b67f09SDavid van Moolenbroek
243*00b67f09SDavid van Moolenbroek m_curtp++;
244*00b67f09SDavid van Moolenbroek
245*00b67f09SDavid van Moolenbroek if (!reason.empty()) {
246*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag("BOGUS TEST PROGRAM: Cannot "
247*00b67f09SDavid van Moolenbroek "trust its results because "
248*00b67f09SDavid van Moolenbroek "of `" + reason + "'",
249*00b67f09SDavid van Moolenbroek m_tpname + ": ", false)
250*00b67f09SDavid van Moolenbroek << "\n";
251*00b67f09SDavid van Moolenbroek m_failed_tps.push_back(m_tpname);
252*00b67f09SDavid van Moolenbroek }
253*00b67f09SDavid van Moolenbroek (*m_os) << "[" << format_tv(tv) << "s]\n\n";
254*00b67f09SDavid van Moolenbroek (*m_os).flush();
255*00b67f09SDavid van Moolenbroek
256*00b67f09SDavid van Moolenbroek m_tpname.clear();
257*00b67f09SDavid van Moolenbroek }
258*00b67f09SDavid van Moolenbroek
259*00b67f09SDavid van Moolenbroek void
write_tc_start(const std::string & tcname)260*00b67f09SDavid van Moolenbroek write_tc_start(const std::string& tcname)
261*00b67f09SDavid van Moolenbroek {
262*00b67f09SDavid van Moolenbroek m_tcname = tcname;
263*00b67f09SDavid van Moolenbroek
264*00b67f09SDavid van Moolenbroek (*m_os) << " " + tcname + ": ";
265*00b67f09SDavid van Moolenbroek (*m_os).flush();
266*00b67f09SDavid van Moolenbroek }
267*00b67f09SDavid van Moolenbroek
268*00b67f09SDavid van Moolenbroek void
write_tc_end(const std::string & state,struct timeval * tv,const std::string & reason)269*00b67f09SDavid van Moolenbroek write_tc_end(const std::string& state, struct timeval* tv,
270*00b67f09SDavid van Moolenbroek const std::string& reason)
271*00b67f09SDavid van Moolenbroek {
272*00b67f09SDavid van Moolenbroek std::string str;
273*00b67f09SDavid van Moolenbroek
274*00b67f09SDavid van Moolenbroek (*m_os) << "[" << format_tv(tv) << "s] ";
275*00b67f09SDavid van Moolenbroek
276*00b67f09SDavid van Moolenbroek if (state == "expected_death" || state == "expected_exit" ||
277*00b67f09SDavid van Moolenbroek state == "expected_failure" || state == "expected_signal" ||
278*00b67f09SDavid van Moolenbroek state == "expected_timeout") {
279*00b67f09SDavid van Moolenbroek str = "Expected failure: " + reason;
280*00b67f09SDavid van Moolenbroek m_tcs_expected_failures++;
281*00b67f09SDavid van Moolenbroek m_expected_failures_tcs[m_tpname + ":" + m_tcname] = reason;
282*00b67f09SDavid van Moolenbroek } else if (state == "failed") {
283*00b67f09SDavid van Moolenbroek str = "Failed: " + reason;
284*00b67f09SDavid van Moolenbroek m_tcs_failed++;
285*00b67f09SDavid van Moolenbroek m_failed_tcs.push_back(m_tpname + ":" + m_tcname);
286*00b67f09SDavid van Moolenbroek } else if (state == "passed") {
287*00b67f09SDavid van Moolenbroek str = "Passed.";
288*00b67f09SDavid van Moolenbroek m_tcs_passed++;
289*00b67f09SDavid van Moolenbroek } else if (state == "skipped") {
290*00b67f09SDavid van Moolenbroek str = "Skipped: " + reason;
291*00b67f09SDavid van Moolenbroek m_tcs_skipped++;
292*00b67f09SDavid van Moolenbroek } else
293*00b67f09SDavid van Moolenbroek UNREACHABLE;
294*00b67f09SDavid van Moolenbroek
295*00b67f09SDavid van Moolenbroek // XXX Wrap text. format_text_with_tag does not currently allow
296*00b67f09SDavid van Moolenbroek // to specify the current column, which is needed because we have
297*00b67f09SDavid van Moolenbroek // already printed the tc's name.
298*00b67f09SDavid van Moolenbroek (*m_os) << str << '\n';
299*00b67f09SDavid van Moolenbroek
300*00b67f09SDavid van Moolenbroek m_tcname = "";
301*00b67f09SDavid van Moolenbroek }
302*00b67f09SDavid van Moolenbroek
303*00b67f09SDavid van Moolenbroek static void
write_expected_failures(const std::map<std::string,std::string> & xfails,std::ostream & os)304*00b67f09SDavid van Moolenbroek write_expected_failures(const std::map< std::string, std::string >& xfails,
305*00b67f09SDavid van Moolenbroek std::ostream& os)
306*00b67f09SDavid van Moolenbroek {
307*00b67f09SDavid van Moolenbroek using atf::ui::format_text;
308*00b67f09SDavid van Moolenbroek using atf::ui::format_text_with_tag;
309*00b67f09SDavid van Moolenbroek
310*00b67f09SDavid van Moolenbroek os << format_text("Test cases for known bugs:") << "\n";
311*00b67f09SDavid van Moolenbroek
312*00b67f09SDavid van Moolenbroek for (std::map< std::string, std::string >::const_iterator iter =
313*00b67f09SDavid van Moolenbroek xfails.begin(); iter != xfails.end(); iter++) {
314*00b67f09SDavid van Moolenbroek const std::string& name = (*iter).first;
315*00b67f09SDavid van Moolenbroek const std::string& reason = (*iter).second;
316*00b67f09SDavid van Moolenbroek
317*00b67f09SDavid van Moolenbroek os << format_text_with_tag(reason, " " + name + ": ", false)
318*00b67f09SDavid van Moolenbroek << "\n";
319*00b67f09SDavid van Moolenbroek }
320*00b67f09SDavid van Moolenbroek }
321*00b67f09SDavid van Moolenbroek
322*00b67f09SDavid van Moolenbroek void
write_eof(void)323*00b67f09SDavid van Moolenbroek write_eof(void)
324*00b67f09SDavid van Moolenbroek {
325*00b67f09SDavid van Moolenbroek using atf::text::join;
326*00b67f09SDavid van Moolenbroek using atf::text::to_string;
327*00b67f09SDavid van Moolenbroek using atf::ui::format_text;
328*00b67f09SDavid van Moolenbroek using atf::ui::format_text_with_tag;
329*00b67f09SDavid van Moolenbroek
330*00b67f09SDavid van Moolenbroek if (!m_failed_tps.empty()) {
331*00b67f09SDavid van Moolenbroek (*m_os) << format_text("Failed (bogus) test programs:")
332*00b67f09SDavid van Moolenbroek << "\n";
333*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag(join(m_failed_tps, ", "),
334*00b67f09SDavid van Moolenbroek " ", false) << "\n\n";
335*00b67f09SDavid van Moolenbroek }
336*00b67f09SDavid van Moolenbroek
337*00b67f09SDavid van Moolenbroek if (!m_expected_failures_tcs.empty()) {
338*00b67f09SDavid van Moolenbroek write_expected_failures(m_expected_failures_tcs, *m_os);
339*00b67f09SDavid van Moolenbroek (*m_os) << "\n";
340*00b67f09SDavid van Moolenbroek }
341*00b67f09SDavid van Moolenbroek
342*00b67f09SDavid van Moolenbroek if (!m_failed_tcs.empty()) {
343*00b67f09SDavid van Moolenbroek (*m_os) << format_text("Failed test cases:") << "\n";
344*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag(join(m_failed_tcs, ", "),
345*00b67f09SDavid van Moolenbroek " ", false) << "\n\n";
346*00b67f09SDavid van Moolenbroek }
347*00b67f09SDavid van Moolenbroek
348*00b67f09SDavid van Moolenbroek (*m_os) << format_text("Summary for " + to_string(m_ntps) +
349*00b67f09SDavid van Moolenbroek " test programs:") << "\n";
350*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag(to_string(m_tcs_passed) +
351*00b67f09SDavid van Moolenbroek " passed test cases.",
352*00b67f09SDavid van Moolenbroek " ", false) << "\n";
353*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag(to_string(m_tcs_failed) +
354*00b67f09SDavid van Moolenbroek " failed test cases.",
355*00b67f09SDavid van Moolenbroek " ", false) << "\n";
356*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag(to_string(m_tcs_expected_failures) +
357*00b67f09SDavid van Moolenbroek " expected failed test cases.",
358*00b67f09SDavid van Moolenbroek " ", false) << "\n";
359*00b67f09SDavid van Moolenbroek (*m_os) << format_text_with_tag(to_string(m_tcs_skipped) +
360*00b67f09SDavid van Moolenbroek " skipped test cases.",
361*00b67f09SDavid van Moolenbroek " ", false) << "\n";
362*00b67f09SDavid van Moolenbroek }
363*00b67f09SDavid van Moolenbroek
364*00b67f09SDavid van Moolenbroek public:
ticker_writer(const atf::fs::path & p)365*00b67f09SDavid van Moolenbroek ticker_writer(const atf::fs::path& p) :
366*00b67f09SDavid van Moolenbroek m_os(open_outfile(p))
367*00b67f09SDavid van Moolenbroek {
368*00b67f09SDavid van Moolenbroek }
369*00b67f09SDavid van Moolenbroek };
370*00b67f09SDavid van Moolenbroek
371*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
372*00b67f09SDavid van Moolenbroek // The "xml" class.
373*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
374*00b67f09SDavid van Moolenbroek
375*00b67f09SDavid van Moolenbroek //!
376*00b67f09SDavid van Moolenbroek //! \brief A single-file XML output format.
377*00b67f09SDavid van Moolenbroek //!
378*00b67f09SDavid van Moolenbroek //! The xml_writer class implements a formatter that prints the results
379*00b67f09SDavid van Moolenbroek //! of test cases in an XML format easily parseable later on by other
380*00b67f09SDavid van Moolenbroek //! utilities.
381*00b67f09SDavid van Moolenbroek //!
382*00b67f09SDavid van Moolenbroek class xml_writer : public writer {
383*00b67f09SDavid van Moolenbroek ostream_ptr m_os;
384*00b67f09SDavid van Moolenbroek
385*00b67f09SDavid van Moolenbroek std::string m_tcname, m_tpname;
386*00b67f09SDavid van Moolenbroek
387*00b67f09SDavid van Moolenbroek static
388*00b67f09SDavid van Moolenbroek std::string
attrval(const std::string & str)389*00b67f09SDavid van Moolenbroek attrval(const std::string& str)
390*00b67f09SDavid van Moolenbroek {
391*00b67f09SDavid van Moolenbroek return str;
392*00b67f09SDavid van Moolenbroek }
393*00b67f09SDavid van Moolenbroek
394*00b67f09SDavid van Moolenbroek static
395*00b67f09SDavid van Moolenbroek std::string
elemval(const std::string & str)396*00b67f09SDavid van Moolenbroek elemval(const std::string& str)
397*00b67f09SDavid van Moolenbroek {
398*00b67f09SDavid van Moolenbroek std::ostringstream buf;
399*00b67f09SDavid van Moolenbroek for (std::string::const_iterator iter = str.begin();
400*00b67f09SDavid van Moolenbroek iter != str.end(); iter++) {
401*00b67f09SDavid van Moolenbroek const int character = static_cast< unsigned char >(*iter);
402*00b67f09SDavid van Moolenbroek if (character == '&') {
403*00b67f09SDavid van Moolenbroek buf << "&";
404*00b67f09SDavid van Moolenbroek } else if (character == '<') {
405*00b67f09SDavid van Moolenbroek buf << "<";
406*00b67f09SDavid van Moolenbroek } else if (character == '>') {
407*00b67f09SDavid van Moolenbroek buf << ">";
408*00b67f09SDavid van Moolenbroek } else if (std::isalnum(character) || std::ispunct(character) ||
409*00b67f09SDavid van Moolenbroek std::isspace(character)) {
410*00b67f09SDavid van Moolenbroek buf << static_cast< char >(character);
411*00b67f09SDavid van Moolenbroek } else {
412*00b67f09SDavid van Moolenbroek buf << "&#" << character << ";";
413*00b67f09SDavid van Moolenbroek }
414*00b67f09SDavid van Moolenbroek }
415*00b67f09SDavid van Moolenbroek return buf.str();
416*00b67f09SDavid van Moolenbroek }
417*00b67f09SDavid van Moolenbroek
418*00b67f09SDavid van Moolenbroek void
write_info(const std::string & what,const std::string & val)419*00b67f09SDavid van Moolenbroek write_info(const std::string& what, const std::string& val)
420*00b67f09SDavid van Moolenbroek {
421*00b67f09SDavid van Moolenbroek (*m_os) << "<info class=\"" << what << "\">" << val << "</info>\n";
422*00b67f09SDavid van Moolenbroek }
423*00b67f09SDavid van Moolenbroek
424*00b67f09SDavid van Moolenbroek void
write_tp_start(const std::string & tp,size_t ntcs ATF_DEFS_ATTRIBUTE_UNUSED)425*00b67f09SDavid van Moolenbroek write_tp_start(const std::string& tp,
426*00b67f09SDavid van Moolenbroek size_t ntcs ATF_DEFS_ATTRIBUTE_UNUSED)
427*00b67f09SDavid van Moolenbroek {
428*00b67f09SDavid van Moolenbroek (*m_os) << "<tp id=\"" << attrval(tp) << "\">\n";
429*00b67f09SDavid van Moolenbroek }
430*00b67f09SDavid van Moolenbroek
431*00b67f09SDavid van Moolenbroek void
write_tp_end(struct timeval * tv,const std::string & reason)432*00b67f09SDavid van Moolenbroek write_tp_end(struct timeval* tv, const std::string& reason)
433*00b67f09SDavid van Moolenbroek {
434*00b67f09SDavid van Moolenbroek if (!reason.empty())
435*00b67f09SDavid van Moolenbroek (*m_os) << "<failed>" << elemval(reason) << "</failed>\n";
436*00b67f09SDavid van Moolenbroek (*m_os) << "<tp-time>" << format_tv(tv) << "</tp-time>";
437*00b67f09SDavid van Moolenbroek (*m_os) << "</tp>\n";
438*00b67f09SDavid van Moolenbroek }
439*00b67f09SDavid van Moolenbroek
440*00b67f09SDavid van Moolenbroek void
write_tc_start(const std::string & tcname)441*00b67f09SDavid van Moolenbroek write_tc_start(const std::string& tcname)
442*00b67f09SDavid van Moolenbroek {
443*00b67f09SDavid van Moolenbroek (*m_os) << "<tc id=\"" << attrval(tcname) << "\">\n";
444*00b67f09SDavid van Moolenbroek }
445*00b67f09SDavid van Moolenbroek
446*00b67f09SDavid van Moolenbroek void
write_tc_stdout_line(const std::string & line)447*00b67f09SDavid van Moolenbroek write_tc_stdout_line(const std::string& line)
448*00b67f09SDavid van Moolenbroek {
449*00b67f09SDavid van Moolenbroek (*m_os) << "<so>" << elemval(line) << "</so>\n";
450*00b67f09SDavid van Moolenbroek }
451*00b67f09SDavid van Moolenbroek
452*00b67f09SDavid van Moolenbroek void
write_tc_stderr_line(const std::string & line)453*00b67f09SDavid van Moolenbroek write_tc_stderr_line(const std::string& line)
454*00b67f09SDavid van Moolenbroek {
455*00b67f09SDavid van Moolenbroek (*m_os) << "<se>" << elemval(line) << "</se>\n";
456*00b67f09SDavid van Moolenbroek }
457*00b67f09SDavid van Moolenbroek
458*00b67f09SDavid van Moolenbroek void
write_tc_end(const std::string & state,struct timeval * tv,const std::string & reason)459*00b67f09SDavid van Moolenbroek write_tc_end(const std::string& state, struct timeval* tv,
460*00b67f09SDavid van Moolenbroek const std::string& reason)
461*00b67f09SDavid van Moolenbroek {
462*00b67f09SDavid van Moolenbroek std::string str;
463*00b67f09SDavid van Moolenbroek
464*00b67f09SDavid van Moolenbroek if (state == "expected_death" || state == "expected_exit" ||
465*00b67f09SDavid van Moolenbroek state == "expected_failure" || state == "expected_signal" ||
466*00b67f09SDavid van Moolenbroek state == "expected_timeout") {
467*00b67f09SDavid van Moolenbroek (*m_os) << "<" << state << ">" << elemval(reason)
468*00b67f09SDavid van Moolenbroek << "</" << state << ">\n";
469*00b67f09SDavid van Moolenbroek } else if (state == "passed") {
470*00b67f09SDavid van Moolenbroek (*m_os) << "<passed />\n";
471*00b67f09SDavid van Moolenbroek } else if (state == "failed") {
472*00b67f09SDavid van Moolenbroek (*m_os) << "<failed>" << elemval(reason) << "</failed>\n";
473*00b67f09SDavid van Moolenbroek } else if (state == "skipped") {
474*00b67f09SDavid van Moolenbroek (*m_os) << "<skipped>" << elemval(reason) << "</skipped>\n";
475*00b67f09SDavid van Moolenbroek } else
476*00b67f09SDavid van Moolenbroek UNREACHABLE;
477*00b67f09SDavid van Moolenbroek (*m_os) << "<tc-time>" << format_tv(tv) << "</tc-time>";
478*00b67f09SDavid van Moolenbroek (*m_os) << "</tc>\n";
479*00b67f09SDavid van Moolenbroek }
480*00b67f09SDavid van Moolenbroek
481*00b67f09SDavid van Moolenbroek void
write_eof(void)482*00b67f09SDavid van Moolenbroek write_eof(void)
483*00b67f09SDavid van Moolenbroek {
484*00b67f09SDavid van Moolenbroek (*m_os) << "</tests-results>\n";
485*00b67f09SDavid van Moolenbroek }
486*00b67f09SDavid van Moolenbroek
487*00b67f09SDavid van Moolenbroek public:
xml_writer(const atf::fs::path & p)488*00b67f09SDavid van Moolenbroek xml_writer(const atf::fs::path& p) :
489*00b67f09SDavid van Moolenbroek m_os(open_outfile(p))
490*00b67f09SDavid van Moolenbroek {
491*00b67f09SDavid van Moolenbroek (*m_os) << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"
492*00b67f09SDavid van Moolenbroek << "<!DOCTYPE tests-results PUBLIC "
493*00b67f09SDavid van Moolenbroek "\"-//NetBSD//DTD ATF Tests Results 0.1//EN\" "
494*00b67f09SDavid van Moolenbroek "\"http://www.NetBSD.org/XML/atf/tests-results.dtd\">\n\n"
495*00b67f09SDavid van Moolenbroek "<tests-results>\n";
496*00b67f09SDavid van Moolenbroek }
497*00b67f09SDavid van Moolenbroek };
498*00b67f09SDavid van Moolenbroek
499*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
500*00b67f09SDavid van Moolenbroek // The "converter" class.
501*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
502*00b67f09SDavid van Moolenbroek
503*00b67f09SDavid van Moolenbroek //!
504*00b67f09SDavid van Moolenbroek //! \brief A reader that redirects events to multiple writers.
505*00b67f09SDavid van Moolenbroek //!
506*00b67f09SDavid van Moolenbroek //! The converter class implements an atf_tps_reader that, for each event
507*00b67f09SDavid van Moolenbroek //! raised by the parser, redirects it to multiple writers so that they
508*00b67f09SDavid van Moolenbroek //! can reformat it according to their output rules.
509*00b67f09SDavid van Moolenbroek //!
510*00b67f09SDavid van Moolenbroek class converter : public atf::atf_report::atf_tps_reader {
511*00b67f09SDavid van Moolenbroek typedef std::vector< writer* > outs_vector;
512*00b67f09SDavid van Moolenbroek outs_vector m_outs;
513*00b67f09SDavid van Moolenbroek
514*00b67f09SDavid van Moolenbroek void
got_info(const std::string & what,const std::string & val)515*00b67f09SDavid van Moolenbroek got_info(const std::string& what, const std::string& val)
516*00b67f09SDavid van Moolenbroek {
517*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
518*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
519*00b67f09SDavid van Moolenbroek (*iter)->write_info(what, val);
520*00b67f09SDavid van Moolenbroek }
521*00b67f09SDavid van Moolenbroek
522*00b67f09SDavid van Moolenbroek void
got_ntps(size_t ntps)523*00b67f09SDavid van Moolenbroek got_ntps(size_t ntps)
524*00b67f09SDavid van Moolenbroek {
525*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
526*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
527*00b67f09SDavid van Moolenbroek (*iter)->write_ntps(ntps);
528*00b67f09SDavid van Moolenbroek }
529*00b67f09SDavid van Moolenbroek
530*00b67f09SDavid van Moolenbroek void
got_tp_start(const std::string & tp,size_t ntcs)531*00b67f09SDavid van Moolenbroek got_tp_start(const std::string& tp, size_t ntcs)
532*00b67f09SDavid van Moolenbroek {
533*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
534*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
535*00b67f09SDavid van Moolenbroek (*iter)->write_tp_start(tp, ntcs);
536*00b67f09SDavid van Moolenbroek }
537*00b67f09SDavid van Moolenbroek
538*00b67f09SDavid van Moolenbroek void
got_tp_end(struct timeval * tv,const std::string & reason)539*00b67f09SDavid van Moolenbroek got_tp_end(struct timeval* tv, const std::string& reason)
540*00b67f09SDavid van Moolenbroek {
541*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
542*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
543*00b67f09SDavid van Moolenbroek (*iter)->write_tp_end(tv, reason);
544*00b67f09SDavid van Moolenbroek }
545*00b67f09SDavid van Moolenbroek
546*00b67f09SDavid van Moolenbroek void
got_tc_start(const std::string & tcname)547*00b67f09SDavid van Moolenbroek got_tc_start(const std::string& tcname)
548*00b67f09SDavid van Moolenbroek {
549*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
550*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
551*00b67f09SDavid van Moolenbroek (*iter)->write_tc_start(tcname);
552*00b67f09SDavid van Moolenbroek }
553*00b67f09SDavid van Moolenbroek
554*00b67f09SDavid van Moolenbroek void
got_tc_stdout_line(const std::string & line)555*00b67f09SDavid van Moolenbroek got_tc_stdout_line(const std::string& line)
556*00b67f09SDavid van Moolenbroek {
557*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
558*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
559*00b67f09SDavid van Moolenbroek (*iter)->write_tc_stdout_line(line);
560*00b67f09SDavid van Moolenbroek }
561*00b67f09SDavid van Moolenbroek
562*00b67f09SDavid van Moolenbroek void
got_tc_stderr_line(const std::string & line)563*00b67f09SDavid van Moolenbroek got_tc_stderr_line(const std::string& line)
564*00b67f09SDavid van Moolenbroek {
565*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
566*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
567*00b67f09SDavid van Moolenbroek (*iter)->write_tc_stderr_line(line);
568*00b67f09SDavid van Moolenbroek }
569*00b67f09SDavid van Moolenbroek
570*00b67f09SDavid van Moolenbroek void
got_tc_end(const std::string & state,struct timeval * tv,const std::string & reason)571*00b67f09SDavid van Moolenbroek got_tc_end(const std::string& state, struct timeval* tv,
572*00b67f09SDavid van Moolenbroek const std::string& reason)
573*00b67f09SDavid van Moolenbroek {
574*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
575*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
576*00b67f09SDavid van Moolenbroek (*iter)->write_tc_end(state, tv, reason);
577*00b67f09SDavid van Moolenbroek }
578*00b67f09SDavid van Moolenbroek
579*00b67f09SDavid van Moolenbroek void
got_eof(void)580*00b67f09SDavid van Moolenbroek got_eof(void)
581*00b67f09SDavid van Moolenbroek {
582*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
583*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
584*00b67f09SDavid van Moolenbroek (*iter)->write_eof();
585*00b67f09SDavid van Moolenbroek }
586*00b67f09SDavid van Moolenbroek
587*00b67f09SDavid van Moolenbroek public:
converter(std::istream & is)588*00b67f09SDavid van Moolenbroek converter(std::istream& is) :
589*00b67f09SDavid van Moolenbroek atf::atf_report::atf_tps_reader(is)
590*00b67f09SDavid van Moolenbroek {
591*00b67f09SDavid van Moolenbroek }
592*00b67f09SDavid van Moolenbroek
~converter(void)593*00b67f09SDavid van Moolenbroek ~converter(void)
594*00b67f09SDavid van Moolenbroek {
595*00b67f09SDavid van Moolenbroek for (outs_vector::iterator iter = m_outs.begin();
596*00b67f09SDavid van Moolenbroek iter != m_outs.end(); iter++)
597*00b67f09SDavid van Moolenbroek delete *iter;
598*00b67f09SDavid van Moolenbroek }
599*00b67f09SDavid van Moolenbroek
600*00b67f09SDavid van Moolenbroek void
add_output(const std::string & fmt,const atf::fs::path & p)601*00b67f09SDavid van Moolenbroek add_output(const std::string& fmt, const atf::fs::path& p)
602*00b67f09SDavid van Moolenbroek {
603*00b67f09SDavid van Moolenbroek if (fmt == "csv") {
604*00b67f09SDavid van Moolenbroek m_outs.push_back(new csv_writer(p));
605*00b67f09SDavid van Moolenbroek } else if (fmt == "ticker") {
606*00b67f09SDavid van Moolenbroek m_outs.push_back(new ticker_writer(p));
607*00b67f09SDavid van Moolenbroek } else if (fmt == "xml") {
608*00b67f09SDavid van Moolenbroek m_outs.push_back(new xml_writer(p));
609*00b67f09SDavid van Moolenbroek } else
610*00b67f09SDavid van Moolenbroek throw std::runtime_error("Unknown format `" + fmt + "'");
611*00b67f09SDavid van Moolenbroek }
612*00b67f09SDavid van Moolenbroek };
613*00b67f09SDavid van Moolenbroek
614*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
615*00b67f09SDavid van Moolenbroek // The "atf_report" class.
616*00b67f09SDavid van Moolenbroek // ------------------------------------------------------------------------
617*00b67f09SDavid van Moolenbroek
618*00b67f09SDavid van Moolenbroek class atf_report : public atf::application::app {
619*00b67f09SDavid van Moolenbroek static const char* m_description;
620*00b67f09SDavid van Moolenbroek
621*00b67f09SDavid van Moolenbroek typedef std::pair< std::string, atf::fs::path > fmt_path_pair;
622*00b67f09SDavid van Moolenbroek std::vector< fmt_path_pair > m_oflags;
623*00b67f09SDavid van Moolenbroek
624*00b67f09SDavid van Moolenbroek void process_option(int, const char*);
625*00b67f09SDavid van Moolenbroek options_set specific_options(void) const;
626*00b67f09SDavid van Moolenbroek
627*00b67f09SDavid van Moolenbroek public:
628*00b67f09SDavid van Moolenbroek atf_report(void);
629*00b67f09SDavid van Moolenbroek
630*00b67f09SDavid van Moolenbroek int main(void);
631*00b67f09SDavid van Moolenbroek };
632*00b67f09SDavid van Moolenbroek
633*00b67f09SDavid van Moolenbroek const char* atf_report::m_description =
634*00b67f09SDavid van Moolenbroek "atf-report is a tool that parses the output of atf-run and "
635*00b67f09SDavid van Moolenbroek "generates user-friendly reports in multiple different formats.";
636*00b67f09SDavid van Moolenbroek
atf_report(void)637*00b67f09SDavid van Moolenbroek atf_report::atf_report(void) :
638*00b67f09SDavid van Moolenbroek app(m_description, "atf-report(1)", "atf(7)")
639*00b67f09SDavid van Moolenbroek {
640*00b67f09SDavid van Moolenbroek }
641*00b67f09SDavid van Moolenbroek
642*00b67f09SDavid van Moolenbroek void
process_option(int ch,const char * arg)643*00b67f09SDavid van Moolenbroek atf_report::process_option(int ch, const char* arg)
644*00b67f09SDavid van Moolenbroek {
645*00b67f09SDavid van Moolenbroek switch (ch) {
646*00b67f09SDavid van Moolenbroek case 'o':
647*00b67f09SDavid van Moolenbroek {
648*00b67f09SDavid van Moolenbroek std::string str(arg);
649*00b67f09SDavid van Moolenbroek std::string::size_type pos = str.find(':');
650*00b67f09SDavid van Moolenbroek if (pos == std::string::npos)
651*00b67f09SDavid van Moolenbroek throw std::runtime_error("Syntax error in -o option");
652*00b67f09SDavid van Moolenbroek else {
653*00b67f09SDavid van Moolenbroek std::string fmt = str.substr(0, pos);
654*00b67f09SDavid van Moolenbroek atf::fs::path path = atf::fs::path(str.substr(pos + 1));
655*00b67f09SDavid van Moolenbroek m_oflags.push_back(fmt_path_pair(fmt, path));
656*00b67f09SDavid van Moolenbroek }
657*00b67f09SDavid van Moolenbroek }
658*00b67f09SDavid van Moolenbroek break;
659*00b67f09SDavid van Moolenbroek
660*00b67f09SDavid van Moolenbroek default:
661*00b67f09SDavid van Moolenbroek UNREACHABLE;
662*00b67f09SDavid van Moolenbroek }
663*00b67f09SDavid van Moolenbroek }
664*00b67f09SDavid van Moolenbroek
665*00b67f09SDavid van Moolenbroek atf_report::options_set
specific_options(void) const666*00b67f09SDavid van Moolenbroek atf_report::specific_options(void)
667*00b67f09SDavid van Moolenbroek const
668*00b67f09SDavid van Moolenbroek {
669*00b67f09SDavid van Moolenbroek using atf::application::option;
670*00b67f09SDavid van Moolenbroek options_set opts;
671*00b67f09SDavid van Moolenbroek opts.insert(option('o', "fmt:path", "Adds a new output file; multiple "
672*00b67f09SDavid van Moolenbroek "ones can be specified, and a - "
673*00b67f09SDavid van Moolenbroek "path means stdout"));
674*00b67f09SDavid van Moolenbroek return opts;
675*00b67f09SDavid van Moolenbroek }
676*00b67f09SDavid van Moolenbroek
677*00b67f09SDavid van Moolenbroek int
main(void)678*00b67f09SDavid van Moolenbroek atf_report::main(void)
679*00b67f09SDavid van Moolenbroek {
680*00b67f09SDavid van Moolenbroek if (m_argc > 0)
681*00b67f09SDavid van Moolenbroek throw std::runtime_error("No arguments allowed");
682*00b67f09SDavid van Moolenbroek
683*00b67f09SDavid van Moolenbroek if (m_oflags.empty())
684*00b67f09SDavid van Moolenbroek m_oflags.push_back(fmt_path_pair("ticker", atf::fs::path("-")));
685*00b67f09SDavid van Moolenbroek
686*00b67f09SDavid van Moolenbroek // Look for path duplicates.
687*00b67f09SDavid van Moolenbroek std::set< atf::fs::path > paths;
688*00b67f09SDavid van Moolenbroek for (std::vector< fmt_path_pair >::const_iterator iter = m_oflags.begin();
689*00b67f09SDavid van Moolenbroek iter != m_oflags.end(); iter++) {
690*00b67f09SDavid van Moolenbroek atf::fs::path p = (*iter).second;
691*00b67f09SDavid van Moolenbroek if (p == atf::fs::path("/dev/stdout"))
692*00b67f09SDavid van Moolenbroek p = atf::fs::path("-");
693*00b67f09SDavid van Moolenbroek if (paths.find(p) != paths.end())
694*00b67f09SDavid van Moolenbroek throw std::runtime_error("The file `" + p.str() + "' was "
695*00b67f09SDavid van Moolenbroek "specified more than once");
696*00b67f09SDavid van Moolenbroek paths.insert((*iter).second);
697*00b67f09SDavid van Moolenbroek }
698*00b67f09SDavid van Moolenbroek
699*00b67f09SDavid van Moolenbroek // Generate the output files.
700*00b67f09SDavid van Moolenbroek converter cnv(std::cin);
701*00b67f09SDavid van Moolenbroek for (std::vector< fmt_path_pair >::const_iterator iter = m_oflags.begin();
702*00b67f09SDavid van Moolenbroek iter != m_oflags.end(); iter++)
703*00b67f09SDavid van Moolenbroek cnv.add_output((*iter).first, (*iter).second);
704*00b67f09SDavid van Moolenbroek cnv.read();
705*00b67f09SDavid van Moolenbroek
706*00b67f09SDavid van Moolenbroek return EXIT_SUCCESS;
707*00b67f09SDavid van Moolenbroek }
708*00b67f09SDavid van Moolenbroek
709*00b67f09SDavid van Moolenbroek int
main(int argc,char * const * argv)710*00b67f09SDavid van Moolenbroek main(int argc, char* const* argv)
711*00b67f09SDavid van Moolenbroek {
712*00b67f09SDavid van Moolenbroek return atf_report().run(argc, argv);
713*00b67f09SDavid van Moolenbroek }
714