1 // Copyright (c) 2007 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 #include "atf-c++/tests.hpp" 27 28 #if defined(HAVE_CONFIG_H) 29 #include "config.h" 30 #endif 31 32 extern "C" { 33 #include <sys/types.h> 34 #include <sys/stat.h> 35 #include <sys/time.h> 36 #include <sys/wait.h> 37 #include <signal.h> 38 #include <unistd.h> 39 } 40 41 #include <algorithm> 42 #include <cctype> 43 #include <cerrno> 44 #include <cstdlib> 45 #include <cstring> 46 #include <fstream> 47 #include <iostream> 48 #include <map> 49 #include <memory> 50 #include <sstream> 51 #include <stdexcept> 52 #include <vector> 53 54 extern "C" { 55 #include "atf-c/error.h" 56 #include "atf-c/tc.h" 57 #include "atf-c/utils.h" 58 } 59 60 #include "atf-c++/detail/application.hpp" 61 #include "atf-c++/detail/auto_array.hpp" 62 #include "atf-c++/detail/env.hpp" 63 #include "atf-c++/detail/exceptions.hpp" 64 #include "atf-c++/detail/fs.hpp" 65 #include "atf-c++/detail/sanity.hpp" 66 #include "atf-c++/detail/text.hpp" 67 68 #if defined(HAVE_GNU_GETOPT) 69 # define GETOPT_POSIX "+" 70 #else 71 # define GETOPT_POSIX "" 72 #endif 73 74 namespace impl = atf::tests; 75 namespace detail = atf::tests::detail; 76 #define IMPL_NAME "atf::tests" 77 78 using atf::application::usage_error; 79 80 // ------------------------------------------------------------------------ 81 // The "atf_tp_writer" class. 82 // ------------------------------------------------------------------------ 83 84 detail::atf_tp_writer::atf_tp_writer(std::ostream& os) : 85 m_os(os), 86 m_is_first(true) 87 { 88 m_os << "Content-Type: application/X-atf-tp; version=\"1\"\n\n"; 89 } 90 91 void 92 detail::atf_tp_writer::start_tc(const std::string& ident) 93 { 94 if (!m_is_first) 95 m_os << "\n"; 96 m_os << "ident: " << ident << "\n"; 97 m_os.flush(); 98 } 99 100 void 101 detail::atf_tp_writer::end_tc(void) 102 { 103 if (m_is_first) 104 m_is_first = false; 105 } 106 107 void 108 detail::atf_tp_writer::tc_meta_data(const std::string& name, 109 const std::string& value) 110 { 111 PRE(name != "ident"); 112 m_os << name << ": " << value << "\n"; 113 m_os.flush(); 114 } 115 116 // ------------------------------------------------------------------------ 117 // Free helper functions. 118 // ------------------------------------------------------------------------ 119 120 std::string Program_Name; 121 122 static void 123 set_program_name(const char* argv0) 124 { 125 const std::string program_name = atf::fs::path(argv0).leaf_name(); 126 // Libtool workaround: if running from within the source tree (binaries 127 // that are not installed yet), skip the "lt-" prefix added to files in 128 // the ".libs" directory to show the real (not temporary) name. 129 if (program_name.substr(0, 3) == "lt-") 130 Program_Name = program_name.substr(3); 131 else 132 Program_Name = program_name; 133 } 134 135 bool 136 detail::match(const std::string& regexp, const std::string& str) 137 { 138 return atf::text::match(str, regexp); 139 } 140 141 // ------------------------------------------------------------------------ 142 // The "tc" class. 143 // ------------------------------------------------------------------------ 144 145 static std::map< atf_tc_t*, impl::tc* > wraps; 146 static std::map< const atf_tc_t*, const impl::tc* > cwraps; 147 148 struct impl::tc_impl { 149 private: 150 // Non-copyable. 151 tc_impl(const tc_impl&); 152 tc_impl& operator=(const tc_impl&); 153 154 public: 155 std::string m_ident; 156 atf_tc_t m_tc; 157 bool m_has_cleanup; 158 159 tc_impl(const std::string& ident, const bool has_cleanup) : 160 m_ident(ident), 161 m_has_cleanup(has_cleanup) 162 { 163 } 164 165 static void 166 wrap_head(atf_tc_t *tc) 167 { 168 std::map< atf_tc_t*, impl::tc* >::iterator iter = wraps.find(tc); 169 INV(iter != wraps.end()); 170 (*iter).second->head(); 171 } 172 173 static void 174 wrap_body(const atf_tc_t *tc) 175 { 176 std::map< const atf_tc_t*, const impl::tc* >::const_iterator iter = 177 cwraps.find(tc); 178 INV(iter != cwraps.end()); 179 (*iter).second->body(); 180 } 181 182 static void 183 wrap_cleanup(const atf_tc_t *tc) 184 { 185 std::map< const atf_tc_t*, const impl::tc* >::const_iterator iter = 186 cwraps.find(tc); 187 INV(iter != cwraps.end()); 188 (*iter).second->cleanup(); 189 } 190 }; 191 192 impl::tc::tc(const std::string& ident, const bool has_cleanup) : 193 pimpl(new tc_impl(ident, has_cleanup)) 194 { 195 } 196 197 impl::tc::~tc(void) 198 { 199 cwraps.erase(&pimpl->m_tc); 200 wraps.erase(&pimpl->m_tc); 201 202 atf_tc_fini(&pimpl->m_tc); 203 } 204 205 void 206 impl::tc::init(const vars_map& config) 207 { 208 atf_error_t err; 209 210 auto_array< const char * > array(new const char*[(config.size() * 2) + 1]); 211 const char **ptr = array.get(); 212 for (vars_map::const_iterator iter = config.begin(); 213 iter != config.end(); iter++) { 214 *ptr = (*iter).first.c_str(); 215 *(ptr + 1) = (*iter).second.c_str(); 216 ptr += 2; 217 } 218 *ptr = NULL; 219 220 wraps[&pimpl->m_tc] = this; 221 cwraps[&pimpl->m_tc] = this; 222 223 err = atf_tc_init(&pimpl->m_tc, pimpl->m_ident.c_str(), pimpl->wrap_head, 224 pimpl->wrap_body, pimpl->m_has_cleanup ? pimpl->wrap_cleanup : NULL, 225 array.get()); 226 if (atf_is_error(err)) 227 throw_atf_error(err); 228 } 229 230 bool 231 impl::tc::has_config_var(const std::string& var) 232 const 233 { 234 return atf_tc_has_config_var(&pimpl->m_tc, var.c_str()); 235 } 236 237 bool 238 impl::tc::has_md_var(const std::string& var) 239 const 240 { 241 return atf_tc_has_md_var(&pimpl->m_tc, var.c_str()); 242 } 243 244 const std::string 245 impl::tc::get_config_var(const std::string& var) 246 const 247 { 248 return atf_tc_get_config_var(&pimpl->m_tc, var.c_str()); 249 } 250 251 const std::string 252 impl::tc::get_config_var(const std::string& var, const std::string& defval) 253 const 254 { 255 return atf_tc_get_config_var_wd(&pimpl->m_tc, var.c_str(), defval.c_str()); 256 } 257 258 const std::string 259 impl::tc::get_md_var(const std::string& var) 260 const 261 { 262 return atf_tc_get_md_var(&pimpl->m_tc, var.c_str()); 263 } 264 265 const impl::vars_map 266 impl::tc::get_md_vars(void) 267 const 268 { 269 vars_map vars; 270 271 char **array = atf_tc_get_md_vars(&pimpl->m_tc); 272 try { 273 char **ptr; 274 for (ptr = array; *ptr != NULL; ptr += 2) 275 vars[*ptr] = *(ptr + 1); 276 } catch (...) { 277 atf_utils_free_charpp(array); 278 throw; 279 } 280 281 return vars; 282 } 283 284 void 285 impl::tc::set_md_var(const std::string& var, const std::string& val) 286 { 287 atf_error_t err = atf_tc_set_md_var(&pimpl->m_tc, var.c_str(), val.c_str()); 288 if (atf_is_error(err)) 289 throw_atf_error(err); 290 } 291 292 void 293 impl::tc::run(const std::string& resfile) 294 const 295 { 296 atf_error_t err = atf_tc_run(&pimpl->m_tc, resfile.c_str()); 297 if (atf_is_error(err)) 298 throw_atf_error(err); 299 } 300 301 void 302 impl::tc::run_cleanup(void) 303 const 304 { 305 atf_error_t err = atf_tc_cleanup(&pimpl->m_tc); 306 if (atf_is_error(err)) 307 throw_atf_error(err); 308 } 309 310 void 311 impl::tc::head(void) 312 { 313 } 314 315 void 316 impl::tc::cleanup(void) 317 const 318 { 319 } 320 321 void 322 impl::tc::require_prog(const std::string& prog) 323 const 324 { 325 atf_tc_require_prog(prog.c_str()); 326 } 327 328 void 329 impl::tc::pass(void) 330 { 331 atf_tc_pass(); 332 } 333 334 void 335 impl::tc::fail(const std::string& reason) 336 { 337 atf_tc_fail("%s", reason.c_str()); 338 } 339 340 void 341 impl::tc::fail_nonfatal(const std::string& reason) 342 { 343 atf_tc_fail_nonfatal("%s", reason.c_str()); 344 } 345 346 void 347 impl::tc::skip(const std::string& reason) 348 { 349 atf_tc_skip("%s", reason.c_str()); 350 } 351 352 void 353 impl::tc::check_errno(const char* file, const int line, const int exp_errno, 354 const char* expr_str, const bool result) 355 { 356 atf_tc_check_errno(file, line, exp_errno, expr_str, result); 357 } 358 359 void 360 impl::tc::require_errno(const char* file, const int line, const int exp_errno, 361 const char* expr_str, const bool result) 362 { 363 atf_tc_require_errno(file, line, exp_errno, expr_str, result); 364 } 365 366 void 367 impl::tc::expect_pass(void) 368 { 369 atf_tc_expect_pass(); 370 } 371 372 void 373 impl::tc::expect_fail(const std::string& reason) 374 { 375 atf_tc_expect_fail("%s", reason.c_str()); 376 } 377 378 void 379 impl::tc::expect_exit(const int exitcode, const std::string& reason) 380 { 381 atf_tc_expect_exit(exitcode, "%s", reason.c_str()); 382 } 383 384 void 385 impl::tc::expect_signal(const int signo, const std::string& reason) 386 { 387 atf_tc_expect_signal(signo, "%s", reason.c_str()); 388 } 389 390 void 391 impl::tc::expect_death(const std::string& reason) 392 { 393 atf_tc_expect_death("%s", reason.c_str()); 394 } 395 396 void 397 impl::tc::expect_timeout(const std::string& reason) 398 { 399 atf_tc_expect_timeout("%s", reason.c_str()); 400 } 401 402 // ------------------------------------------------------------------------ 403 // Test program main code. 404 // ------------------------------------------------------------------------ 405 406 namespace { 407 408 typedef std::vector< impl::tc * > tc_vector; 409 410 enum tc_part { BODY, CLEANUP }; 411 412 static void 413 parse_vflag(const std::string& str, atf::tests::vars_map& vars) 414 { 415 if (str.empty()) 416 throw std::runtime_error("-v requires a non-empty argument"); 417 418 std::vector< std::string > ws = atf::text::split(str, "="); 419 if (ws.size() == 1 && str[str.length() - 1] == '=') { 420 vars[ws[0]] = ""; 421 } else { 422 if (ws.size() != 2) 423 throw std::runtime_error("-v requires an argument of the form " 424 "var=value"); 425 426 vars[ws[0]] = ws[1]; 427 } 428 } 429 430 static atf::fs::path 431 handle_srcdir(const char* argv0, const std::string& srcdir_arg) 432 { 433 atf::fs::path srcdir("."); 434 435 if (srcdir_arg.empty()) { 436 srcdir = atf::fs::path(argv0).branch_path(); 437 if (srcdir.leaf_name() == ".libs") 438 srcdir = srcdir.branch_path(); 439 } else 440 srcdir = atf::fs::path(srcdir_arg); 441 442 if (!atf::fs::exists(srcdir / Program_Name)) 443 throw usage_error("Cannot find the test program in the source " 444 "directory `%s'", srcdir.c_str()); 445 446 if (!srcdir.is_absolute()) 447 srcdir = srcdir.to_absolute(); 448 449 return srcdir; 450 } 451 452 static void 453 init_tcs(void (*add_tcs)(tc_vector&), tc_vector& tcs, 454 const atf::tests::vars_map& vars) 455 { 456 add_tcs(tcs); 457 for (tc_vector::iterator iter = tcs.begin(); iter != tcs.end(); iter++) { 458 impl::tc* tc = *iter; 459 460 tc->init(vars); 461 } 462 } 463 464 static int 465 list_tcs(const tc_vector& tcs) 466 { 467 detail::atf_tp_writer writer(std::cout); 468 469 for (tc_vector::const_iterator iter = tcs.begin(); 470 iter != tcs.end(); iter++) { 471 const impl::vars_map vars = (*iter)->get_md_vars(); 472 473 { 474 impl::vars_map::const_iterator iter2 = vars.find("ident"); 475 INV(iter2 != vars.end()); 476 writer.start_tc((*iter2).second); 477 } 478 479 for (impl::vars_map::const_iterator iter2 = vars.begin(); 480 iter2 != vars.end(); iter2++) { 481 const std::string& key = (*iter2).first; 482 if (key != "ident") 483 writer.tc_meta_data(key, (*iter2).second); 484 } 485 486 writer.end_tc(); 487 } 488 489 return EXIT_SUCCESS; 490 } 491 492 static impl::tc* 493 find_tc(tc_vector tcs, const std::string& name) 494 { 495 std::vector< std::string > ids; 496 for (tc_vector::iterator iter = tcs.begin(); 497 iter != tcs.end(); iter++) { 498 impl::tc* tc = *iter; 499 500 if (tc->get_md_var("ident") == name) 501 return tc; 502 } 503 throw usage_error("Unknown test case `%s'", name.c_str()); 504 } 505 506 static std::pair< std::string, tc_part > 507 process_tcarg(const std::string& tcarg) 508 { 509 const std::string::size_type pos = tcarg.find(':'); 510 if (pos == std::string::npos) { 511 return std::make_pair(tcarg, BODY); 512 } else { 513 const std::string tcname = tcarg.substr(0, pos); 514 515 const std::string partname = tcarg.substr(pos + 1); 516 if (partname == "body") 517 return std::make_pair(tcname, BODY); 518 else if (partname == "cleanup") 519 return std::make_pair(tcname, CLEANUP); 520 else { 521 throw usage_error("Invalid test case part `%s'", partname.c_str()); 522 } 523 } 524 } 525 526 static int 527 run_tc(tc_vector& tcs, const std::string& tcarg, const atf::fs::path& resfile) 528 { 529 const std::pair< std::string, tc_part > fields = process_tcarg(tcarg); 530 531 impl::tc* tc = find_tc(tcs, fields.first); 532 533 if (!atf::env::has("__RUNNING_INSIDE_ATF_RUN") || atf::env::get( 534 "__RUNNING_INSIDE_ATF_RUN") != "internal-yes-value") 535 { 536 std::cerr << Program_Name << ": WARNING: Running test cases outside " 537 "of kyua(1) is unsupported\n"; 538 std::cerr << Program_Name << ": WARNING: No isolation nor timeout " 539 "control is being applied; you may get unexpected failures; see " 540 "atf-test-case(4)\n"; 541 } 542 543 switch (fields.second) { 544 case BODY: 545 tc->run(resfile.str()); 546 break; 547 case CLEANUP: 548 tc->run_cleanup(); 549 break; 550 default: 551 UNREACHABLE; 552 } 553 return EXIT_SUCCESS; 554 } 555 556 static int 557 safe_main(int argc, char** argv, void (*add_tcs)(tc_vector&)) 558 { 559 const char* argv0 = argv[0]; 560 561 bool lflag = false; 562 atf::fs::path resfile("/dev/stdout"); 563 std::string srcdir_arg; 564 atf::tests::vars_map vars; 565 566 int ch; 567 int old_opterr; 568 569 old_opterr = opterr; 570 ::opterr = 0; 571 while ((ch = ::getopt(argc, argv, GETOPT_POSIX ":lr:s:v:")) != -1) { 572 switch (ch) { 573 case 'l': 574 lflag = true; 575 break; 576 577 case 'r': 578 resfile = atf::fs::path(::optarg); 579 break; 580 581 case 's': 582 srcdir_arg = ::optarg; 583 break; 584 585 case 'v': 586 parse_vflag(::optarg, vars); 587 break; 588 589 case ':': 590 throw usage_error("Option -%c requires an argument.", ::optopt); 591 break; 592 593 case '?': 594 default: 595 throw usage_error("Unknown option -%c.", ::optopt); 596 } 597 } 598 argc -= optind; 599 argv += optind; 600 601 // Clear getopt state just in case the test wants to use it. 602 ::opterr = old_opterr; 603 ::optind = 1; 604 #if defined(HAVE_OPTRESET) 605 ::optreset = 1; 606 #endif 607 608 vars["srcdir"] = handle_srcdir(argv0, srcdir_arg).str(); 609 610 int errcode; 611 612 tc_vector tcs; 613 if (lflag) { 614 if (argc > 0) 615 throw usage_error("Cannot provide test case names with -l"); 616 617 init_tcs(add_tcs, tcs, vars); 618 errcode = list_tcs(tcs); 619 } else { 620 if (argc == 0) 621 throw usage_error("Must provide a test case name"); 622 else if (argc > 1) 623 throw usage_error("Cannot provide more than one test case name"); 624 INV(argc == 1); 625 626 init_tcs(add_tcs, tcs, vars); 627 errcode = run_tc(tcs, argv[0], resfile); 628 } 629 for (tc_vector::iterator iter = tcs.begin(); iter != tcs.end(); iter++) { 630 impl::tc* tc = *iter; 631 632 delete tc; 633 } 634 635 return errcode; 636 } 637 638 } // anonymous namespace 639 640 namespace atf { 641 namespace tests { 642 int run_tp(int, char**, void (*)(tc_vector&)); 643 } 644 } 645 646 int 647 impl::run_tp(int argc, char** argv, void (*add_tcs)(tc_vector&)) 648 { 649 try { 650 set_program_name(argv[0]); 651 return ::safe_main(argc, argv, add_tcs); 652 } catch (const usage_error& e) { 653 std::cerr 654 << Program_Name << ": ERROR: " << e.what() << '\n' 655 << Program_Name << ": See atf-test-program(1) for usage details.\n"; 656 return EXIT_FAILURE; 657 } 658 } 659