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