contrib/atf/atf-c++/macros_test.cpp

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