c_helpers.c revision 1.1.1.4
1/* 2 * Automated Testing Framework (atf) 3 * 4 * Copyright (c) 2007 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_WITHOUT_HEAD(metadata_no_descr); 424ATF_TC_BODY(metadata_no_descr, tc) 425{ 426} 427 428ATF_TC_WITHOUT_HEAD(metadata_no_head); 429ATF_TC_BODY(metadata_no_head, tc) 430{ 431} 432 433/* --------------------------------------------------------------------- 434 * Helper tests for "t_srcdir". 435 * --------------------------------------------------------------------- */ 436 437ATF_TC(srcdir_exists); 438ATF_TC_HEAD(srcdir_exists, tc) 439{ 440 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_srcdir test " 441 "program"); 442} 443ATF_TC_BODY(srcdir_exists, tc) 444{ 445 atf_fs_path_t p; 446 bool b; 447 448 RE(atf_fs_path_init_fmt(&p, "%s/datafile", 449 atf_tc_get_config_var(tc, "srcdir"))); 450 RE(atf_fs_exists(&p, &b)); 451 atf_fs_path_fini(&p); 452 if (!b) 453 atf_tc_fail("Cannot find datafile"); 454} 455 456/* --------------------------------------------------------------------- 457 * Helper tests for "t_result". 458 * --------------------------------------------------------------------- */ 459 460ATF_TC_WITHOUT_HEAD(result_pass); 461ATF_TC_BODY(result_pass, tc) 462{ 463 printf("msg\n"); 464} 465 466ATF_TC_WITHOUT_HEAD(result_fail); 467ATF_TC_BODY(result_fail, tc) 468{ 469 printf("msg\n"); 470 atf_tc_fail("Failure reason"); 471} 472 473ATF_TC_WITHOUT_HEAD(result_skip); 474ATF_TC_BODY(result_skip, tc) 475{ 476 printf("msg\n"); 477 atf_tc_skip("Skipped reason"); 478} 479 480ATF_TC(result_newlines_fail); 481ATF_TC_HEAD(result_newlines_fail, tc) 482{ 483 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_result test " 484 "program"); 485} 486ATF_TC_BODY(result_newlines_fail, tc) 487{ 488 atf_tc_fail("First line\nSecond line"); 489} 490 491ATF_TC(result_newlines_skip); 492ATF_TC_HEAD(result_newlines_skip, tc) 493{ 494 atf_tc_set_md_var(tc, "descr", "Helper test case for the t_result test " 495 "program"); 496} 497ATF_TC_BODY(result_newlines_skip, tc) 498{ 499 atf_tc_skip("First line\nSecond line"); 500} 501 502/* --------------------------------------------------------------------- 503 * Main. 504 * --------------------------------------------------------------------- */ 505 506ATF_TP_ADD_TCS(tp) 507{ 508 /* Add helper tests for t_cleanup. */ 509 ATF_TP_ADD_TC(tp, cleanup_pass); 510 ATF_TP_ADD_TC(tp, cleanup_fail); 511 ATF_TP_ADD_TC(tp, cleanup_skip); 512 ATF_TP_ADD_TC(tp, cleanup_curdir); 513 ATF_TP_ADD_TC(tp, cleanup_sigterm); 514 ATF_TP_ADD_TC(tp, cleanup_fork); 515 516 /* Add helper tests for t_config. */ 517 ATF_TP_ADD_TC(tp, config_unset); 518 ATF_TP_ADD_TC(tp, config_empty); 519 ATF_TP_ADD_TC(tp, config_value); 520 ATF_TP_ADD_TC(tp, config_multi_value); 521 522 /* Add helper tests for t_expect. */ 523 ATF_TP_ADD_TC(tp, expect_pass_and_pass); 524 ATF_TP_ADD_TC(tp, expect_pass_but_fail_requirement); 525 ATF_TP_ADD_TC(tp, expect_pass_but_fail_check); 526 ATF_TP_ADD_TC(tp, expect_fail_and_fail_requirement); 527 ATF_TP_ADD_TC(tp, expect_fail_and_fail_check); 528 ATF_TP_ADD_TC(tp, expect_fail_but_pass); 529 ATF_TP_ADD_TC(tp, expect_exit_any_and_exit); 530 ATF_TP_ADD_TC(tp, expect_exit_code_and_exit); 531 ATF_TP_ADD_TC(tp, expect_exit_but_pass); 532 ATF_TP_ADD_TC(tp, expect_signal_any_and_signal); 533 ATF_TP_ADD_TC(tp, expect_signal_no_and_signal); 534 ATF_TP_ADD_TC(tp, expect_signal_but_pass); 535 ATF_TP_ADD_TC(tp, expect_death_and_exit); 536 ATF_TP_ADD_TC(tp, expect_death_and_signal); 537 ATF_TP_ADD_TC(tp, expect_death_but_pass); 538 ATF_TP_ADD_TC(tp, expect_timeout_and_hang); 539 ATF_TP_ADD_TC(tp, expect_timeout_but_pass); 540 541 /* Add helper tests for t_fork. */ 542 ATF_TP_ADD_TC(tp, fork_stop); 543 544 /* Add helper tests for t_meta_data. */ 545 ATF_TP_ADD_TC(tp, metadata_no_descr); 546 ATF_TP_ADD_TC(tp, metadata_no_head); 547 548 /* Add helper tests for t_srcdir. */ 549 ATF_TP_ADD_TC(tp, srcdir_exists); 550 551 /* Add helper tests for t_result. */ 552 ATF_TP_ADD_TC(tp, result_pass); 553 ATF_TP_ADD_TC(tp, result_fail); 554 ATF_TP_ADD_TC(tp, result_skip); 555 ATF_TP_ADD_TC(tp, result_newlines_fail); 556 ATF_TP_ADD_TC(tp, result_newlines_skip); 557 558 return atf_no_error(); 559} 560