1/* 2 * Automated Testing Framework (atf) 3 * 4 * Copyright (c) 2007, 2008, 2009, 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 <sys/types.h> 31#include <sys/wait.h> 32#include <fcntl.h> 33#include <unistd.h> 34 35#include <signal.h> 36#include <stdio.h> 37#include <stdlib.h> 38#include <string.h> 39 40#include <atf-c.h> 41 42#include "atf-c/error.h" 43 44#include "atf-c/detail/env.h" 45#include "atf-c/detail/fs.h" 46#include "atf-c/detail/test_helpers.h" 47#include "atf-c/detail/text.h" 48 49/* --------------------------------------------------------------------- 50 * Auxiliary functions. 51 * --------------------------------------------------------------------- */ 52 53static 54void 55safe_remove(const char* path) 56{ 57 if (unlink(path) == -1) 58 atf_tc_fail("unlink(2) of %s failed", path); 59} 60 61static 62void 63touch(const char *path) 64{ 65 int fd; 66 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0644); 67 if (fd == -1) 68 atf_tc_fail("Could not create file %s", path); 69 close(fd); 70} 71 72/* --------------------------------------------------------------------- 73 * Helper tests for "t_cleanup". 74 * --------------------------------------------------------------------- */ 75 76ATF_TC_WITH_CLEANUP(cleanup_pass); 77ATF_TC_HEAD(cleanup_pass, tc) 78{ 79 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test " 80 "program"); 81} 82ATF_TC_BODY(cleanup_pass, tc) 83{ 84 touch(atf_tc_get_config_var(tc, "tmpfile")); 85} 86ATF_TC_CLEANUP(cleanup_pass, tc) 87{ 88 if (atf_tc_get_config_var_as_bool(tc, "cleanup")) 89 safe_remove(atf_tc_get_config_var(tc, "tmpfile")); 90} 91 92ATF_TC_WITH_CLEANUP(cleanup_fail); 93ATF_TC_HEAD(cleanup_fail, tc) 94{ 95 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test " 96 "program"); 97} 98ATF_TC_BODY(cleanup_fail, tc) 99{ 100 touch(atf_tc_get_config_var(tc, "tmpfile")); 101 atf_tc_fail("On purpose"); 102} 103ATF_TC_CLEANUP(cleanup_fail, tc) 104{ 105 if (atf_tc_get_config_var_as_bool(tc, "cleanup")) 106 safe_remove(atf_tc_get_config_var(tc, "tmpfile")); 107} 108 109ATF_TC_WITH_CLEANUP(cleanup_skip); 110ATF_TC_HEAD(cleanup_skip, tc) 111{ 112 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test " 113 "program"); 114} 115ATF_TC_BODY(cleanup_skip, tc) 116{ 117 touch(atf_tc_get_config_var(tc, "tmpfile")); 118 atf_tc_skip("On purpose"); 119} 120ATF_TC_CLEANUP(cleanup_skip, tc) 121{ 122 if (atf_tc_get_config_var_as_bool(tc, "cleanup")) 123 safe_remove(atf_tc_get_config_var(tc, "tmpfile")); 124} 125 126ATF_TC_WITH_CLEANUP(cleanup_curdir); 127ATF_TC_HEAD(cleanup_curdir, tc) 128{ 129 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test " 130 "program"); 131} 132ATF_TC_BODY(cleanup_curdir, tc) 133{ 134 FILE *f; 135 136 f = fopen("oldvalue", "w"); 137 if (f == NULL) 138 atf_tc_fail("Failed to create oldvalue file"); 139 fprintf(f, "1234"); 140 fclose(f); 141} 142ATF_TC_CLEANUP(cleanup_curdir, tc) 143{ 144 FILE *f; 145 146 f = fopen("oldvalue", "r"); 147 if (f != NULL) { 148 int i; 149 if (fscanf(f, "%d", &i) != 1) 150 fprintf(stderr, "Failed to read old value\n"); 151 else 152 printf("Old value: %d", i); 153 fclose(f); 154 } 155} 156 157ATF_TC_WITH_CLEANUP(cleanup_sigterm); 158ATF_TC_HEAD(cleanup_sigterm, tc) 159{ 160 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test " 161 "program"); 162} 163ATF_TC_BODY(cleanup_sigterm, tc) 164{ 165 char *nofile; 166 167 touch(atf_tc_get_config_var(tc, "tmpfile")); 168 kill(getpid(), SIGTERM); 169 170 RE(atf_text_format(&nofile, "%s.no", 171 atf_tc_get_config_var(tc, "tmpfile"))); 172 touch(nofile); 173 free(nofile); 174} 175ATF_TC_CLEANUP(cleanup_sigterm, tc) 176{ 177 safe_remove(atf_tc_get_config_var(tc, "tmpfile")); 178} 179 180ATF_TC_WITH_CLEANUP(cleanup_fork); 181ATF_TC_HEAD(cleanup_fork, tc) 182{ 183 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test " 184 "program"); 185} 186ATF_TC_BODY(cleanup_fork, tc) 187{ 188} 189ATF_TC_CLEANUP(cleanup_fork, tc) 190{ 191 close(STDOUT_FILENO); 192 close(STDERR_FILENO); 193 close(3); 194} 195 196/* --------------------------------------------------------------------- 197 * Helper tests for "t_config". 198 * --------------------------------------------------------------------- */ 199 200ATF_TC(config_unset); 201ATF_TC_HEAD(config_unset, tc) 202{ 203 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test " 204 "program"); 205} 206ATF_TC_BODY(config_unset, tc) 207{ 208 ATF_REQUIRE(!atf_tc_has_config_var(tc, "test")); 209} 210 211ATF_TC(config_empty); 212ATF_TC_HEAD(config_empty, tc) 213{ 214 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test " 215 "program"); 216} 217ATF_TC_BODY(config_empty, tc) 218{ 219 ATF_REQUIRE(atf_tc_has_config_var(tc, "test")); 220 ATF_REQUIRE(strlen(atf_tc_get_config_var(tc, "test")) == 0); 221} 222 223ATF_TC(config_value); 224ATF_TC_HEAD(config_value, tc) 225{ 226 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test " 227 "program"); 228} 229ATF_TC_BODY(config_value, tc) 230{ 231 ATF_REQUIRE(atf_tc_has_config_var(tc, "test")); 232 ATF_REQUIRE(strcmp(atf_tc_get_config_var(tc, "test"), "foo") == 0); 233} 234 235ATF_TC(config_multi_value); 236ATF_TC_HEAD(config_multi_value, tc) 237{ 238 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test " 239 "program"); 240} 241ATF_TC_BODY(config_multi_value, tc) 242{ 243 ATF_REQUIRE(atf_tc_has_config_var(tc, "test")); 244 ATF_REQUIRE(strcmp(atf_tc_get_config_var(tc, "test"), "foo bar") == 0); 245} 246 247/* --------------------------------------------------------------------- 248 * Helper tests for "t_expect". 249 * --------------------------------------------------------------------- */ 250 251ATF_TC_WITHOUT_HEAD(expect_pass_and_pass); 252ATF_TC_BODY(expect_pass_and_pass, tc) 253{ 254 atf_tc_expect_pass(); 255 256} 257 258ATF_TC_WITHOUT_HEAD(expect_pass_but_fail_requirement); 259ATF_TC_BODY(expect_pass_but_fail_requirement, tc) 260{ 261 atf_tc_expect_pass(); 262 atf_tc_fail("Some reason"); 263} 264 265ATF_TC_WITHOUT_HEAD(expect_pass_but_fail_check); 266ATF_TC_BODY(expect_pass_but_fail_check, tc) 267{ 268 atf_tc_expect_pass(); 269 atf_tc_fail_nonfatal("Some reason"); 270} 271 272ATF_TC_WITHOUT_HEAD(expect_fail_and_fail_requirement); 273ATF_TC_BODY(expect_fail_and_fail_requirement, tc) 274{ 275 atf_tc_expect_fail("Fail %s", "reason"); 276 atf_tc_fail("The failure"); 277 atf_tc_expect_pass(); 278} 279 280ATF_TC_WITHOUT_HEAD(expect_fail_and_fail_check); 281ATF_TC_BODY(expect_fail_and_fail_check, tc) 282{ 283 atf_tc_expect_fail("Fail first"); 284 atf_tc_fail_nonfatal("abc"); 285 atf_tc_expect_pass(); 286 287 atf_tc_expect_fail("And fail again"); 288 atf_tc_fail_nonfatal("def"); 289 atf_tc_expect_pass(); 290} 291 292ATF_TC_WITHOUT_HEAD(expect_fail_but_pass); 293ATF_TC_BODY(expect_fail_but_pass, tc) 294{ 295 atf_tc_expect_fail("Fail first"); 296 atf_tc_fail_nonfatal("abc"); 297 atf_tc_expect_pass(); 298 299 atf_tc_expect_fail("Will not fail"); 300 atf_tc_expect_pass(); 301 302 atf_tc_expect_fail("And fail again"); 303 atf_tc_fail_nonfatal("def"); 304 atf_tc_expect_pass(); 305} 306 307ATF_TC_WITHOUT_HEAD(expect_exit_any_and_exit); 308ATF_TC_BODY(expect_exit_any_and_exit, tc) 309{ 310 atf_tc_expect_exit(-1, "Call will exit"); 311 exit(EXIT_SUCCESS); 312} 313 314ATF_TC_WITHOUT_HEAD(expect_exit_code_and_exit); 315ATF_TC_BODY(expect_exit_code_and_exit, tc) 316{ 317 atf_tc_expect_exit(123, "Call will exit"); 318 exit(123); 319} 320 321ATF_TC_WITHOUT_HEAD(expect_exit_but_pass); 322ATF_TC_BODY(expect_exit_but_pass, tc) 323{ 324 atf_tc_expect_exit(-1, "Call won't exit"); 325} 326 327ATF_TC_WITHOUT_HEAD(expect_signal_any_and_signal); 328ATF_TC_BODY(expect_signal_any_and_signal, tc) 329{ 330 atf_tc_expect_signal(-1, "Call will signal"); 331 kill(getpid(), SIGKILL); 332} 333 334ATF_TC_WITHOUT_HEAD(expect_signal_no_and_signal); 335ATF_TC_BODY(expect_signal_no_and_signal, tc) 336{ 337 atf_tc_expect_signal(SIGHUP, "Call will signal"); 338 kill(getpid(), SIGHUP); 339} 340 341ATF_TC_WITHOUT_HEAD(expect_signal_but_pass); 342ATF_TC_BODY(expect_signal_but_pass, tc) 343{ 344 atf_tc_expect_signal(-1, "Call won't signal"); 345} 346 347ATF_TC_WITHOUT_HEAD(expect_death_and_exit); 348ATF_TC_BODY(expect_death_and_exit, tc) 349{ 350 atf_tc_expect_death("Exit case"); 351 exit(123); 352} 353 354ATF_TC_WITHOUT_HEAD(expect_death_and_signal); 355ATF_TC_BODY(expect_death_and_signal, tc) 356{ 357 atf_tc_expect_death("Signal case"); 358 kill(getpid(), SIGKILL); 359} 360 361ATF_TC_WITHOUT_HEAD(expect_death_but_pass); 362ATF_TC_BODY(expect_death_but_pass, tc) 363{ 364 atf_tc_expect_death("Call won't die"); 365} 366 367ATF_TC(expect_timeout_and_hang); 368ATF_TC_HEAD(expect_timeout_and_hang, tc) 369{ 370 atf_tc_set_md_var(tc, "timeout", "1"); 371} 372ATF_TC_BODY(expect_timeout_and_hang, tc) 373{ 374 atf_tc_expect_timeout("Will overrun"); 375 sleep(5); 376} 377 378ATF_TC(expect_timeout_but_pass); 379ATF_TC_HEAD(expect_timeout_but_pass, tc) 380{ 381 atf_tc_set_md_var(tc, "timeout", "1"); 382} 383ATF_TC_BODY(expect_timeout_but_pass, tc) 384{ 385 atf_tc_expect_timeout("Will just exit"); 386} 387 388/* --------------------------------------------------------------------- 389 * Helper tests for "t_fork". 390 * --------------------------------------------------------------------- */ 391 392ATF_TC(fork_stop); 393ATF_TC_HEAD(fork_stop, tc) 394{ 395 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_fork test " 396 "program"); 397} 398ATF_TC_BODY(fork_stop, tc) 399{ 400 FILE *f; 401 const char *dfstr, *pfstr; 402 403 dfstr = atf_tc_get_config_var(tc, "donefile"); 404 pfstr = atf_tc_get_config_var(tc, "pidfile"); 405 406 f = fopen(pfstr, "w"); 407 if (f == NULL) 408 atf_tc_fail("Failed to create pidfile %s", pfstr); 409 fprintf(f, "%d", (int)getpid()); 410 fclose(f); 411 printf("Wrote pid file\n"); 412 413 printf("Waiting for done file\n"); 414 while (access(dfstr, F_OK) != 0) 415 usleep(10000); 416 printf("Exiting\n"); 417} 418 419/* --------------------------------------------------------------------- 420 * Helper tests for "t_meta_data". 421 * --------------------------------------------------------------------- */ 422 423ATF_TC(metadata_no_descr); 424ATF_TC_HEAD(metadata_no_descr, tc) 425{ 426} 427ATF_TC_BODY(metadata_no_descr, tc) 428{ 429} 430 431ATF_TC_WITHOUT_HEAD(metadata_no_head); 432ATF_TC_BODY(metadata_no_head, tc) 433{ 434} 435 436/* --------------------------------------------------------------------- 437 * Helper tests for "t_srcdir". 438 * --------------------------------------------------------------------- */ 439 440ATF_TC(srcdir_exists); 441ATF_TC_HEAD(srcdir_exists, tc) 442{ 443 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_srcdir test " 444 "program"); 445} 446ATF_TC_BODY(srcdir_exists, tc) 447{ 448 atf_fs_path_t p; 449 bool b; 450 451 RE(atf_fs_path_init_fmt(&p, "%s/datafile", 452 atf_tc_get_config_var(tc, "srcdir"))); 453 RE(atf_fs_exists(&p, &b)); 454 atf_fs_path_fini(&p); 455 if (!b) 456 atf_tc_fail("Cannot find datafile"); 457} 458 459/* --------------------------------------------------------------------- 460 * Helper tests for "t_result". 461 * --------------------------------------------------------------------- */ 462 463ATF_TC(result_pass); 464ATF_TC_HEAD(result_pass, tc) { } 465ATF_TC_BODY(result_pass, tc) 466{ 467 printf("msg\n"); 468} 469 470ATF_TC(result_fail); 471ATF_TC_HEAD(result_fail, tc) { } 472ATF_TC_BODY(result_fail, tc) 473{ 474 printf("msg\n"); 475 atf_tc_fail("Failure reason"); 476} 477 478ATF_TC(result_skip); 479ATF_TC_HEAD(result_skip, tc) { } 480ATF_TC_BODY(result_skip, tc) 481{ 482 printf("msg\n"); 483 atf_tc_skip("Skipped reason"); 484} 485 486ATF_TC(result_newlines_fail); 487ATF_TC_HEAD(result_newlines_fail, tc) 488{ 489 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_result test " 490 "program"); 491} 492ATF_TC_BODY(result_newlines_fail, tc) 493{ 494 atf_tc_fail("First line\nSecond line"); 495} 496 497ATF_TC(result_newlines_skip); 498ATF_TC_HEAD(result_newlines_skip, tc) 499{ 500 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_result test " 501 "program"); 502} 503ATF_TC_BODY(result_newlines_skip, tc) 504{ 505 atf_tc_skip("First line\nSecond line"); 506} 507 508/* --------------------------------------------------------------------- 509 * Main. 510 * --------------------------------------------------------------------- */ 511 512ATF_TP_ADD_TCS(tp) 513{ 514 /* Add helper tests for t_cleanup. */ 515 ATF_TP_ADD_TC(tp, cleanup_pass); 516 ATF_TP_ADD_TC(tp, cleanup_fail); 517 ATF_TP_ADD_TC(tp, cleanup_skip); 518 ATF_TP_ADD_TC(tp, cleanup_curdir); 519 ATF_TP_ADD_TC(tp, cleanup_sigterm); 520 ATF_TP_ADD_TC(tp, cleanup_fork); 521 522 /* Add helper tests for t_config. */ 523 ATF_TP_ADD_TC(tp, config_unset); 524 ATF_TP_ADD_TC(tp, config_empty); 525 ATF_TP_ADD_TC(tp, config_value); 526 ATF_TP_ADD_TC(tp, config_multi_value); 527 528 /* Add helper tests for t_expect. */ 529 ATF_TP_ADD_TC(tp, expect_pass_and_pass); 530 ATF_TP_ADD_TC(tp, expect_pass_but_fail_requirement); 531 ATF_TP_ADD_TC(tp, expect_pass_but_fail_check); 532 ATF_TP_ADD_TC(tp, expect_fail_and_fail_requirement); 533 ATF_TP_ADD_TC(tp, expect_fail_and_fail_check); 534 ATF_TP_ADD_TC(tp, expect_fail_but_pass); 535 ATF_TP_ADD_TC(tp, expect_exit_any_and_exit); 536 ATF_TP_ADD_TC(tp, expect_exit_code_and_exit); 537 ATF_TP_ADD_TC(tp, expect_exit_but_pass); 538 ATF_TP_ADD_TC(tp, expect_signal_any_and_signal); 539 ATF_TP_ADD_TC(tp, expect_signal_no_and_signal); 540 ATF_TP_ADD_TC(tp, expect_signal_but_pass); 541 ATF_TP_ADD_TC(tp, expect_death_and_exit); 542 ATF_TP_ADD_TC(tp, expect_death_and_signal); 543 ATF_TP_ADD_TC(tp, expect_death_but_pass); 544 ATF_TP_ADD_TC(tp, expect_timeout_and_hang); 545 ATF_TP_ADD_TC(tp, expect_timeout_but_pass); 546 547 /* Add helper tests for t_fork. */ 548 ATF_TP_ADD_TC(tp, fork_stop); 549 550 /* Add helper tests for t_meta_data. */ 551 ATF_TP_ADD_TC(tp, metadata_no_descr); 552 ATF_TP_ADD_TC(tp, metadata_no_head); 553 554 /* Add helper tests for t_srcdir. */ 555 ATF_TP_ADD_TC(tp, srcdir_exists); 556 557 /* Add helper tests for t_result. */ 558 ATF_TP_ADD_TC(tp, result_pass); 559 ATF_TP_ADD_TC(tp, result_fail); 560 ATF_TP_ADD_TC(tp, result_skip); 561 ATF_TP_ADD_TC(tp, result_newlines_fail); 562 ATF_TP_ADD_TC(tp, result_newlines_skip); 563 564 return atf_no_error(); 565} 566