external/bsd/bind/dist/unit/atf-src/test-programs/c_helpers.c

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