test_program_test.cpp revision 1.1.1.1.4.2
1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2010 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 #include <fstream> 31 #include <iostream> 32 33 #include <atf-c++.hpp> 34 35 #include "parser.hpp" 36 #include "test-program.hpp" 37 #include "test_helpers.hpp" 38 #include "text.hpp" 39 40 namespace impl = tools::test_program; 41 namespace detail = tools::test_program::detail; 42 43 // ------------------------------------------------------------------------- 44 // Auxiliary functions. 45 // ------------------------------------------------------------------------- 46 47 namespace { 48 49 typedef std::map< std::string, std::string > vars_map; 50 51 static 52 tools::fs::path 53 get_helper(const atf::tests::tc& tc, const char* name) 54 { 55 return tools::fs::path(tc.get_config_var("srcdir")) / name; 56 } 57 58 static 59 void 60 check_property(const vars_map& props, const char* name, const char* value) 61 { 62 const vars_map::const_iterator iter = props.find(name); 63 ATF_REQUIRE(iter != props.end()); 64 ATF_REQUIRE_EQ(value, (*iter).second); 65 } 66 67 static void 68 check_result(const char* exp_state, const int exp_value, const char* exp_reason, 69 const impl::test_case_result& tcr) 70 { 71 ATF_REQUIRE_EQ(exp_state, tcr.state()); 72 ATF_REQUIRE_EQ(exp_value, tcr.value()); 73 ATF_REQUIRE_EQ(exp_reason, tcr.reason()); 74 } 75 76 static 77 void 78 write_test_case_result(const char *results_path, const std::string& contents) 79 { 80 std::ofstream results_file(results_path); 81 ATF_REQUIRE(results_file); 82 83 results_file << contents; 84 } 85 86 static 87 void 88 print_indented(const std::string& str) 89 { 90 std::vector< std::string > ws = tools::text::split(str, "\n"); 91 for (std::vector< std::string >::const_iterator iter = ws.begin(); 92 iter != ws.end(); iter++) 93 std::cout << ">>" << *iter << "<<\n"; 94 } 95 96 // XXX Should this string handling and verbosity level be part of the 97 // ATF_REQUIRE_EQ macro? It may be hard to predict sometimes that a 98 // string can have newlines in it, and so the error message generated 99 // at the moment will be bogus if there are some. 100 static 101 void 102 check_match(const atf::tests::tc& tc, const std::string& str, 103 const std::string& exp) 104 { 105 if (!tools::text::match(str, exp)) { 106 std::cout << "String match check failed.\n" 107 << "Adding >> and << to delimit the string boundaries " 108 "below.\n"; 109 std::cout << "GOT:\n"; 110 print_indented(str); 111 std::cout << "EXPECTED:\n"; 112 print_indented(exp); 113 tc.fail("Constructed string differs from the expected one"); 114 } 115 } 116 117 } // anonymous namespace 118 119 // ------------------------------------------------------------------------- 120 // Tests for the "tp" reader. 121 // ------------------------------------------------------------------------- 122 123 class tp_reader : protected detail::atf_tp_reader { 124 void 125 got_tc(const std::string& ident, 126 const std::map< std::string, std::string >& md) 127 { 128 std::string call = "got_tc(" + ident + ", {"; 129 for (std::map< std::string, std::string >::const_iterator iter = 130 md.begin(); iter != md.end(); iter++) { 131 if (iter != md.begin()) 132 call += ", "; 133 call += (*iter).first + '=' + (*iter).second; 134 } 135 call += "})"; 136 m_calls.push_back(call); 137 } 138 139 void 140 got_eof(void) 141 { 142 m_calls.push_back("got_eof()"); 143 } 144 145 public: 146 tp_reader(std::istream& is) : 147 detail::atf_tp_reader(is) 148 { 149 } 150 151 void 152 read(void) 153 { 154 atf_tp_reader::read(); 155 } 156 157 std::vector< std::string > m_calls; 158 }; 159 160 ATF_TEST_CASE_WITHOUT_HEAD(tp_1); 161 ATF_TEST_CASE_BODY(tp_1) 162 { 163 const char* input = 164 "Content-Type: application/X-atf-tp; version=\"1\"\n" 165 "\n" 166 "ident: test_case_1\n" 167 "\n" 168 "ident: test_case_2\n" 169 "\n" 170 "ident: test_case_3\n" 171 ; 172 173 const char* exp_calls[] = { 174 "got_tc(test_case_1, {ident=test_case_1})", 175 "got_tc(test_case_2, {ident=test_case_2})", 176 "got_tc(test_case_3, {ident=test_case_3})", 177 "got_eof()", 178 NULL 179 }; 180 181 const char* exp_errors[] = { 182 NULL 183 }; 184 185 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 186 } 187 188 ATF_TEST_CASE_WITHOUT_HEAD(tp_2); 189 ATF_TEST_CASE_BODY(tp_2) 190 { 191 const char* input = 192 "Content-Type: application/X-atf-tp; version=\"1\"\n" 193 "\n" 194 "ident: test_case_1\n" 195 "descr: This is the description\n" 196 "timeout: 300\n" 197 "\n" 198 "ident: test_case_2\n" 199 "\n" 200 "ident: test_case_3\n" 201 "X-prop1: A custom property\n" 202 "descr: Third test case\n" 203 ; 204 205 // NO_CHECK_STYLE_BEGIN 206 const char* exp_calls[] = { 207 "got_tc(test_case_1, {descr=This is the description, ident=test_case_1, timeout=300})", 208 "got_tc(test_case_2, {ident=test_case_2})", 209 "got_tc(test_case_3, {X-prop1=A custom property, descr=Third test case, ident=test_case_3})", 210 "got_eof()", 211 NULL 212 }; 213 // NO_CHECK_STYLE_END 214 215 const char* exp_errors[] = { 216 NULL 217 }; 218 219 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 220 } 221 222 ATF_TEST_CASE_WITHOUT_HEAD(tp_3); 223 ATF_TEST_CASE_BODY(tp_3) 224 { 225 const char* input = 226 "Content-Type: application/X-atf-tp; version=\"1\"\n" 227 "\n" 228 "ident: single_test\n" 229 "descr: Some description\n" 230 "timeout: 300\n" 231 "require.arch: thearch\n" 232 "require.config: foo-bar\n" 233 "require.files: /a/1 /b/2\n" 234 "require.machine: themachine\n" 235 "require.progs: /bin/cp mv\n" 236 "require.user: root\n" 237 ; 238 239 // NO_CHECK_STYLE_BEGIN 240 const char* exp_calls[] = { 241 "got_tc(single_test, {descr=Some description, ident=single_test, require.arch=thearch, require.config=foo-bar, require.files=/a/1 /b/2, require.machine=themachine, require.progs=/bin/cp mv, require.user=root, timeout=300})", 242 "got_eof()", 243 NULL 244 }; 245 // NO_CHECK_STYLE_END 246 247 const char* exp_errors[] = { 248 NULL 249 }; 250 251 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 252 } 253 254 ATF_TEST_CASE_WITHOUT_HEAD(tp_4); 255 ATF_TEST_CASE_BODY(tp_4) 256 { 257 const char* input = 258 "Content-Type: application/X-atf-tp; version=\"1\"\n" 259 "\n" 260 "ident: single_test \n" 261 "descr: Some description \n" 262 ; 263 264 const char* exp_calls[] = { 265 "got_tc(single_test, {descr=Some description, ident=single_test})", 266 "got_eof()", 267 NULL 268 }; 269 270 const char* exp_errors[] = { 271 NULL 272 }; 273 274 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 275 } 276 277 ATF_TEST_CASE_WITHOUT_HEAD(tp_50); 278 ATF_TEST_CASE_BODY(tp_50) 279 { 280 const char* input = 281 "Content-Type: application/X-atf-tp; version=\"1\"\n" 282 "\n" 283 ; 284 285 const char* exp_calls[] = { 286 NULL 287 }; 288 289 const char* exp_errors[] = { 290 "3: Unexpected token `<<EOF>>'; expected property name", 291 NULL 292 }; 293 294 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 295 } 296 297 ATF_TEST_CASE_WITHOUT_HEAD(tp_51); 298 ATF_TEST_CASE_BODY(tp_51) 299 { 300 const char* input = 301 "Content-Type: application/X-atf-tp; version=\"1\"\n" 302 "\n" 303 "\n" 304 "\n" 305 "\n" 306 ; 307 308 const char* exp_calls[] = { 309 NULL 310 }; 311 312 const char* exp_errors[] = { 313 "3: Unexpected token `<<NEWLINE>>'; expected property name", 314 NULL 315 }; 316 317 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 318 } 319 320 ATF_TEST_CASE_WITHOUT_HEAD(tp_52); 321 ATF_TEST_CASE_BODY(tp_52) 322 { 323 const char* input = 324 "Content-Type: application/X-atf-tp; version=\"1\"\n" 325 "\n" 326 "ident: test1\n" 327 "ident: test2\n" 328 ; 329 330 const char* exp_calls[] = { 331 "got_tc(test1, {ident=test1})", 332 "got_eof()", 333 NULL 334 }; 335 336 const char* exp_errors[] = { 337 NULL 338 }; 339 340 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 341 } 342 343 ATF_TEST_CASE_WITHOUT_HEAD(tp_53); 344 ATF_TEST_CASE_BODY(tp_53) 345 { 346 const char* input = 347 "Content-Type: application/X-atf-tp; version=\"1\"\n" 348 "\n" 349 "descr: Out of order\n" 350 "ident: test1\n" 351 ; 352 353 const char* exp_calls[] = { 354 NULL 355 }; 356 357 const char* exp_errors[] = { 358 "3: First property of a test case must be 'ident'", 359 NULL 360 }; 361 362 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 363 } 364 365 ATF_TEST_CASE_WITHOUT_HEAD(tp_54); 366 ATF_TEST_CASE_BODY(tp_54) 367 { 368 const char* input = 369 "Content-Type: application/X-atf-tp; version=\"1\"\n" 370 "\n" 371 "ident:\n" 372 ; 373 374 const char* exp_calls[] = { 375 NULL 376 }; 377 378 const char* exp_errors[] = { 379 "3: The value for 'ident' cannot be empty", 380 NULL 381 }; 382 383 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 384 } 385 386 ATF_TEST_CASE_WITHOUT_HEAD(tp_55); 387 ATF_TEST_CASE_BODY(tp_55) 388 { 389 const char* input = 390 "Content-Type: application/X-atf-tp; version=\"1\"\n" 391 "\n" 392 "ident: +*,\n" 393 ; 394 395 const char* exp_calls[] = { 396 NULL 397 }; 398 399 const char* exp_errors[] = { 400 "3: The identifier must match ^[_A-Za-z0-9]+$; was '+*,'", 401 NULL 402 }; 403 404 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 405 } 406 407 ATF_TEST_CASE_WITHOUT_HEAD(tp_56); 408 ATF_TEST_CASE_BODY(tp_56) 409 { 410 const char* input = 411 "Content-Type: application/X-atf-tp; version=\"1\"\n" 412 "\n" 413 "ident: test\n" 414 "timeout: hello\n" 415 ; 416 417 const char* exp_calls[] = { 418 NULL 419 }; 420 421 const char* exp_errors[] = { 422 "4: The timeout property requires an integer value", 423 NULL 424 }; 425 426 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 427 } 428 429 ATF_TEST_CASE_WITHOUT_HEAD(tp_57); 430 ATF_TEST_CASE_BODY(tp_57) 431 { 432 const char* input = 433 "Content-Type: application/X-atf-tp; version=\"1\"\n" 434 "\n" 435 "ident: test\n" 436 "unknown: property\n" 437 ; 438 439 const char* exp_calls[] = { 440 NULL 441 }; 442 443 const char* exp_errors[] = { 444 "4: Unknown property 'unknown'", 445 NULL 446 }; 447 448 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 449 } 450 451 ATF_TEST_CASE_WITHOUT_HEAD(tp_58); 452 ATF_TEST_CASE_BODY(tp_58) 453 { 454 const char* input = 455 "Content-Type: application/X-atf-tp; version=\"1\"\n" 456 "\n" 457 "ident: test\n" 458 "X-foo:\n" 459 ; 460 461 const char* exp_calls[] = { 462 NULL 463 }; 464 465 const char* exp_errors[] = { 466 "4: The value for 'X-foo' cannot be empty", 467 NULL 468 }; 469 470 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 471 } 472 473 ATF_TEST_CASE_WITHOUT_HEAD(tp_59); 474 ATF_TEST_CASE_BODY(tp_59) 475 { 476 const char* input = 477 "Content-Type: application/X-atf-tp; version=\"1\"\n" 478 "\n" 479 "\n" 480 "ident: test\n" 481 "timeout: 300\n" 482 ; 483 484 const char* exp_calls[] = { 485 NULL 486 }; 487 488 const char* exp_errors[] = { 489 "3: Unexpected token `<<NEWLINE>>'; expected property name", 490 NULL 491 }; 492 493 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 494 } 495 496 ATF_TEST_CASE_WITHOUT_HEAD(tp_60); 497 ATF_TEST_CASE_BODY(tp_60) 498 { 499 const char* input = 500 "Content-Type: application/X-atf-tp; version=\"1\"\n" 501 "\n" 502 "ident: test\n" 503 "require.memory: 12345D\n" 504 ; 505 506 const char* exp_calls[] = { 507 NULL 508 }; 509 510 const char* exp_errors[] = { 511 "4: The require.memory property requires an integer value representing" 512 " an amount of bytes", 513 NULL 514 }; 515 516 do_parser_test< tp_reader >(input, exp_calls, exp_errors); 517 } 518 519 // ------------------------------------------------------------------------- 520 // Tests for the "tps" writer. 521 // ------------------------------------------------------------------------- 522 523 ATF_TEST_CASE(atf_tps_writer); 524 ATF_TEST_CASE_HEAD(atf_tps_writer) 525 { 526 set_md_var("descr", "Verifies the application/X-atf-tps writer"); 527 } 528 ATF_TEST_CASE_BODY(atf_tps_writer) 529 { 530 std::ostringstream expss; 531 std::ostringstream ss; 532 const char *ts_regex = "[0-9]+\\.[0-9]{1,6}, "; 533 534 #define RESET \ 535 expss.str(""); \ 536 ss.str("") 537 538 #define CHECK \ 539 check_match(*this, ss.str(), expss.str()) 540 541 { 542 RESET; 543 544 impl::atf_tps_writer w(ss); 545 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 546 CHECK; 547 } 548 549 { 550 RESET; 551 552 impl::atf_tps_writer w(ss); 553 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 554 CHECK; 555 556 w.info("foo", "bar"); 557 expss << "info: foo, bar\n"; 558 CHECK; 559 560 w.info("baz", "second info"); 561 expss << "info: baz, second info\n"; 562 CHECK; 563 } 564 565 { 566 RESET; 567 568 impl::atf_tps_writer w(ss); 569 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 570 CHECK; 571 572 w.ntps(0); 573 expss << "tps-count: 0\n"; 574 CHECK; 575 } 576 577 { 578 RESET; 579 580 impl::atf_tps_writer w(ss); 581 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 582 CHECK; 583 584 w.ntps(123); 585 expss << "tps-count: 123\n"; 586 CHECK; 587 } 588 589 { 590 RESET; 591 592 impl::atf_tps_writer w(ss); 593 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 594 CHECK; 595 596 w.ntps(2); 597 expss << "tps-count: 2\n"; 598 CHECK; 599 600 w.start_tp("foo", 0); 601 expss << "tp-start: " << ts_regex << "foo, 0\n"; 602 CHECK; 603 604 w.end_tp(""); 605 expss << "tp-end: " << ts_regex << "foo\n"; 606 CHECK; 607 608 w.start_tp("bar", 0); 609 expss << "tp-start: " << ts_regex << "bar, 0\n"; 610 CHECK; 611 612 w.end_tp("failed program"); 613 expss << "tp-end: " << ts_regex << "bar, failed program\n"; 614 CHECK; 615 } 616 617 { 618 RESET; 619 620 impl::atf_tps_writer w(ss); 621 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 622 CHECK; 623 624 w.ntps(1); 625 expss << "tps-count: 1\n"; 626 CHECK; 627 628 w.start_tp("foo", 1); 629 expss << "tp-start: " << ts_regex << "foo, 1\n"; 630 CHECK; 631 632 w.start_tc("brokentc"); 633 expss << "tc-start: " << ts_regex << "brokentc\n"; 634 CHECK; 635 636 w.end_tp("aborted"); 637 expss << "tp-end: " << ts_regex << "foo, aborted\n"; 638 CHECK; 639 } 640 641 { 642 RESET; 643 644 impl::atf_tps_writer w(ss); 645 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 646 CHECK; 647 648 w.ntps(1); 649 expss << "tps-count: 1\n"; 650 CHECK; 651 652 w.start_tp("thetp", 3); 653 expss << "tp-start: " << ts_regex << "thetp, 3\n"; 654 CHECK; 655 656 w.start_tc("passtc"); 657 expss << "tc-start: " << ts_regex << "passtc\n"; 658 CHECK; 659 660 w.end_tc("passed", ""); 661 expss << "tc-end: " << ts_regex << "passtc, passed\n"; 662 CHECK; 663 664 w.start_tc("failtc"); 665 expss << "tc-start: " << ts_regex << "failtc\n"; 666 CHECK; 667 668 w.end_tc("failed", "The reason"); 669 expss << "tc-end: " << ts_regex << "failtc, failed, The reason\n"; 670 CHECK; 671 672 w.start_tc("skiptc"); 673 expss << "tc-start: " << ts_regex << "skiptc\n"; 674 CHECK; 675 676 w.end_tc("skipped", "The reason"); 677 expss << "tc-end: " << ts_regex << "skiptc, skipped, The reason\n"; 678 CHECK; 679 680 w.end_tp(""); 681 expss << "tp-end: " << ts_regex << "thetp\n"; 682 CHECK; 683 } 684 685 { 686 RESET; 687 688 impl::atf_tps_writer w(ss); 689 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 690 CHECK; 691 692 w.ntps(1); 693 expss << "tps-count: 1\n"; 694 CHECK; 695 696 w.start_tp("thetp", 1); 697 expss << "tp-start: " << ts_regex << "thetp, 1\n"; 698 CHECK; 699 700 w.start_tc("thetc"); 701 expss << "tc-start: " << ts_regex << "thetc\n"; 702 CHECK; 703 704 w.stdout_tc("a line"); 705 expss << "tc-so:a line\n"; 706 CHECK; 707 708 w.stdout_tc("another line"); 709 expss << "tc-so:another line\n"; 710 CHECK; 711 712 w.stderr_tc("an error message"); 713 expss << "tc-se:an error message\n"; 714 CHECK; 715 716 w.end_tc("passed", ""); 717 expss << "tc-end: " << ts_regex << "thetc, passed\n"; 718 CHECK; 719 720 w.end_tp(""); 721 expss << "tp-end: " << ts_regex << "thetp\n"; 722 CHECK; 723 } 724 725 { 726 RESET; 727 728 impl::atf_tps_writer w(ss); 729 expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 730 CHECK; 731 732 w.ntps(1); 733 expss << "tps-count: 1\n"; 734 CHECK; 735 736 w.start_tp("thetp", 0); 737 expss << "tp-start: " << ts_regex << "thetp, 0\n"; 738 CHECK; 739 740 w.end_tp(""); 741 expss << "tp-end: " << ts_regex << "thetp\n"; 742 CHECK; 743 744 w.info("foo", "bar"); 745 expss << "info: foo, bar\n"; 746 CHECK; 747 748 w.info("baz", "second value"); 749 expss << "info: baz, second value\n"; 750 CHECK; 751 } 752 753 #undef CHECK 754 #undef RESET 755 } 756 757 // ------------------------------------------------------------------------- 758 // Tests for the free functions. 759 // ------------------------------------------------------------------------- 760 761 ATF_TEST_CASE(get_metadata_bad); 762 ATF_TEST_CASE_HEAD(get_metadata_bad) {} 763 ATF_TEST_CASE_BODY(get_metadata_bad) { 764 const tools::fs::path executable = get_helper(*this, "bad_metadata_helper"); 765 ATF_REQUIRE_THROW(tools::parser::parse_errors, 766 impl::get_metadata(executable, vars_map())); 767 } 768 769 ATF_TEST_CASE(get_metadata_zero_tcs); 770 ATF_TEST_CASE_HEAD(get_metadata_zero_tcs) {} 771 ATF_TEST_CASE_BODY(get_metadata_zero_tcs) { 772 const tools::fs::path executable = get_helper(*this, "zero_tcs_helper"); 773 ATF_REQUIRE_THROW(tools::parser::parse_errors, 774 impl::get_metadata(executable, vars_map())); 775 } 776 777 ATF_TEST_CASE(get_metadata_several_tcs); 778 ATF_TEST_CASE_HEAD(get_metadata_several_tcs) {} 779 ATF_TEST_CASE_BODY(get_metadata_several_tcs) { 780 const tools::fs::path executable = get_helper(*this, "several_tcs_helper"); 781 const impl::metadata md = impl::get_metadata(executable, vars_map()); 782 ATF_REQUIRE_EQ(3, md.test_cases.size()); 783 784 { 785 const impl::test_cases_map::const_iterator iter = 786 md.test_cases.find("first"); 787 ATF_REQUIRE(iter != md.test_cases.end()); 788 789 ATF_REQUIRE_EQ(4, (*iter).second.size()); 790 check_property((*iter).second, "descr", "Description 1"); 791 check_property((*iter).second, "has.cleanup", "false"); 792 check_property((*iter).second, "ident", "first"); 793 check_property((*iter).second, "timeout", "300"); 794 } 795 796 { 797 const impl::test_cases_map::const_iterator iter = 798 md.test_cases.find("second"); 799 ATF_REQUIRE(iter != md.test_cases.end()); 800 801 ATF_REQUIRE_EQ(5, (*iter).second.size()); 802 check_property((*iter).second, "descr", "Description 2"); 803 check_property((*iter).second, "has.cleanup", "true"); 804 check_property((*iter).second, "ident", "second"); 805 check_property((*iter).second, "timeout", "500"); 806 check_property((*iter).second, "X-property", "Custom property"); 807 } 808 809 { 810 const impl::test_cases_map::const_iterator iter = 811 md.test_cases.find("third"); 812 ATF_REQUIRE(iter != md.test_cases.end()); 813 814 ATF_REQUIRE_EQ(3, (*iter).second.size()); 815 check_property((*iter).second, "has.cleanup", "false"); 816 check_property((*iter).second, "ident", "third"); 817 check_property((*iter).second, "timeout", "300"); 818 } 819 } 820 821 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_death); 822 ATF_TEST_CASE_BODY(parse_test_case_result_expected_death) { 823 check_result("expected_death", -1, "foo bar", 824 detail::parse_test_case_result("expected_death: foo bar")); 825 826 ATF_REQUIRE_THROW(std::runtime_error, 827 detail::parse_test_case_result("expected_death")); 828 ATF_REQUIRE_THROW(std::runtime_error, 829 detail::parse_test_case_result("expected_death(3): foo")); 830 } 831 832 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_exit); 833 ATF_TEST_CASE_BODY(parse_test_case_result_expected_exit) { 834 check_result("expected_exit", -1, "foo bar", 835 detail::parse_test_case_result("expected_exit: foo bar")); 836 check_result("expected_exit", -1, "foo bar", 837 detail::parse_test_case_result("expected_exit(): foo bar")); 838 check_result("expected_exit", 5, "foo bar", 839 detail::parse_test_case_result("expected_exit(5): foo bar")); 840 841 ATF_REQUIRE_THROW(std::runtime_error, 842 detail::parse_test_case_result("expected_exit")); 843 ATF_REQUIRE_THROW(std::runtime_error, 844 detail::parse_test_case_result("expected_exit(")); 845 } 846 847 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_failure); 848 ATF_TEST_CASE_BODY(parse_test_case_result_expected_failure) { 849 check_result("expected_failure", -1, "foo bar", 850 detail::parse_test_case_result("expected_failure: foo bar")); 851 852 ATF_REQUIRE_THROW(std::runtime_error, 853 detail::parse_test_case_result("expected_failure")); 854 ATF_REQUIRE_THROW(std::runtime_error, 855 detail::parse_test_case_result("expected_failure(3): foo")); 856 } 857 858 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_signal); 859 ATF_TEST_CASE_BODY(parse_test_case_result_expected_signal) { 860 check_result("expected_signal", -1, "foo bar", 861 detail::parse_test_case_result("expected_signal: foo bar")); 862 check_result("expected_signal", -1, "foo bar", 863 detail::parse_test_case_result("expected_signal(): foo bar")); 864 check_result("expected_signal", 5, "foo bar", 865 detail::parse_test_case_result("expected_signal(5): foo bar")); 866 867 ATF_REQUIRE_THROW(std::runtime_error, 868 detail::parse_test_case_result("expected_signal")); 869 ATF_REQUIRE_THROW(std::runtime_error, 870 detail::parse_test_case_result("expected_signal(")); 871 } 872 873 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_timeout); 874 ATF_TEST_CASE_BODY(parse_test_case_result_expected_timeout) { 875 check_result("expected_timeout", -1, "foo bar", 876 detail::parse_test_case_result("expected_timeout: foo bar")); 877 878 ATF_REQUIRE_THROW(std::runtime_error, 879 detail::parse_test_case_result("expected_timeout")); 880 ATF_REQUIRE_THROW(std::runtime_error, 881 detail::parse_test_case_result("expected_timeout(3): foo")); 882 } 883 884 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_failed); 885 ATF_TEST_CASE_BODY(parse_test_case_result_failed) { 886 check_result("failed", -1, "foo bar", 887 detail::parse_test_case_result("failed: foo bar")); 888 889 ATF_REQUIRE_THROW(std::runtime_error, 890 detail::parse_test_case_result("failed")); 891 ATF_REQUIRE_THROW(std::runtime_error, 892 detail::parse_test_case_result("failed(3): foo")); 893 } 894 895 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_passed); 896 ATF_TEST_CASE_BODY(parse_test_case_result_passed) { 897 check_result("passed", -1, "", 898 detail::parse_test_case_result("passed")); 899 900 ATF_REQUIRE_THROW(std::runtime_error, 901 detail::parse_test_case_result("passed: foo")); 902 ATF_REQUIRE_THROW(std::runtime_error, 903 detail::parse_test_case_result("passed(3): foo")); 904 } 905 906 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_skipped); 907 ATF_TEST_CASE_BODY(parse_test_case_result_skipped) { 908 check_result("skipped", -1, "foo bar", 909 detail::parse_test_case_result("skipped: foo bar")); 910 911 ATF_REQUIRE_THROW(std::runtime_error, 912 detail::parse_test_case_result("skipped")); 913 ATF_REQUIRE_THROW(std::runtime_error, 914 detail::parse_test_case_result("skipped(3): foo")); 915 } 916 917 ATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_unknown); 918 ATF_TEST_CASE_BODY(parse_test_case_result_unknown) { 919 ATF_REQUIRE_THROW(std::runtime_error, 920 detail::parse_test_case_result("foo")); 921 ATF_REQUIRE_THROW(std::runtime_error, 922 detail::parse_test_case_result("bar: foo")); 923 ATF_REQUIRE_THROW(std::runtime_error, 924 detail::parse_test_case_result("baz: foo")); 925 } 926 927 ATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_failed); 928 ATF_TEST_CASE_BODY(read_test_case_result_failed) { 929 write_test_case_result("resfile", "failed: foo bar\n"); 930 const impl::test_case_result tcr = impl::read_test_case_result( 931 tools::fs::path("resfile")); 932 ATF_REQUIRE_EQ("failed", tcr.state()); 933 ATF_REQUIRE_EQ("foo bar", tcr.reason()); 934 } 935 936 ATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_skipped); 937 ATF_TEST_CASE_BODY(read_test_case_result_skipped) { 938 write_test_case_result("resfile", "skipped: baz bar\n"); 939 const impl::test_case_result tcr = impl::read_test_case_result( 940 tools::fs::path("resfile")); 941 ATF_REQUIRE_EQ("skipped", tcr.state()); 942 ATF_REQUIRE_EQ("baz bar", tcr.reason()); 943 } 944 945 946 ATF_TEST_CASE(read_test_case_result_no_file); 947 ATF_TEST_CASE_HEAD(read_test_case_result_no_file) {} 948 ATF_TEST_CASE_BODY(read_test_case_result_no_file) { 949 ATF_REQUIRE_THROW(std::runtime_error, 950 impl::read_test_case_result(tools::fs::path("resfile"))); 951 } 952 953 ATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_empty_file); 954 ATF_TEST_CASE_BODY(read_test_case_result_empty_file) { 955 write_test_case_result("resfile", ""); 956 ATF_REQUIRE_THROW(std::runtime_error, 957 impl::read_test_case_result(tools::fs::path("resfile"))); 958 } 959 960 ATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_invalid); 961 ATF_TEST_CASE_BODY(read_test_case_result_invalid) { 962 write_test_case_result("resfile", "passed: hello\n"); 963 ATF_REQUIRE_THROW(std::runtime_error, 964 impl::read_test_case_result(tools::fs::path("resfile"))); 965 } 966 967 ATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_multiline); 968 ATF_TEST_CASE_BODY(read_test_case_result_multiline) { 969 write_test_case_result("resfile", "skipped: foo\nbar\n"); 970 const impl::test_case_result tcr = impl::read_test_case_result( 971 tools::fs::path("resfile")); 972 ATF_REQUIRE_EQ("skipped", tcr.state()); 973 ATF_REQUIRE_EQ("foo<<NEWLINE UNEXPECTED>>bar", tcr.reason()); 974 } 975 976 // ------------------------------------------------------------------------- 977 // Main. 978 // ------------------------------------------------------------------------- 979 980 ATF_INIT_TEST_CASES(tcs) 981 { 982 ATF_ADD_TEST_CASE(tcs, tp_1); 983 ATF_ADD_TEST_CASE(tcs, tp_2); 984 ATF_ADD_TEST_CASE(tcs, tp_3); 985 ATF_ADD_TEST_CASE(tcs, tp_4); 986 ATF_ADD_TEST_CASE(tcs, tp_50); 987 ATF_ADD_TEST_CASE(tcs, tp_51); 988 ATF_ADD_TEST_CASE(tcs, tp_52); 989 ATF_ADD_TEST_CASE(tcs, tp_53); 990 ATF_ADD_TEST_CASE(tcs, tp_54); 991 ATF_ADD_TEST_CASE(tcs, tp_55); 992 ATF_ADD_TEST_CASE(tcs, tp_56); 993 ATF_ADD_TEST_CASE(tcs, tp_57); 994 ATF_ADD_TEST_CASE(tcs, tp_58); 995 ATF_ADD_TEST_CASE(tcs, tp_59); 996 ATF_ADD_TEST_CASE(tcs, tp_60); 997 998 ATF_ADD_TEST_CASE(tcs, atf_tps_writer); 999 1000 ATF_ADD_TEST_CASE(tcs, get_metadata_bad); 1001 ATF_ADD_TEST_CASE(tcs, get_metadata_zero_tcs); 1002 ATF_ADD_TEST_CASE(tcs, get_metadata_several_tcs); 1003 1004 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_death); 1005 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_exit); 1006 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_failure); 1007 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_signal); 1008 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_timeout); 1009 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_failed); 1010 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_passed); 1011 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_skipped); 1012 ATF_ADD_TEST_CASE(tcs, parse_test_case_result_unknown); 1013 1014 ATF_ADD_TEST_CASE(tcs, read_test_case_result_failed); 1015 ATF_ADD_TEST_CASE(tcs, read_test_case_result_skipped); 1016 ATF_ADD_TEST_CASE(tcs, read_test_case_result_no_file); 1017 ATF_ADD_TEST_CASE(tcs, read_test_case_result_empty_file); 1018 ATF_ADD_TEST_CASE(tcs, read_test_case_result_multiline); 1019 ATF_ADD_TEST_CASE(tcs, read_test_case_result_invalid); 1020 1021 // TODO: Add tests for run_test_case once all the missing functionality 1022 // is implemented. 1023 } 1024
Indexes created Tue Mar 17 00:23:13 UTC 2026