1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2008 The NetBSD Foundation, Inc. 5 // All rights reserved. 6 // 7 // Redistribution and use in source and binary forms, with or without 8 // modification, are permitted provided that the following conditions 9 // are met: 10 // 1. Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // 2. Redistributions in binary form must reproduce the above copyright 13 // notice, this list of conditions and the following disclaimer in the 14 // documentation and/or other materials provided with the distribution. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 // 29 30 extern "C" { 31 #include <fcntl.h> 32 #include <unistd.h> 33 } 34 35 #include <cerrno> 36 #include <cstdlib> 37 #include <iostream> 38 #include <stdexcept> 39 40 #include "macros.hpp" 41 #include "utils.hpp" 42 43 #include "detail/fs.hpp" 44 #include "detail/process.hpp" 45 #include "detail/sanity.hpp" 46 #include "detail/test_helpers.hpp" 47 #include "detail/text.hpp" 48 49 // ------------------------------------------------------------------------ 50 // Auxiliary functions. 51 // ------------------------------------------------------------------------ 52 53 static 54 void 55 create_ctl_file(const char *name) 56 { 57 ATF_REQUIRE(open(name, O_CREAT | O_WRONLY | O_TRUNC, 0644) != -1); 58 } 59 60 // ------------------------------------------------------------------------ 61 // Auxiliary test cases. 62 // ------------------------------------------------------------------------ 63 64 ATF_TEST_CASE(h_pass); 65 ATF_TEST_CASE_HEAD(h_pass) 66 { 67 set_md_var("descr", "Helper test case"); 68 } 69 ATF_TEST_CASE_BODY(h_pass) 70 { 71 create_ctl_file("before"); 72 ATF_PASS(); 73 create_ctl_file("after"); 74 } 75 76 ATF_TEST_CASE(h_fail); 77 ATF_TEST_CASE_HEAD(h_fail) 78 { 79 set_md_var("descr", "Helper test case"); 80 } 81 ATF_TEST_CASE_BODY(h_fail) 82 { 83 create_ctl_file("before"); 84 ATF_FAIL("Failed on purpose"); 85 create_ctl_file("after"); 86 } 87 88 ATF_TEST_CASE(h_skip); 89 ATF_TEST_CASE_HEAD(h_skip) 90 { 91 set_md_var("descr", "Helper test case"); 92 } 93 ATF_TEST_CASE_BODY(h_skip) 94 { 95 create_ctl_file("before"); 96 ATF_SKIP("Skipped on purpose"); 97 create_ctl_file("after"); 98 } 99 100 ATF_TEST_CASE(h_require); 101 ATF_TEST_CASE_HEAD(h_require) 102 { 103 set_md_var("descr", "Helper test case"); 104 } 105 ATF_TEST_CASE_BODY(h_require) 106 { 107 bool condition = atf::text::to_bool(get_config_var("condition")); 108 109 create_ctl_file("before"); 110 ATF_REQUIRE(condition); 111 create_ctl_file("after"); 112 } 113 114 ATF_TEST_CASE(h_require_eq); 115 ATF_TEST_CASE_HEAD(h_require_eq) 116 { 117 set_md_var("descr", "Helper test case"); 118 } 119 ATF_TEST_CASE_BODY(h_require_eq) 120 { 121 long v1 = atf::text::to_type< long >(get_config_var("v1")); 122 long v2 = atf::text::to_type< long >(get_config_var("v2")); 123 124 create_ctl_file("before"); 125 ATF_REQUIRE_EQ(v1, v2); 126 create_ctl_file("after"); 127 } 128 129 ATF_TEST_CASE(h_require_in); 130 ATF_TEST_CASE_HEAD(h_require_in) 131 { 132 set_md_var("descr", "Helper test case"); 133 } 134 ATF_TEST_CASE_BODY(h_require_in) 135 { 136 const std::string element = get_config_var("value"); 137 138 std::set< std::string > collection; 139 collection.insert("foo"); 140 collection.insert("bar"); 141 collection.insert("baz"); 142 143 create_ctl_file("before"); 144 ATF_REQUIRE_IN(element, collection); 145 create_ctl_file("after"); 146 } 147 148 ATF_TEST_CASE(h_require_match); 149 ATF_TEST_CASE_HEAD(h_require_match) 150 { 151 set_md_var("descr", "Helper test case"); 152 } 153 ATF_TEST_CASE_BODY(h_require_match) 154 { 155 const std::string regexp = get_config_var("regexp"); 156 const std::string string = get_config_var("string"); 157 158 create_ctl_file("before"); 159 ATF_REQUIRE_MATCH(regexp, string); 160 create_ctl_file("after"); 161 } 162 163 ATF_TEST_CASE(h_require_not_in); 164 ATF_TEST_CASE_HEAD(h_require_not_in) 165 { 166 set_md_var("descr", "Helper test case"); 167 } 168 ATF_TEST_CASE_BODY(h_require_not_in) 169 { 170 const std::string element = get_config_var("value"); 171 172 std::set< std::string > collection; 173 collection.insert("foo"); 174 collection.insert("bar"); 175 collection.insert("baz"); 176 177 create_ctl_file("before"); 178 ATF_REQUIRE_NOT_IN(element, collection); 179 create_ctl_file("after"); 180 } 181 182 ATF_TEST_CASE(h_require_throw); 183 ATF_TEST_CASE_HEAD(h_require_throw) 184 { 185 set_md_var("descr", "Helper test case"); 186 } 187 ATF_TEST_CASE_BODY(h_require_throw) 188 { 189 create_ctl_file("before"); 190 191 if (get_config_var("what") == "throw_int") 192 ATF_REQUIRE_THROW(std::runtime_error, if (1) throw int(5)); 193 else if (get_config_var("what") == "throw_rt") 194 ATF_REQUIRE_THROW(std::runtime_error, 195 if (1) throw std::runtime_error("e")); 196 else if (get_config_var("what") == "no_throw_rt") 197 ATF_REQUIRE_THROW(std::runtime_error, 198 if (0) throw std::runtime_error("e")); 199 200 create_ctl_file("after"); 201 } 202 203 ATF_TEST_CASE(h_require_throw_re); 204 ATF_TEST_CASE_HEAD(h_require_throw_re) 205 { 206 set_md_var("descr", "Helper test case"); 207 } 208 ATF_TEST_CASE_BODY(h_require_throw_re) 209 { 210 create_ctl_file("before"); 211 212 if (get_config_var("what") == "throw_int") 213 ATF_REQUIRE_THROW_RE(std::runtime_error, "5", if (1) throw int(5)); 214 else if (get_config_var("what") == "throw_rt_match") 215 ATF_REQUIRE_THROW_RE(std::runtime_error, "foo.*baz", 216 if (1) throw std::runtime_error("a foo bar baz")); 217 else if (get_config_var("what") == "throw_rt_no_match") 218 ATF_REQUIRE_THROW_RE(std::runtime_error, "foo.*baz", 219 if (1) throw std::runtime_error("baz foo bar a")); 220 else if (get_config_var("what") == "no_throw_rt") 221 ATF_REQUIRE_THROW_RE(std::runtime_error, "e", 222 if (0) throw std::runtime_error("e")); 223 224 create_ctl_file("after"); 225 } 226 227 static int 228 errno_fail_stub(const int raised_errno) 229 { 230 errno = raised_errno; 231 return -1; 232 } 233 234 static int 235 errno_ok_stub(void) 236 { 237 return 0; 238 } 239 240 ATF_TEST_CASE(h_check_errno); 241 ATF_TEST_CASE_HEAD(h_check_errno) 242 { 243 set_md_var("descr", "Helper test case"); 244 } 245 ATF_TEST_CASE_BODY(h_check_errno) 246 { 247 create_ctl_file("before"); 248 249 if (get_config_var("what") == "no_error") 250 ATF_CHECK_ERRNO(-1, errno_ok_stub() == -1); 251 else if (get_config_var("what") == "errno_ok") 252 ATF_CHECK_ERRNO(2, errno_fail_stub(2) == -1); 253 else if (get_config_var("what") == "errno_fail") 254 ATF_CHECK_ERRNO(3, errno_fail_stub(4) == -1); 255 else 256 UNREACHABLE; 257 258 create_ctl_file("after"); 259 } 260 261 ATF_TEST_CASE(h_require_errno); 262 ATF_TEST_CASE_HEAD(h_require_errno) 263 { 264 set_md_var("descr", "Helper test case"); 265 } 266 ATF_TEST_CASE_BODY(h_require_errno) 267 { 268 create_ctl_file("before"); 269 270 if (get_config_var("what") == "no_error") 271 ATF_REQUIRE_ERRNO(-1, errno_ok_stub() == -1); 272 else if (get_config_var("what") == "errno_ok") 273 ATF_REQUIRE_ERRNO(2, errno_fail_stub(2) == -1); 274 else if (get_config_var("what") == "errno_fail") 275 ATF_REQUIRE_ERRNO(3, errno_fail_stub(4) == -1); 276 else 277 UNREACHABLE; 278 279 create_ctl_file("after"); 280 } 281 282 // ------------------------------------------------------------------------ 283 // Test cases for the macros. 284 // ------------------------------------------------------------------------ 285 286 ATF_TEST_CASE(pass); 287 ATF_TEST_CASE_HEAD(pass) 288 { 289 set_md_var("descr", "Tests the ATF_PASS macro"); 290 } 291 ATF_TEST_CASE_BODY(pass) 292 { 293 ATF_TEST_CASE_USE(h_pass); 294 run_h_tc< ATF_TEST_CASE_NAME(h_pass) >(); 295 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 296 ATF_REQUIRE(atf::fs::exists(atf::fs::path("before"))); 297 ATF_REQUIRE(!atf::fs::exists(atf::fs::path("after"))); 298 } 299 300 ATF_TEST_CASE(fail); 301 ATF_TEST_CASE_HEAD(fail) 302 { 303 set_md_var("descr", "Tests the ATF_FAIL macro"); 304 } 305 ATF_TEST_CASE_BODY(fail) 306 { 307 ATF_TEST_CASE_USE(h_fail); 308 run_h_tc< ATF_TEST_CASE_NAME(h_fail) >(); 309 ATF_REQUIRE(atf::utils::grep_file("^failed: Failed on purpose", "result")); 310 ATF_REQUIRE(atf::fs::exists(atf::fs::path("before"))); 311 ATF_REQUIRE(!atf::fs::exists(atf::fs::path("after"))); 312 } 313 314 ATF_TEST_CASE(skip); 315 ATF_TEST_CASE_HEAD(skip) 316 { 317 set_md_var("descr", "Tests the ATF_SKIP macro"); 318 } 319 ATF_TEST_CASE_BODY(skip) 320 { 321 ATF_TEST_CASE_USE(h_skip); 322 run_h_tc< ATF_TEST_CASE_NAME(h_skip) >(); 323 ATF_REQUIRE(atf::utils::grep_file("^skipped: Skipped on purpose", 324 "result")); 325 ATF_REQUIRE(atf::fs::exists(atf::fs::path("before"))); 326 ATF_REQUIRE(!atf::fs::exists(atf::fs::path("after"))); 327 } 328 329 ATF_TEST_CASE(require); 330 ATF_TEST_CASE_HEAD(require) 331 { 332 set_md_var("descr", "Tests the ATF_REQUIRE macro"); 333 } 334 ATF_TEST_CASE_BODY(require) 335 { 336 struct test { 337 const char *cond; 338 bool ok; 339 } *t, tests[] = { 340 { "false", false }, 341 { "true", true }, 342 { NULL, false } 343 }; 344 345 const atf::fs::path before("before"); 346 const atf::fs::path after("after"); 347 348 for (t = &tests[0]; t->cond != NULL; t++) { 349 atf::tests::vars_map config; 350 config["condition"] = t->cond; 351 352 std::cout << "Checking with a " << t->cond << " value\n"; 353 354 ATF_TEST_CASE_USE(h_require); 355 run_h_tc< ATF_TEST_CASE_NAME(h_require) >(config); 356 357 ATF_REQUIRE(atf::fs::exists(before)); 358 if (t->ok) { 359 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 360 ATF_REQUIRE(atf::fs::exists(after)); 361 } else { 362 ATF_REQUIRE(atf::utils::grep_file( 363 "^failed: .*condition not met", "result")); 364 ATF_REQUIRE(!atf::fs::exists(after)); 365 } 366 367 atf::fs::remove(before); 368 if (t->ok) 369 atf::fs::remove(after); 370 } 371 } 372 373 ATF_TEST_CASE(require_eq); 374 ATF_TEST_CASE_HEAD(require_eq) 375 { 376 set_md_var("descr", "Tests the ATF_REQUIRE_EQ macro"); 377 } 378 ATF_TEST_CASE_BODY(require_eq) 379 { 380 struct test { 381 const char *v1; 382 const char *v2; 383 bool ok; 384 } *t, tests[] = { 385 { "1", "1", true }, 386 { "1", "2", false }, 387 { "2", "1", false }, 388 { "2", "2", true }, 389 { NULL, NULL, false } 390 }; 391 392 const atf::fs::path before("before"); 393 const atf::fs::path after("after"); 394 395 for (t = &tests[0]; t->v1 != NULL; t++) { 396 atf::tests::vars_map config; 397 config["v1"] = t->v1; 398 config["v2"] = t->v2; 399 400 std::cout << "Checking with " << t->v1 << ", " << t->v2 401 << " and expecting " << (t->ok ? "true" : "false") 402 << "\n"; 403 404 ATF_TEST_CASE_USE(h_require_eq); 405 run_h_tc< ATF_TEST_CASE_NAME(h_require_eq) >(config); 406 407 ATF_REQUIRE(atf::fs::exists(before)); 408 if (t->ok) { 409 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 410 ATF_REQUIRE(atf::fs::exists(after)); 411 } else { 412 ATF_REQUIRE(atf::utils::grep_file("^failed: .*v1 != v2", "result")); 413 ATF_REQUIRE(!atf::fs::exists(after)); 414 } 415 416 atf::fs::remove(before); 417 if (t->ok) 418 atf::fs::remove(after); 419 } 420 } 421 422 ATF_TEST_CASE(require_in); 423 ATF_TEST_CASE_HEAD(require_in) 424 { 425 set_md_var("descr", "Tests the ATF_REQUIRE_IN macro"); 426 } 427 ATF_TEST_CASE_BODY(require_in) 428 { 429 struct test { 430 const char *value; 431 bool ok; 432 } *t, tests[] = { 433 { "foo", true }, 434 { "bar", true }, 435 { "baz", true }, 436 { "xxx", false }, 437 { "fooa", false }, 438 { "foo ", false }, 439 { NULL, false } 440 }; 441 442 const atf::fs::path before("before"); 443 const atf::fs::path after("after"); 444 445 for (t = &tests[0]; t->value != NULL; t++) { 446 atf::tests::vars_map config; 447 config["value"] = t->value; 448 449 ATF_TEST_CASE_USE(h_require_in); 450 run_h_tc< ATF_TEST_CASE_NAME(h_require_in) >(config); 451 452 ATF_REQUIRE(atf::fs::exists(before)); 453 if (t->ok) { 454 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 455 ATF_REQUIRE(atf::fs::exists(after)); 456 } else { 457 ATF_REQUIRE(atf::utils::grep_file("^failed: ", "result")); 458 ATF_REQUIRE(!atf::fs::exists(after)); 459 } 460 461 atf::fs::remove(before); 462 if (t->ok) 463 atf::fs::remove(after); 464 } 465 } 466 467 ATF_TEST_CASE(require_match); 468 ATF_TEST_CASE_HEAD(require_match) 469 { 470 set_md_var("descr", "Tests the ATF_REQUIRE_MATCH macro"); 471 } 472 ATF_TEST_CASE_BODY(require_match) 473 { 474 struct test { 475 const char *regexp; 476 const char *string; 477 bool ok; 478 } *t, tests[] = { 479 { "foo.*bar", "this is a foo, bar, baz", true }, 480 { "bar.*baz", "this is a baz, bar, foo", false }, 481 { NULL, NULL, false } 482 }; 483 484 const atf::fs::path before("before"); 485 const atf::fs::path after("after"); 486 487 for (t = &tests[0]; t->regexp != NULL; t++) { 488 atf::tests::vars_map config; 489 config["regexp"] = t->regexp; 490 config["string"] = t->string; 491 492 std::cout << "Checking with " << t->regexp << ", " << t->string 493 << " and expecting " << (t->ok ? "true" : "false") 494 << "\n"; 495 496 ATF_TEST_CASE_USE(h_require_match); 497 run_h_tc< ATF_TEST_CASE_NAME(h_require_match) >(config); 498 499 ATF_REQUIRE(atf::fs::exists(before)); 500 if (t->ok) { 501 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 502 ATF_REQUIRE(atf::fs::exists(after)); 503 } else { 504 ATF_REQUIRE(atf::utils::grep_file("^failed: ", "result")); 505 ATF_REQUIRE(!atf::fs::exists(after)); 506 } 507 508 atf::fs::remove(before); 509 if (t->ok) 510 atf::fs::remove(after); 511 } 512 } 513 514 ATF_TEST_CASE(require_not_in); 515 ATF_TEST_CASE_HEAD(require_not_in) 516 { 517 set_md_var("descr", "Tests the ATF_REQUIRE_NOT_IN macro"); 518 } 519 ATF_TEST_CASE_BODY(require_not_in) 520 { 521 struct test { 522 const char *value; 523 bool ok; 524 } *t, tests[] = { 525 { "foo", false }, 526 { "bar", false }, 527 { "baz", false }, 528 { "xxx", true }, 529 { "fooa", true }, 530 { "foo ", true }, 531 { NULL, false } 532 }; 533 534 const atf::fs::path before("before"); 535 const atf::fs::path after("after"); 536 537 for (t = &tests[0]; t->value != NULL; t++) { 538 atf::tests::vars_map config; 539 config["value"] = t->value; 540 541 ATF_TEST_CASE_USE(h_require_not_in); 542 run_h_tc< ATF_TEST_CASE_NAME(h_require_not_in) >(config); 543 544 ATF_REQUIRE(atf::fs::exists(before)); 545 if (t->ok) { 546 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 547 ATF_REQUIRE(atf::fs::exists(after)); 548 } else { 549 ATF_REQUIRE(atf::utils::grep_file("^failed: ", "result")); 550 ATF_REQUIRE(!atf::fs::exists(after)); 551 } 552 553 atf::fs::remove(before); 554 if (t->ok) 555 atf::fs::remove(after); 556 } 557 } 558 559 ATF_TEST_CASE(require_throw); 560 ATF_TEST_CASE_HEAD(require_throw) 561 { 562 set_md_var("descr", "Tests the ATF_REQUIRE_THROW macro"); 563 } 564 ATF_TEST_CASE_BODY(require_throw) 565 { 566 struct test { 567 const char *what; 568 bool ok; 569 const char *msg; 570 } *t, tests[] = { 571 { "throw_int", false, "unexpected error" }, 572 { "throw_rt", true, NULL }, 573 { "no_throw_rt", false, "did not throw" }, 574 { NULL, false, NULL } 575 }; 576 577 const atf::fs::path before("before"); 578 const atf::fs::path after("after"); 579 580 for (t = &tests[0]; t->what != NULL; t++) { 581 atf::tests::vars_map config; 582 config["what"] = t->what; 583 584 std::cout << "Checking with " << t->what << " and expecting " 585 << (t->ok ? "true" : "false") << "\n"; 586 587 ATF_TEST_CASE_USE(h_require_throw); 588 run_h_tc< ATF_TEST_CASE_NAME(h_require_throw) >(config); 589 590 ATF_REQUIRE(atf::fs::exists(before)); 591 if (t->ok) { 592 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 593 ATF_REQUIRE(atf::fs::exists(after)); 594 } else { 595 std::cout << "Checking that message contains '" << t->msg 596 << "'\n"; 597 std::string exp_result = std::string("^failed: .*") + t->msg; 598 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "result")); 599 ATF_REQUIRE(!atf::fs::exists(after)); 600 } 601 602 atf::fs::remove(before); 603 if (t->ok) 604 atf::fs::remove(after); 605 } 606 } 607 608 ATF_TEST_CASE(require_throw_re); 609 ATF_TEST_CASE_HEAD(require_throw_re) 610 { 611 set_md_var("descr", "Tests the ATF_REQUIRE_THROW_RE macro"); 612 } 613 ATF_TEST_CASE_BODY(require_throw_re) 614 { 615 struct test { 616 const char *what; 617 bool ok; 618 const char *msg; 619 } *t, tests[] = { 620 { "throw_int", false, "unexpected error" }, 621 { "throw_rt_match", true, NULL }, 622 { "throw_rt_no_match", false, 623 "threw.*runtime_error\\(baz foo bar a\\).*" 624 "does not match 'foo\\.\\*baz'" }, 625 { "no_throw_rt", false, "did not throw" }, 626 { NULL, false, NULL } 627 }; 628 629 const atf::fs::path before("before"); 630 const atf::fs::path after("after"); 631 632 for (t = &tests[0]; t->what != NULL; t++) { 633 atf::tests::vars_map config; 634 config["what"] = t->what; 635 636 std::cout << "Checking with " << t->what << " and expecting " 637 << (t->ok ? "true" : "false") << "\n"; 638 639 ATF_TEST_CASE_USE(h_require_throw_re); 640 run_h_tc< ATF_TEST_CASE_NAME(h_require_throw_re) >(config); 641 642 ATF_REQUIRE(atf::fs::exists(before)); 643 if (t->ok) { 644 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 645 ATF_REQUIRE(atf::fs::exists(after)); 646 } else { 647 std::cout << "Checking that message contains '" << t->msg 648 << "'\n"; 649 std::string exp_result = std::string("^failed: .*") + t->msg; 650 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "result")); 651 ATF_REQUIRE(!atf::fs::exists(after)); 652 } 653 654 atf::fs::remove(before); 655 if (t->ok) 656 atf::fs::remove(after); 657 } 658 } 659 660 ATF_TEST_CASE(check_errno); 661 ATF_TEST_CASE_HEAD(check_errno) 662 { 663 set_md_var("descr", "Tests the ATF_CHECK_ERRNO macro"); 664 } 665 ATF_TEST_CASE_BODY(check_errno) 666 { 667 struct test { 668 const char *what; 669 bool ok; 670 const char *msg; 671 } *t, tests[] = { 672 { "no_error", false, 673 "Expected true value in errno_ok_stub\\(\\) == -1" }, 674 { "errno_ok", true, NULL }, 675 { "errno_fail", false, 676 "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" }, 677 { NULL, false, NULL } 678 }; 679 680 const atf::fs::path before("before"); 681 const atf::fs::path after("after"); 682 683 for (t = &tests[0]; t->what != NULL; t++) { 684 atf::tests::vars_map config; 685 config["what"] = t->what; 686 687 ATF_TEST_CASE_USE(h_check_errno); 688 run_h_tc< ATF_TEST_CASE_NAME(h_check_errno) >(config); 689 690 ATF_REQUIRE(atf::fs::exists(before)); 691 ATF_REQUIRE(atf::fs::exists(after)); 692 693 if (t->ok) { 694 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 695 } else { 696 ATF_REQUIRE(atf::utils::grep_file("^failed", "result")); 697 698 std::string exp_result = "macros_test.cpp:[0-9]+: " + 699 std::string(t->msg) + "$"; 700 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "stderr")); 701 } 702 703 atf::fs::remove(before); 704 atf::fs::remove(after); 705 } 706 } 707 708 ATF_TEST_CASE(require_errno); 709 ATF_TEST_CASE_HEAD(require_errno) 710 { 711 set_md_var("descr", "Tests the ATF_REQUIRE_ERRNO macro"); 712 } 713 ATF_TEST_CASE_BODY(require_errno) 714 { 715 struct test { 716 const char *what; 717 bool ok; 718 const char *msg; 719 } *t, tests[] = { 720 { "no_error", false, 721 "Expected true value in errno_ok_stub\\(\\) == -1" }, 722 { "errno_ok", true, NULL }, 723 { "errno_fail", false, 724 "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" }, 725 { NULL, false, NULL } 726 }; 727 728 const atf::fs::path before("before"); 729 const atf::fs::path after("after"); 730 731 for (t = &tests[0]; t->what != NULL; t++) { 732 atf::tests::vars_map config; 733 config["what"] = t->what; 734 735 ATF_TEST_CASE_USE(h_require_errno); 736 run_h_tc< ATF_TEST_CASE_NAME(h_require_errno) >(config); 737 738 ATF_REQUIRE(atf::fs::exists(before)); 739 if (t->ok) { 740 ATF_REQUIRE(atf::utils::grep_file("^passed", "result")); 741 ATF_REQUIRE(atf::fs::exists(after)); 742 } else { 743 std::string exp_result = "^failed: .*macros_test.cpp:[0-9]+: " + 744 std::string(t->msg) + "$"; 745 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "result")); 746 747 ATF_REQUIRE(!atf::fs::exists(after)); 748 } 749 750 atf::fs::remove(before); 751 if (t->ok) 752 atf::fs::remove(after); 753 } 754 } 755 756 // ------------------------------------------------------------------------ 757 // Tests cases for the header file. 758 // ------------------------------------------------------------------------ 759 760 HEADER_TC(include, "atf-c++/macros.hpp"); 761 BUILD_TC(use, "macros_hpp_test.cpp", 762 "Tests that the macros provided by the atf-c++/macros.hpp file " 763 "do not cause syntax errors when used", 764 "Build of macros_hpp_test.cpp failed; some macros in " 765 "atf-c++/macros.hpp are broken"); 766 BUILD_TC_FAIL(detect_unused_tests, "unused_test.cpp", 767 "Tests that defining an unused test case raises a warning (and thus " 768 "an error)", 769 "Build of unused_test.cpp passed; unused test cases are not properly " 770 "detected"); 771 772 // ------------------------------------------------------------------------ 773 // Main. 774 // ------------------------------------------------------------------------ 775 776 ATF_INIT_TEST_CASES(tcs) 777 { 778 // Add the test cases for the macros. 779 ATF_ADD_TEST_CASE(tcs, pass); 780 ATF_ADD_TEST_CASE(tcs, fail); 781 ATF_ADD_TEST_CASE(tcs, skip); 782 ATF_ADD_TEST_CASE(tcs, check_errno); 783 ATF_ADD_TEST_CASE(tcs, require); 784 ATF_ADD_TEST_CASE(tcs, require_eq); 785 ATF_ADD_TEST_CASE(tcs, require_in); 786 ATF_ADD_TEST_CASE(tcs, require_match); 787 ATF_ADD_TEST_CASE(tcs, require_not_in); 788 ATF_ADD_TEST_CASE(tcs, require_throw); 789 ATF_ADD_TEST_CASE(tcs, require_throw_re); 790 ATF_ADD_TEST_CASE(tcs, require_errno); 791 792 // Add the test cases for the header file. 793 ATF_ADD_TEST_CASE(tcs, include); 794 ATF_ADD_TEST_CASE(tcs, use); 795 ATF_ADD_TEST_CASE(tcs, detect_unused_tests); 796 } 797