head 1.2; access; symbols perseant-exfatfs-base-20250801:1.2 perseant-exfatfs-base-20240630:1.2 perseant-exfatfs:1.2.0.24 perseant-exfatfs-base:1.2 cjep_sun2x:1.2.0.22 cjep_sun2x-base:1.2 cjep_staticlib_x-base1:1.2 cjep_staticlib_x:1.2.0.20 cjep_staticlib_x-base:1.2 phil-wifi-20200421:1.2 phil-wifi-20200411:1.2 phil-wifi-20200406:1.2 pgoyette-compat-merge-20190127:1.2 pgoyette-compat-20190127:1.2 pgoyette-compat-20190118:1.2 pgoyette-compat-1226:1.2 pgoyette-compat-1126:1.2 pgoyette-compat-1020:1.2 pgoyette-compat-0930:1.2 pgoyette-compat-0906:1.2 pgoyette-compat-0728:1.2 pgoyette-compat-0625:1.2 pgoyette-compat-0521:1.2 pgoyette-compat-0502:1.2 pgoyette-compat-0422:1.2 pgoyette-compat-0415:1.2 pgoyette-compat-0407:1.2 pgoyette-compat-0330:1.2 pgoyette-compat-0322:1.2 pgoyette-compat-0315:1.2 pgoyette-compat:1.2.0.18 pgoyette-compat-base:1.2 prg-localcount2-base3:1.2 prg-localcount2-base2:1.2 prg-localcount2-base1:1.2 prg-localcount2:1.2.0.16 prg-localcount2-base:1.2 pgoyette-localcount-20170426:1.2 bouyer-socketcan-base1:1.2 pgoyette-localcount-20170320:1.2 bouyer-socketcan:1.2.0.14 bouyer-socketcan-base:1.2 pgoyette-localcount-20170107:1.2 pgoyette-localcount-20161104:1.2 localcount-20160914:1.2 pgoyette-localcount-20160806:1.2 pgoyette-localcount-20160726:1.2 pgoyette-localcount:1.2.0.12 pgoyette-localcount-base:1.2 netbsd-5-2-3-RELEASE:1.1.1.3 netbsd-5-1-5-RELEASE:1.1.1.3 yamt-pagecache-base9:1.2 yamt-pagecache-tag8:1.2 tls-earlyentropy:1.2.0.8 tls-earlyentropy-base:1.2 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.2 riastradh-drm2-base3:1.2 netbsd-5-2-2-RELEASE:1.1.1.3 netbsd-5-1-4-RELEASE:1.1.1.3 netbsd-5-2-1-RELEASE:1.1.1.3 netbsd-5-1-3-RELEASE:1.1.1.3 agc-symver:1.2.0.10 agc-symver-base:1.2 tls-maxphys-base:1.2 yamt-pagecache-base8:1.2 netbsd-5-2:1.1.1.3.0.4 yamt-pagecache-base7:1.2 netbsd-5-2-RELEASE:1.1.1.3 netbsd-5-2-RC1:1.1.1.3 yamt-pagecache-base6:1.2 yamt-pagecache-base5:1.2 yamt-pagecache-base4:1.2 netbsd-5-1-2-RELEASE:1.1.1.3 netbsd-5-1-1-RELEASE:1.1.1.3 yamt-pagecache-base3:1.2 yamt-pagecache-base2:1.2 yamt-pagecache:1.2.0.6 yamt-pagecache-base:1.2 bouyer-quota2-nbase:1.2 bouyer-quota2:1.2.0.4 bouyer-quota2-base:1.2 matt-nb5-mips64-premerge-20101231:1.1.1.3 matt-nb5-pq3:1.1.1.3.0.14 matt-nb5-pq3-base:1.1.1.3 netbsd-5-1:1.1.1.3.0.12 netbsd-5-1-RELEASE:1.1.1.3 netbsd-5-1-RC4:1.1.1.3 matt-nb5-mips64-k15:1.1.1.3 netbsd-5-1-RC3:1.1.1.3 netbsd-5-1-RC2:1.1.1.3 netbsd-5-1-RC1:1.1.1.3 netbsd-5-0-2-RELEASE:1.1.1.3 matt-nb5-mips64-premerge-20091211:1.1.1.3 matt-nb5-mips64-u2-k2-k4-k7-k8-k9:1.1.1.3 matt-nb4-mips64-k7-u2a-k9b:1.1.1.3 matt-nb5-mips64-u1-k1-k5:1.1.1.3 matt-nb5-mips64:1.1.1.3.0.10 netbsd-5-0-1-RELEASE:1.1.1.3 jym-xensuspend-nbase:1.2 netbsd-5-0:1.1.1.3.0.8 netbsd-5-0-RELEASE:1.1.1.3 netbsd-5-0-RC4:1.1.1.3 netbsd-5-0-RC3:1.1.1.3 netbsd-5-0-RC2:1.1.1.3 jym-xensuspend:1.2.0.2 jym-xensuspend-base:1.2 netbsd-5-0-RC1:1.1.1.3 netbsd-5:1.1.1.3.0.6 netbsd-5-base:1.1.1.3 matt-mips64-base2:1.1.1.3 wrstuden-revivesa-base-3:1.1.1.3 wrstuden-revivesa-base-2:1.1.1.3 wrstuden-revivesa-base-1:1.1.1.3 yamt-pf42-base4:1.1.1.3 yamt-pf42-base3:1.1.1.3 hpcarm-cleanup-nbase:1.1.1.3 yamt-pf42-baseX:1.1.1.2 yamt-pf42-base2:1.1.1.3 wrstuden-revivesa:1.1.1.3.0.2 wrstuden-revivesa-base:1.1.1.3 atf-0-5:1.1.1.3 yamt-pf42:1.1.1.2.0.4 yamt-pf42-base:1.1.1.2 hpcarm-cleanup-base:1.1.1.2 keiichi-mipv6:1.1.1.2.0.2 keiichi-mipv6-base:1.1.1.2 atf-0-4:1.1.1.2 matt-armv6-base:1.1.1.1 matt-armv6:1.1.1.1.0.4 matt-armv6-nbase:1.1.1.2 cube-autoconf:1.1.1.1.0.2 cube-autoconf-base:1.1.1.1 atf-0-3:1.1.1.1 TNF:1.1.1; locks; strict; comment @// @; 1.2 date 2009.01.19.07.08.27; author jmmv; state dead; branches; next 1.1; 1.1 date 2007.11.12.14.50.58; author jmmv; state Exp; branches 1.1.1.1; next ; 1.1.1.1 date 2007.11.12.14.50.58; author jmmv; state Exp; branches 1.1.1.1.4.1; next 1.1.1.2; 1.1.1.2 date 2008.02.04.20.22.06; author jmmv; state Exp; branches 1.1.1.2.4.1; next 1.1.1.3; 1.1.1.3 date 2008.05.01.15.22.35; author jmmv; state Exp; branches; next ; 1.1.1.1.4.1 date 2007.11.12.14.50.58; author matt; state dead; branches; next 1.1.1.1.4.2; 1.1.1.1.4.2 date 2008.01.09.01.26.04; author matt; state Exp; branches; next 1.1.1.1.4.3; 1.1.1.1.4.3 date 2008.03.23.00.16.58; author matt; state Exp; branches; next ; 1.1.1.2.4.1 date 2008.05.18.12.29.17; author yamt; state Exp; branches; next ; desc @@ 1.2 log @Remove ATF 0.5 from dist/atf and all of the reachover Makefiles used to build it. 0.6 is going to be imported in external/bsd/atf, with all the necessary Makefiles in that same hierarchy. @ text @// // Automated Testing Framework (atf) // // Copyright (c) 2007 The NetBSD Foundation, Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // 1. Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // 2. Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // 3. All advertising materials mentioning features or use of this // software must display the following acknowledgement: // This product includes software developed by the NetBSD // Foundation, Inc. and its contributors. // 4. Neither the name of The NetBSD Foundation nor the names of its // contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // #include #include #include #include #include #include "atf/application.hpp" #include "atf/fs.hpp" #include "atf/formats.hpp" #include "atf/sanity.hpp" #include "atf/text.hpp" #include "atf/ui.hpp" typedef std::auto_ptr< std::ostream > ostream_ptr; ostream_ptr open_outfile(const atf::fs::path& path) { ostream_ptr osp; if (path.str() == "-") osp = ostream_ptr(new std::ofstream("/dev/stdout")); else osp = ostream_ptr(new std::ofstream(path.c_str())); if (!(*osp)) throw std::runtime_error("Could not create file " + path.str()); return osp; } // ------------------------------------------------------------------------ // The "writer" interface. // ------------------------------------------------------------------------ //! //! \brief A base class that defines an output format. //! //! The writer base class defines a generic interface to output formats. //! This is meant to be subclassed, and each subclass can redefine any //! method to format the information as it wishes. //! //! This class is not tied to a output stream nor a file because, depending //! on the output format, we will want to write to a single file or to //! multiple ones. //! class writer { public: writer(void) {} virtual ~writer(void) {} virtual void write_info(const std::string&, const std::string&) {} virtual void write_ntps(size_t) {} virtual void write_tp_start(const std::string&, size_t) {} virtual void write_tp_end(const std::string&) {} virtual void write_tc_start(const std::string&) {} virtual void write_tc_stdout_line(const std::string&) {} virtual void write_tc_stderr_line(const std::string&) {} virtual void write_tc_end(const atf::tests::tcr&) {} virtual void write_eof(void) {} }; // ------------------------------------------------------------------------ // The "csv_writer" class. // ------------------------------------------------------------------------ //! //! \brief A very simple plain-text output format. //! //! The csv_writer class implements a very simple plain-text output //! format that summarizes the results of each executed test case. The //! results are meant to be easily parseable by third-party tools, hence //! they are formatted as a CSV file. //! class csv_writer : public writer { ostream_ptr m_os; bool m_failed; std::string m_tpname; std::string m_tcname; public: csv_writer(const atf::fs::path& p) : m_os(open_outfile(p)) { } virtual void write_tp_start(const std::string& name, size_t ntcs) { m_tpname = name; m_failed = false; } virtual void write_tp_end(const std::string& reason) { if (!reason.empty()) (*m_os) << "tp, " << m_tpname << ", bogus, " << reason << std::endl; else if (m_failed) (*m_os) << "tp, " << m_tpname << ", failed" << std::endl; else (*m_os) << "tp, " << m_tpname << ", passed" << std::endl; } virtual void write_tc_start(const std::string& name) { m_tcname = name; } virtual void write_tc_end(const atf::tests::tcr& tcr) { std::string str = "tc, "; if (tcr.get_status() == atf::tests::tcr::status_passed) { str += m_tpname + ", " + m_tcname + ", passed"; } else if (tcr.get_status() == atf::tests::tcr::status_failed) { str += m_tpname + ", " + m_tcname + ", failed, " + tcr.get_reason(); m_failed = true; } else if (tcr.get_status() == atf::tests::tcr::status_skipped) { str += m_tpname + ", " + m_tcname + ", skipped, " + tcr.get_reason(); } else UNREACHABLE; (*m_os) << str << std::endl; } }; // ------------------------------------------------------------------------ // The "ticker_writer" class. // ------------------------------------------------------------------------ //! //! \brief A console-friendly output format. //! //! The ticker_writer class implements a formatter that is user-friendly //! in the sense that it shows the execution of test cases in an easy to //! read format. It is not meant to be parseable and its format can //! freely change across releases. //! class ticker_writer : public writer { ostream_ptr m_os; size_t m_curtp, m_ntps; size_t m_tcs_passed, m_tcs_failed, m_tcs_skipped; std::string m_tcname, m_tpname; std::vector< std::string > m_failed_tcs; std::vector< std::string > m_failed_tps; void write_info(const std::string& what, const std::string& val) { if (what == "tests.root") { (*m_os) << "Tests root: " << val << std::endl << std::endl; } } void write_ntps(size_t ntps) { m_curtp = 1; m_tcs_passed = 0; m_tcs_failed = 0; m_tcs_skipped = 0; m_ntps = ntps; } void write_tp_start(const std::string& tp, size_t ntcs) { using atf::text::to_string; using atf::ui::format_text; m_tpname = tp; (*m_os) << format_text(tp + " (" + to_string(m_curtp) + "/" + to_string(m_ntps) + "): " + to_string(ntcs) + " test cases") << std::endl; (*m_os).flush(); } void write_tp_end(const std::string& reason) { using atf::ui::format_text_with_tag; m_curtp++; if (!reason.empty()) { (*m_os) << format_text_with_tag("BOGUS TEST PROGRAM: Cannot " "trust its results because " "of `" + reason + "'", m_tpname + ": ", false) << std::endl; m_failed_tps.push_back(m_tpname); } (*m_os) << std::endl; (*m_os).flush(); m_tpname.clear(); } void write_tc_start(const std::string& tcname) { m_tcname = tcname; (*m_os) << " " + tcname + ": "; (*m_os).flush(); } void write_tc_end(const atf::tests::tcr& tcr) { std::string str; atf::tests::tcr::status s = tcr.get_status(); if (s == atf::tests::tcr::status_passed) { str = "Passed."; m_tcs_passed++; } else if (s == atf::tests::tcr::status_failed) { str = "Failed: " + tcr.get_reason(); m_tcs_failed++; m_failed_tcs.push_back(m_tpname + ":" + m_tcname); } else if (s == atf::tests::tcr::status_skipped) { str = "Skipped: " + tcr.get_reason(); m_tcs_skipped++; } else UNREACHABLE; // XXX Wrap text. format_text_with_tag does not currently allow // to specify the current column, which is needed because we have // already printed the tc's name. (*m_os) << str << std::endl; m_tcname = ""; } void write_eof(void) { using atf::text::join; using atf::text::to_string; using atf::ui::format_text; using atf::ui::format_text_with_tag; if (!m_failed_tps.empty()) { (*m_os) << format_text("Failed (bogus) test programs:") << std::endl; (*m_os) << format_text_with_tag(join(m_failed_tps, ", "), " ", false) << std::endl << std::endl; } if (!m_failed_tcs.empty()) { (*m_os) << format_text("Failed test cases:") << std::endl; (*m_os) << format_text_with_tag(join(m_failed_tcs, ", "), " ", false) << std::endl << std::endl; } (*m_os) << format_text("Summary for " + to_string(m_ntps) + " test programs:") << std::endl; (*m_os) << format_text_with_tag(to_string(m_tcs_passed) + " passed test cases.", " ", false) << std::endl; (*m_os) << format_text_with_tag(to_string(m_tcs_failed) + " failed test cases.", " ", false) << std::endl; (*m_os) << format_text_with_tag(to_string(m_tcs_skipped) + " skipped test cases.", " ", false) << std::endl; } public: ticker_writer(const atf::fs::path& p) : m_os(open_outfile(p)) { } }; // ------------------------------------------------------------------------ // The "xml" class. // ------------------------------------------------------------------------ //! //! \brief A single-file XML output format. //! //! The xml_writer class implements a formatter that prints the results //! of test cases in an XML format easily parseable later on by other //! utilities. //! class xml_writer : public writer { ostream_ptr m_os; size_t m_curtp, m_ntps; size_t m_tcs_passed, m_tcs_failed, m_tcs_skipped; std::string m_tcname, m_tpname; std::vector< std::string > m_failed_tcs; std::vector< std::string > m_failed_tps; static std::string attrval(const std::string& str) { return str; } static std::string elemval(const std::string& str) { std::string ostr; for (std::string::const_iterator iter = str.begin(); iter != str.end(); iter++) { switch (*iter) { case '&': ostr += "&"; break; case '<': ostr += "<"; break; case '>': ostr += ">"; break; default: ostr += *iter; } } return ostr; } void write_info(const std::string& what, const std::string& val) { (*m_os) << "" << val << "" << std::endl; } void write_tp_start(const std::string& tp, size_t ntcs) { (*m_os) << "" << std::endl; } void write_tp_end(const std::string& reason) { if (!reason.empty()) (*m_os) << "" << elemval(reason) << "" << std::endl; (*m_os) << "" << std::endl; } void write_tc_start(const std::string& tcname) { (*m_os) << "" << std::endl; } void write_tc_stdout_line(const std::string& line) { (*m_os) << "" << elemval(line) << "" << std::endl; } void write_tc_stderr_line(const std::string& line) { (*m_os) << "" << elemval(line) << "" << std::endl; } void write_tc_end(const atf::tests::tcr& tcr) { std::string str; atf::tests::tcr::status s = tcr.get_status(); if (s == atf::tests::tcr::status_passed) { (*m_os) << "" << std::endl; } else if (s == atf::tests::tcr::status_failed) { (*m_os) << "" << elemval(tcr.get_reason()) << "" << std::endl; } else if (s == atf::tests::tcr::status_skipped) { (*m_os) << "" << elemval(tcr.get_reason()) << "" << std::endl; } else UNREACHABLE; (*m_os) << "" << std::endl; } void write_eof(void) { (*m_os) << "" << std::endl; } public: xml_writer(const atf::fs::path& p) : m_os(open_outfile(p)) { (*m_os) << "" << std::endl << "" << std::endl << std::endl << "" << std::endl; } }; // ------------------------------------------------------------------------ // The "converter" class. // ------------------------------------------------------------------------ //! //! \brief A reader that redirects events to multiple writers. //! //! The converter class implements an atf_tps_reader that, for each event //! raised by the parser, redirects it to multiple writers so that they //! can reformat it according to their output rules. //! class converter : public atf::formats::atf_tps_reader { typedef std::vector< writer* > outs_vector; outs_vector m_outs; void got_info(const std::string& what, const std::string& val) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_info(what, val); } void got_ntps(size_t ntps) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_ntps(ntps); } void got_tp_start(const std::string& tp, size_t ntcs) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tp_start(tp, ntcs); } void got_tp_end(const std::string& reason) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tp_end(reason); } void got_tc_start(const std::string& tcname) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_start(tcname); } void got_tc_stdout_line(const std::string& line) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_stdout_line(line); } void got_tc_stderr_line(const std::string& line) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_stderr_line(line); } void got_tc_end(const atf::tests::tcr& tcr) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_end(tcr); } void got_eof(void) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_eof(); } public: converter(std::istream& is) : atf::formats::atf_tps_reader(is) { } ~converter(void) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) delete *iter; } void add_output(const std::string& fmt, const atf::fs::path& p) { if (fmt == "csv") { m_outs.push_back(new csv_writer(p)); } else if (fmt == "ticker") { m_outs.push_back(new ticker_writer(p)); } else if (fmt == "xml") { m_outs.push_back(new xml_writer(p)); } else throw std::runtime_error("Unknown format `" + fmt + "'"); } }; // ------------------------------------------------------------------------ // The "atf_report" class. // ------------------------------------------------------------------------ class atf_report : public atf::application { static const char* m_description; typedef std::pair< std::string, atf::fs::path > fmt_path_pair; std::vector< fmt_path_pair > m_oflags; void process_option(int, const char*); options_set specific_options(void) const; public: atf_report(void); int main(void); }; const char* atf_report::m_description = "atf-report is a tool that parses the output of atf-run and " "generates user-friendly reports in multiple different formats."; atf_report::atf_report(void) : application(m_description, "atf-report(1)") { } void atf_report::process_option(int ch, const char* arg) { switch (ch) { case 'o': { std::string str(arg); std::string::size_type pos = str.find(':'); if (pos == std::string::npos) throw std::runtime_error("Syntax error in -o option"); else { std::string fmt = str.substr(0, pos); atf::fs::path path = atf::fs::path(str.substr(pos + 1)); m_oflags.push_back(fmt_path_pair(fmt, path)); } } break; default: UNREACHABLE; } } atf_report::options_set atf_report::specific_options(void) const { options_set opts; opts.insert(option('o', "fmt:path", "Adds a new output file; multiple " "ones can be specified, and a - " "path means stdout")); return opts; } int atf_report::main(void) { if (m_oflags.empty()) m_oflags.push_back(fmt_path_pair("ticker", atf::fs::path("-"))); // Look for path duplicates. std::set< atf::fs::path > paths; for (std::vector< fmt_path_pair >::const_iterator iter = m_oflags.begin(); iter != m_oflags.end(); iter++) { atf::fs::path p = (*iter).second; if (p == atf::fs::path("/dev/stdout")) p = atf::fs::path("-"); if (paths.find(p) != paths.end()) throw std::runtime_error("The file `" + p.str() + "' was " "specified more than once"); paths.insert((*iter).second); } // Generate the output files. converter cnv(std::cin); for (std::vector< fmt_path_pair >::const_iterator iter = m_oflags.begin(); iter != m_oflags.end(); iter++) cnv.add_output((*iter).first, (*iter).second); cnv.read(); return EXIT_SUCCESS; } int main(int argc, char* const* argv) { return atf_report().run(argc, argv); } @ 1.1 log @Initial revision @ text @@ 1.1.1.1 log @Import of ATF 0.3 Initial import of the Automated Testing Framework, version 0.3, a project that provides a framework to easily implement test cases for the NetBSD operating system and some tools to run them and generate reports with the results. Note that this is just the framework (libraries and tools), which is and will be maintained externally. The tests themselves will come later, will be put under the 'tests' hierarchy and will be managed exclusively under the NetBSD CVS tree given that they are tied to the operating system. The work done until version 0.1 was sponsored by the Google Summer of Code 2007 program and mentored by martin@@. @ text @@ 1.1.1.2 log @Import of ATF 0.4 Changes in this release: * Added two new manual pages, atf-c++-api and atf-sh-api, describing the C++ and POSIX shell interfaces used to write test programs. * Added a pkg-config file, useful to get the flags to build against the C++ library or to easily detect the presence of ATF. * Added a way for test cases to require a specific architecture and/or machine type through the new 'require.arch' and 'require.machine' meta-data properties, respectively. * Added the 'timeout' property to test cases, useful to set an upper-bound limit for the test's run time and thus prevent global test program stalls due to the test case's misbehavior. * Added the atf-exec(1) internal utility, used to execute a command after changing the process group it belongs to. * Added the atf-killpg(1) internal utility, used to kill process groups. * Multiple portability fixes. Of special interest, full support for SunOS (Solaris Express Developer Edition 2007/09) using the Sun Studio 12 C++ compiler. * Fixed a serious bug that prevented atf-run(1) from working at all under Fedora 8 x86_64. Due to the nature of the bug, other platforms were likely affected too. @ text @d569 1 a569 1 class atf_report : public atf::application::app { d589 1 a589 1 app(m_description, "atf-report(1)", "atf(7)") a619 1 using atf::application::option; @ 1.1.1.2.4.1 log @sync with head. @ text @d4 1 a4 1 // Copyright (c) 2007, 2008 The NetBSD Foundation, Inc. d15 7 d43 6 a48 6 #include "atf-c++/application.hpp" #include "atf-c++/fs.hpp" #include "atf-c++/formats.hpp" #include "atf-c++/sanity.hpp" #include "atf-c++/text.hpp" #include "atf-c++/ui.hpp" d154 1 a154 1 if (tcr.get_state() == atf::tests::tcr::passed_state) { d156 1 a156 1 } else if (tcr.get_state() == atf::tests::tcr::failed_state) { d160 1 a160 1 } else if (tcr.get_state() == atf::tests::tcr::skipped_state) { d259 2 a260 2 atf::tests::tcr::state s = tcr.get_state(); if (s == atf::tests::tcr::passed_state) { d263 1 a263 1 } else if (s == atf::tests::tcr::failed_state) { d267 1 a267 1 } else if (s == atf::tests::tcr::skipped_state) { d417 2 a418 2 atf::tests::tcr::state s = tcr.get_state(); if (s == atf::tests::tcr::passed_state) { d420 1 a420 1 } else if (s == atf::tests::tcr::failed_state) { d423 1 a423 1 } else if (s == atf::tests::tcr::skipped_state) { @ 1.1.1.3 log @Import ATF 0.5 Changes in this release: * Clauses 3 and 4 of the BSD license used by the project were dropped. All the code is now under a 2-clause BSD license compatible with the GNU General Public License (GPL). * Added a C-only binding so that binary test programs do not need to be tied to C++ at all. This binding is now known as the atf-c library. * Renamed the C++ binding to atf-c++ for consistency with the new atf-c. * Renamed the POSIX shell binding to atf-sh for consistency with the new atf-c and atf-c++. * Added a -w flag to test programs through which it is possible to specify the work directory to be used. This was possible in prior releases by defining the workdir configuration variable (-v workdir=...), but was a conceptually incorrect mechanism. * Test programs now preserve the execution order of test cases when they are given in the command line. Even those mentioned more than once are executed multiple times to comply with the user's requests. @ text @d4 1 a4 1 // Copyright (c) 2007, 2008 The NetBSD Foundation, Inc. d15 7 d43 6 a48 6 #include "atf-c++/application.hpp" #include "atf-c++/fs.hpp" #include "atf-c++/formats.hpp" #include "atf-c++/sanity.hpp" #include "atf-c++/text.hpp" #include "atf-c++/ui.hpp" d154 1 a154 1 if (tcr.get_state() == atf::tests::tcr::passed_state) { d156 1 a156 1 } else if (tcr.get_state() == atf::tests::tcr::failed_state) { d160 1 a160 1 } else if (tcr.get_state() == atf::tests::tcr::skipped_state) { d259 2 a260 2 atf::tests::tcr::state s = tcr.get_state(); if (s == atf::tests::tcr::passed_state) { d263 1 a263 1 } else if (s == atf::tests::tcr::failed_state) { d267 1 a267 1 } else if (s == atf::tests::tcr::skipped_state) { d417 2 a418 2 atf::tests::tcr::state s = tcr.get_state(); if (s == atf::tests::tcr::passed_state) { d420 1 a420 1 } else if (s == atf::tests::tcr::failed_state) { d423 1 a423 1 } else if (s == atf::tests::tcr::skipped_state) { @ 1.1.1.1.4.1 log @file atf-report.cpp was added on branch matt-armv6 on 2008-01-09 01:26:04 +0000 @ text @d1 660 @ 1.1.1.1.4.2 log @sync with HEAD @ text @a0 660 // // Automated Testing Framework (atf) // // Copyright (c) 2007 The NetBSD Foundation, Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // 1. Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // 2. Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // 3. All advertising materials mentioning features or use of this // software must display the following acknowledgement: // This product includes software developed by the NetBSD // Foundation, Inc. and its contributors. // 4. Neither the name of The NetBSD Foundation nor the names of its // contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // #include #include #include #include #include #include "atf/application.hpp" #include "atf/fs.hpp" #include "atf/formats.hpp" #include "atf/sanity.hpp" #include "atf/text.hpp" #include "atf/ui.hpp" typedef std::auto_ptr< std::ostream > ostream_ptr; ostream_ptr open_outfile(const atf::fs::path& path) { ostream_ptr osp; if (path.str() == "-") osp = ostream_ptr(new std::ofstream("/dev/stdout")); else osp = ostream_ptr(new std::ofstream(path.c_str())); if (!(*osp)) throw std::runtime_error("Could not create file " + path.str()); return osp; } // ------------------------------------------------------------------------ // The "writer" interface. // ------------------------------------------------------------------------ //! //! \brief A base class that defines an output format. //! //! The writer base class defines a generic interface to output formats. //! This is meant to be subclassed, and each subclass can redefine any //! method to format the information as it wishes. //! //! This class is not tied to a output stream nor a file because, depending //! on the output format, we will want to write to a single file or to //! multiple ones. //! class writer { public: writer(void) {} virtual ~writer(void) {} virtual void write_info(const std::string&, const std::string&) {} virtual void write_ntps(size_t) {} virtual void write_tp_start(const std::string&, size_t) {} virtual void write_tp_end(const std::string&) {} virtual void write_tc_start(const std::string&) {} virtual void write_tc_stdout_line(const std::string&) {} virtual void write_tc_stderr_line(const std::string&) {} virtual void write_tc_end(const atf::tests::tcr&) {} virtual void write_eof(void) {} }; // ------------------------------------------------------------------------ // The "csv_writer" class. // ------------------------------------------------------------------------ //! //! \brief A very simple plain-text output format. //! //! The csv_writer class implements a very simple plain-text output //! format that summarizes the results of each executed test case. The //! results are meant to be easily parseable by third-party tools, hence //! they are formatted as a CSV file. //! class csv_writer : public writer { ostream_ptr m_os; bool m_failed; std::string m_tpname; std::string m_tcname; public: csv_writer(const atf::fs::path& p) : m_os(open_outfile(p)) { } virtual void write_tp_start(const std::string& name, size_t ntcs) { m_tpname = name; m_failed = false; } virtual void write_tp_end(const std::string& reason) { if (!reason.empty()) (*m_os) << "tp, " << m_tpname << ", bogus, " << reason << std::endl; else if (m_failed) (*m_os) << "tp, " << m_tpname << ", failed" << std::endl; else (*m_os) << "tp, " << m_tpname << ", passed" << std::endl; } virtual void write_tc_start(const std::string& name) { m_tcname = name; } virtual void write_tc_end(const atf::tests::tcr& tcr) { std::string str = "tc, "; if (tcr.get_status() == atf::tests::tcr::status_passed) { str += m_tpname + ", " + m_tcname + ", passed"; } else if (tcr.get_status() == atf::tests::tcr::status_failed) { str += m_tpname + ", " + m_tcname + ", failed, " + tcr.get_reason(); m_failed = true; } else if (tcr.get_status() == atf::tests::tcr::status_skipped) { str += m_tpname + ", " + m_tcname + ", skipped, " + tcr.get_reason(); } else UNREACHABLE; (*m_os) << str << std::endl; } }; // ------------------------------------------------------------------------ // The "ticker_writer" class. // ------------------------------------------------------------------------ //! //! \brief A console-friendly output format. //! //! The ticker_writer class implements a formatter that is user-friendly //! in the sense that it shows the execution of test cases in an easy to //! read format. It is not meant to be parseable and its format can //! freely change across releases. //! class ticker_writer : public writer { ostream_ptr m_os; size_t m_curtp, m_ntps; size_t m_tcs_passed, m_tcs_failed, m_tcs_skipped; std::string m_tcname, m_tpname; std::vector< std::string > m_failed_tcs; std::vector< std::string > m_failed_tps; void write_info(const std::string& what, const std::string& val) { if (what == "tests.root") { (*m_os) << "Tests root: " << val << std::endl << std::endl; } } void write_ntps(size_t ntps) { m_curtp = 1; m_tcs_passed = 0; m_tcs_failed = 0; m_tcs_skipped = 0; m_ntps = ntps; } void write_tp_start(const std::string& tp, size_t ntcs) { using atf::text::to_string; using atf::ui::format_text; m_tpname = tp; (*m_os) << format_text(tp + " (" + to_string(m_curtp) + "/" + to_string(m_ntps) + "): " + to_string(ntcs) + " test cases") << std::endl; (*m_os).flush(); } void write_tp_end(const std::string& reason) { using atf::ui::format_text_with_tag; m_curtp++; if (!reason.empty()) { (*m_os) << format_text_with_tag("BOGUS TEST PROGRAM: Cannot " "trust its results because " "of `" + reason + "'", m_tpname + ": ", false) << std::endl; m_failed_tps.push_back(m_tpname); } (*m_os) << std::endl; (*m_os).flush(); m_tpname.clear(); } void write_tc_start(const std::string& tcname) { m_tcname = tcname; (*m_os) << " " + tcname + ": "; (*m_os).flush(); } void write_tc_end(const atf::tests::tcr& tcr) { std::string str; atf::tests::tcr::status s = tcr.get_status(); if (s == atf::tests::tcr::status_passed) { str = "Passed."; m_tcs_passed++; } else if (s == atf::tests::tcr::status_failed) { str = "Failed: " + tcr.get_reason(); m_tcs_failed++; m_failed_tcs.push_back(m_tpname + ":" + m_tcname); } else if (s == atf::tests::tcr::status_skipped) { str = "Skipped: " + tcr.get_reason(); m_tcs_skipped++; } else UNREACHABLE; // XXX Wrap text. format_text_with_tag does not currently allow // to specify the current column, which is needed because we have // already printed the tc's name. (*m_os) << str << std::endl; m_tcname = ""; } void write_eof(void) { using atf::text::join; using atf::text::to_string; using atf::ui::format_text; using atf::ui::format_text_with_tag; if (!m_failed_tps.empty()) { (*m_os) << format_text("Failed (bogus) test programs:") << std::endl; (*m_os) << format_text_with_tag(join(m_failed_tps, ", "), " ", false) << std::endl << std::endl; } if (!m_failed_tcs.empty()) { (*m_os) << format_text("Failed test cases:") << std::endl; (*m_os) << format_text_with_tag(join(m_failed_tcs, ", "), " ", false) << std::endl << std::endl; } (*m_os) << format_text("Summary for " + to_string(m_ntps) + " test programs:") << std::endl; (*m_os) << format_text_with_tag(to_string(m_tcs_passed) + " passed test cases.", " ", false) << std::endl; (*m_os) << format_text_with_tag(to_string(m_tcs_failed) + " failed test cases.", " ", false) << std::endl; (*m_os) << format_text_with_tag(to_string(m_tcs_skipped) + " skipped test cases.", " ", false) << std::endl; } public: ticker_writer(const atf::fs::path& p) : m_os(open_outfile(p)) { } }; // ------------------------------------------------------------------------ // The "xml" class. // ------------------------------------------------------------------------ //! //! \brief A single-file XML output format. //! //! The xml_writer class implements a formatter that prints the results //! of test cases in an XML format easily parseable later on by other //! utilities. //! class xml_writer : public writer { ostream_ptr m_os; size_t m_curtp, m_ntps; size_t m_tcs_passed, m_tcs_failed, m_tcs_skipped; std::string m_tcname, m_tpname; std::vector< std::string > m_failed_tcs; std::vector< std::string > m_failed_tps; static std::string attrval(const std::string& str) { return str; } static std::string elemval(const std::string& str) { std::string ostr; for (std::string::const_iterator iter = str.begin(); iter != str.end(); iter++) { switch (*iter) { case '&': ostr += "&"; break; case '<': ostr += "<"; break; case '>': ostr += ">"; break; default: ostr += *iter; } } return ostr; } void write_info(const std::string& what, const std::string& val) { (*m_os) << "" << val << "" << std::endl; } void write_tp_start(const std::string& tp, size_t ntcs) { (*m_os) << "" << std::endl; } void write_tp_end(const std::string& reason) { if (!reason.empty()) (*m_os) << "" << elemval(reason) << "" << std::endl; (*m_os) << "" << std::endl; } void write_tc_start(const std::string& tcname) { (*m_os) << "" << std::endl; } void write_tc_stdout_line(const std::string& line) { (*m_os) << "" << elemval(line) << "" << std::endl; } void write_tc_stderr_line(const std::string& line) { (*m_os) << "" << elemval(line) << "" << std::endl; } void write_tc_end(const atf::tests::tcr& tcr) { std::string str; atf::tests::tcr::status s = tcr.get_status(); if (s == atf::tests::tcr::status_passed) { (*m_os) << "" << std::endl; } else if (s == atf::tests::tcr::status_failed) { (*m_os) << "" << elemval(tcr.get_reason()) << "" << std::endl; } else if (s == atf::tests::tcr::status_skipped) { (*m_os) << "" << elemval(tcr.get_reason()) << "" << std::endl; } else UNREACHABLE; (*m_os) << "" << std::endl; } void write_eof(void) { (*m_os) << "" << std::endl; } public: xml_writer(const atf::fs::path& p) : m_os(open_outfile(p)) { (*m_os) << "" << std::endl << "" << std::endl << std::endl << "" << std::endl; } }; // ------------------------------------------------------------------------ // The "converter" class. // ------------------------------------------------------------------------ //! //! \brief A reader that redirects events to multiple writers. //! //! The converter class implements an atf_tps_reader that, for each event //! raised by the parser, redirects it to multiple writers so that they //! can reformat it according to their output rules. //! class converter : public atf::formats::atf_tps_reader { typedef std::vector< writer* > outs_vector; outs_vector m_outs; void got_info(const std::string& what, const std::string& val) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_info(what, val); } void got_ntps(size_t ntps) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_ntps(ntps); } void got_tp_start(const std::string& tp, size_t ntcs) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tp_start(tp, ntcs); } void got_tp_end(const std::string& reason) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tp_end(reason); } void got_tc_start(const std::string& tcname) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_start(tcname); } void got_tc_stdout_line(const std::string& line) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_stdout_line(line); } void got_tc_stderr_line(const std::string& line) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_stderr_line(line); } void got_tc_end(const atf::tests::tcr& tcr) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_tc_end(tcr); } void got_eof(void) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) (*iter)->write_eof(); } public: converter(std::istream& is) : atf::formats::atf_tps_reader(is) { } ~converter(void) { for (outs_vector::iterator iter = m_outs.begin(); iter != m_outs.end(); iter++) delete *iter; } void add_output(const std::string& fmt, const atf::fs::path& p) { if (fmt == "csv") { m_outs.push_back(new csv_writer(p)); } else if (fmt == "ticker") { m_outs.push_back(new ticker_writer(p)); } else if (fmt == "xml") { m_outs.push_back(new xml_writer(p)); } else throw std::runtime_error("Unknown format `" + fmt + "'"); } }; // ------------------------------------------------------------------------ // The "atf_report" class. // ------------------------------------------------------------------------ class atf_report : public atf::application { static const char* m_description; typedef std::pair< std::string, atf::fs::path > fmt_path_pair; std::vector< fmt_path_pair > m_oflags; void process_option(int, const char*); options_set specific_options(void) const; public: atf_report(void); int main(void); }; const char* atf_report::m_description = "atf-report is a tool that parses the output of atf-run and " "generates user-friendly reports in multiple different formats."; atf_report::atf_report(void) : application(m_description, "atf-report(1)") { } void atf_report::process_option(int ch, const char* arg) { switch (ch) { case 'o': { std::string str(arg); std::string::size_type pos = str.find(':'); if (pos == std::string::npos) throw std::runtime_error("Syntax error in -o option"); else { std::string fmt = str.substr(0, pos); atf::fs::path path = atf::fs::path(str.substr(pos + 1)); m_oflags.push_back(fmt_path_pair(fmt, path)); } } break; default: UNREACHABLE; } } atf_report::options_set atf_report::specific_options(void) const { options_set opts; opts.insert(option('o', "fmt:path", "Adds a new output file; multiple " "ones can be specified, and a - " "path means stdout")); return opts; } int atf_report::main(void) { if (m_oflags.empty()) m_oflags.push_back(fmt_path_pair("ticker", atf::fs::path("-"))); // Look for path duplicates. std::set< atf::fs::path > paths; for (std::vector< fmt_path_pair >::const_iterator iter = m_oflags.begin(); iter != m_oflags.end(); iter++) { atf::fs::path p = (*iter).second; if (p == atf::fs::path("/dev/stdout")) p = atf::fs::path("-"); if (paths.find(p) != paths.end()) throw std::runtime_error("The file `" + p.str() + "' was " "specified more than once"); paths.insert((*iter).second); } // Generate the output files. converter cnv(std::cin); for (std::vector< fmt_path_pair >::const_iterator iter = m_oflags.begin(); iter != m_oflags.end(); iter++) cnv.add_output((*iter).first, (*iter).second); cnv.read(); return EXIT_SUCCESS; } int main(int argc, char* const* argv) { return atf_report().run(argc, argv); } @ 1.1.1.1.4.3 log @sync with HEAD @ text @d569 1 a569 1 class atf_report : public atf::application::app { d589 1 a589 1 app(m_description, "atf-report(1)", "atf(7)") a619 1 using atf::application::option; @