1240116Smarcel/* 2240116Smarcel * Automated Testing Framework (atf) 3240116Smarcel * 4240116Smarcel * Copyright (c) 2008 The NetBSD Foundation, Inc. 5240116Smarcel * All rights reserved. 6240116Smarcel * 7240116Smarcel * Redistribution and use in source and binary forms, with or without 8240116Smarcel * modification, are permitted provided that the following conditions 9240116Smarcel * are met: 10240116Smarcel * 1. Redistributions of source code must retain the above copyright 11240116Smarcel * notice, this list of conditions and the following disclaimer. 12240116Smarcel * 2. Redistributions in binary form must reproduce the above copyright 13240116Smarcel * notice, this list of conditions and the following disclaimer in the 14240116Smarcel * documentation and/or other materials provided with the distribution. 15240116Smarcel * 16240116Smarcel * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17240116Smarcel * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18240116Smarcel * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19240116Smarcel * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20240116Smarcel * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21240116Smarcel * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22240116Smarcel * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23240116Smarcel * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24240116Smarcel * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25240116Smarcel * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26240116Smarcel * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27240116Smarcel * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28240116Smarcel */ 29240116Smarcel 30240116Smarcel#include <sys/types.h> 31240116Smarcel#include <sys/wait.h> 32240116Smarcel 33240116Smarcel#include <errno.h> 34240116Smarcel#include <fcntl.h> 35240116Smarcel#include <stdarg.h> 36240116Smarcel#include <stdbool.h> 37240116Smarcel#include <stdio.h> 38240116Smarcel#include <stdlib.h> 39240116Smarcel#include <string.h> 40240116Smarcel#include <unistd.h> 41240116Smarcel 42240116Smarcel#include <atf-c.h> 43240116Smarcel 44240116Smarcel#include "detail/fs.h" 45240116Smarcel#include "detail/process.h" 46240116Smarcel#include "detail/test_helpers.h" 47240116Smarcel#include "detail/text.h" 48240116Smarcel 49240116Smarcel/* --------------------------------------------------------------------- 50240116Smarcel * Auxiliary functions. 51240116Smarcel * --------------------------------------------------------------------- */ 52240116Smarcel 53240116Smarcelstatic 54240116Smarcelvoid 55240116Smarcelcreate_ctl_file(const char *name) 56240116Smarcel{ 57240116Smarcel atf_fs_path_t p; 58240116Smarcel 59240116Smarcel RE(atf_fs_path_init_fmt(&p, "%s", name)); 60240116Smarcel ATF_REQUIRE(open(atf_fs_path_cstring(&p), 61240116Smarcel O_CREAT | O_WRONLY | O_TRUNC, 0644) != -1); 62240116Smarcel atf_fs_path_fini(&p); 63240116Smarcel} 64240116Smarcel 65240116Smarcelstatic 66240116Smarcelbool 67240116Smarcelexists(const char *p) 68240116Smarcel{ 69240116Smarcel bool b; 70240116Smarcel atf_fs_path_t pp; 71240116Smarcel 72240116Smarcel RE(atf_fs_path_init_fmt(&pp, "%s", p)); 73240116Smarcel RE(atf_fs_exists(&pp, &b)); 74240116Smarcel atf_fs_path_fini(&pp); 75240116Smarcel 76240116Smarcel return b; 77240116Smarcel} 78240116Smarcel 79240116Smarcelstatic 80240116Smarcelvoid 81240116Smarcelinit_and_run_h_tc(const char *name, void (*head)(atf_tc_t *), 82240116Smarcel void (*body)(const atf_tc_t *)) 83240116Smarcel{ 84240116Smarcel atf_tc_t tc; 85240116Smarcel const char *const config[] = { NULL }; 86240116Smarcel 87240116Smarcel RE(atf_tc_init(&tc, name, head, body, NULL, config)); 88240116Smarcel run_h_tc(&tc, "output", "error", "result"); 89240116Smarcel atf_tc_fini(&tc); 90240116Smarcel} 91240116Smarcel 92240116Smarcel/* --------------------------------------------------------------------- 93240116Smarcel * Helper test cases. 94240116Smarcel * --------------------------------------------------------------------- */ 95240116Smarcel 96240116Smarcel#define H_DEF(id, macro) \ 97240116Smarcel ATF_TC_HEAD(h_ ## id, tc) \ 98240116Smarcel { \ 99240116Smarcel atf_tc_set_md_var(tc, "descr", "Helper test case"); \ 100240116Smarcel } \ 101240116Smarcel ATF_TC_BODY(h_ ## id, tc) \ 102240116Smarcel { \ 103240116Smarcel create_ctl_file("before"); \ 104240116Smarcel macro; \ 105240116Smarcel create_ctl_file("after"); \ 106240116Smarcel } 107240116Smarcel 108240116Smarcel#define H_CHECK_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_ ## id) 109240116Smarcel#define H_CHECK_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_ ## id) 110240116Smarcel#define H_CHECK(id, condition) \ 111240116Smarcel H_DEF(check_ ## id, ATF_CHECK(condition)) 112240116Smarcel 113240116Smarcel#define H_CHECK_MSG_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_msg_ ## id) 114240116Smarcel#define H_CHECK_MSG_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_msg_ ## id) 115240116Smarcel#define H_CHECK_MSG(id, condition, msg) \ 116240116Smarcel H_DEF(check_msg_ ## id, ATF_CHECK_MSG(condition, msg)) 117240116Smarcel 118240116Smarcel#define H_CHECK_EQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_eq_ ## id) 119240116Smarcel#define H_CHECK_EQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_eq_ ## id) 120240116Smarcel#define H_CHECK_EQ(id, v1, v2) \ 121240116Smarcel H_DEF(check_eq_ ## id, ATF_CHECK_EQ(v1, v2)) 122240116Smarcel 123240116Smarcel#define H_CHECK_STREQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_streq_ ## id) 124240116Smarcel#define H_CHECK_STREQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_streq_ ## id) 125240116Smarcel#define H_CHECK_STREQ(id, v1, v2) \ 126240116Smarcel H_DEF(check_streq_ ## id, ATF_CHECK_STREQ(v1, v2)) 127240116Smarcel 128260029Sjmmv#define H_CHECK_MATCH_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_match_ ## id) 129260029Sjmmv#define H_CHECK_MATCH_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_match_ ## id) 130260029Sjmmv#define H_CHECK_MATCH(id, v1, v2) \ 131260029Sjmmv H_DEF(check_match_ ## id, ATF_CHECK_MATCH(v1, v2)) 132260029Sjmmv 133240116Smarcel#define H_CHECK_EQ_MSG_HEAD_NAME(id) \ 134240116Smarcel ATF_TC_HEAD_NAME(h_check_eq_msg_ ## id) 135240116Smarcel#define H_CHECK_EQ_MSG_BODY_NAME(id) \ 136240116Smarcel ATF_TC_BODY_NAME(h_check_eq_msg_ ## id) 137240116Smarcel#define H_CHECK_EQ_MSG(id, v1, v2, msg) \ 138240116Smarcel H_DEF(check_eq_msg_ ## id, ATF_CHECK_EQ_MSG(v1, v2, msg)) 139240116Smarcel 140240116Smarcel#define H_CHECK_STREQ_MSG_HEAD_NAME(id) \ 141240116Smarcel ATF_TC_HEAD_NAME(h_check_streq_msg_ ## id) 142240116Smarcel#define H_CHECK_STREQ_MSG_BODY_NAME(id) \ 143240116Smarcel ATF_TC_BODY_NAME(h_check_streq_msg_ ## id) 144240116Smarcel#define H_CHECK_STREQ_MSG(id, v1, v2, msg) \ 145240116Smarcel H_DEF(check_streq_msg_ ## id, ATF_CHECK_STREQ_MSG(v1, v2, msg)) 146240116Smarcel 147260029Sjmmv#define H_CHECK_MATCH_MSG_HEAD_NAME(id) \ 148260029Sjmmv ATF_TC_HEAD_NAME(h_check_match_msg_ ## id) 149260029Sjmmv#define H_CHECK_MATCH_MSG_BODY_NAME(id) \ 150260029Sjmmv ATF_TC_BODY_NAME(h_check_match_msg_ ## id) 151260029Sjmmv#define H_CHECK_MATCH_MSG(id, v1, v2, msg) \ 152260029Sjmmv H_DEF(check_match_msg_ ## id, ATF_CHECK_MATCH_MSG(v1, v2, msg)) 153260029Sjmmv 154240116Smarcel#define H_CHECK_ERRNO_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_errno_ ## id) 155240116Smarcel#define H_CHECK_ERRNO_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_errno_ ## id) 156240116Smarcel#define H_CHECK_ERRNO(id, exp_errno, bool_expr) \ 157240116Smarcel H_DEF(check_errno_ ## id, ATF_CHECK_ERRNO(exp_errno, bool_expr)) 158240116Smarcel 159240116Smarcel#define H_REQUIRE_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_ ## id) 160240116Smarcel#define H_REQUIRE_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_ ## id) 161240116Smarcel#define H_REQUIRE(id, condition) \ 162240116Smarcel H_DEF(require_ ## id, ATF_REQUIRE(condition)) 163240116Smarcel 164240116Smarcel#define H_REQUIRE_MSG_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_msg_ ## id) 165240116Smarcel#define H_REQUIRE_MSG_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_msg_ ## id) 166240116Smarcel#define H_REQUIRE_MSG(id, condition, msg) \ 167240116Smarcel H_DEF(require_msg_ ## id, ATF_REQUIRE_MSG(condition, msg)) 168240116Smarcel 169240116Smarcel#define H_REQUIRE_EQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_eq_ ## id) 170240116Smarcel#define H_REQUIRE_EQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_eq_ ## id) 171240116Smarcel#define H_REQUIRE_EQ(id, v1, v2) \ 172240116Smarcel H_DEF(require_eq_ ## id, ATF_REQUIRE_EQ(v1, v2)) 173240116Smarcel 174240116Smarcel#define H_REQUIRE_STREQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_streq_ ## id) 175240116Smarcel#define H_REQUIRE_STREQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_streq_ ## id) 176240116Smarcel#define H_REQUIRE_STREQ(id, v1, v2) \ 177240116Smarcel H_DEF(require_streq_ ## id, ATF_REQUIRE_STREQ(v1, v2)) 178240116Smarcel 179260029Sjmmv#define H_REQUIRE_MATCH_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_match_ ## id) 180260029Sjmmv#define H_REQUIRE_MATCH_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_match_ ## id) 181260029Sjmmv#define H_REQUIRE_MATCH(id, v1, v2) \ 182260029Sjmmv H_DEF(require_match_ ## id, ATF_REQUIRE_MATCH(v1, v2)) 183260029Sjmmv 184240116Smarcel#define H_REQUIRE_EQ_MSG_HEAD_NAME(id) \ 185240116Smarcel ATF_TC_HEAD_NAME(h_require_eq_msg_ ## id) 186240116Smarcel#define H_REQUIRE_EQ_MSG_BODY_NAME(id) \ 187240116Smarcel ATF_TC_BODY_NAME(h_require_eq_msg_ ## id) 188240116Smarcel#define H_REQUIRE_EQ_MSG(id, v1, v2, msg) \ 189240116Smarcel H_DEF(require_eq_msg_ ## id, ATF_REQUIRE_EQ_MSG(v1, v2, msg)) 190240116Smarcel 191240116Smarcel#define H_REQUIRE_STREQ_MSG_HEAD_NAME(id) \ 192240116Smarcel ATF_TC_HEAD_NAME(h_require_streq_msg_ ## id) 193240116Smarcel#define H_REQUIRE_STREQ_MSG_BODY_NAME(id) \ 194240116Smarcel ATF_TC_BODY_NAME(h_require_streq_msg_ ## id) 195240116Smarcel#define H_REQUIRE_STREQ_MSG(id, v1, v2, msg) \ 196240116Smarcel H_DEF(require_streq_msg_ ## id, ATF_REQUIRE_STREQ_MSG(v1, v2, msg)) 197240116Smarcel 198260029Sjmmv#define H_REQUIRE_MATCH_MSG_HEAD_NAME(id) \ 199260029Sjmmv ATF_TC_HEAD_NAME(h_require_match_msg_ ## id) 200260029Sjmmv#define H_REQUIRE_MATCH_MSG_BODY_NAME(id) \ 201260029Sjmmv ATF_TC_BODY_NAME(h_require_match_msg_ ## id) 202260029Sjmmv#define H_REQUIRE_MATCH_MSG(id, v1, v2, msg) \ 203260029Sjmmv H_DEF(require_match_msg_ ## id, ATF_REQUIRE_MATCH_MSG(v1, v2, msg)) 204260029Sjmmv 205240116Smarcel#define H_REQUIRE_ERRNO_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_errno_ ## id) 206240116Smarcel#define H_REQUIRE_ERRNO_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_errno_ ## id) 207240116Smarcel#define H_REQUIRE_ERRNO(id, exp_errno, bool_expr) \ 208240116Smarcel H_DEF(require_errno_ ## id, ATF_REQUIRE_ERRNO(exp_errno, bool_expr)) 209240116Smarcel 210240116Smarcel/* --------------------------------------------------------------------- 211240116Smarcel * Test cases for the ATF_{CHECK,REQUIRE}_ERRNO macros. 212240116Smarcel * --------------------------------------------------------------------- */ 213240116Smarcel 214240116Smarcelstatic int 215240116Smarcelerrno_fail_stub(const int raised_errno) 216240116Smarcel{ 217240116Smarcel errno = raised_errno; 218240116Smarcel return -1; 219240116Smarcel} 220240116Smarcel 221240116Smarcelstatic int 222240116Smarcelerrno_ok_stub(void) 223240116Smarcel{ 224240116Smarcel return 0; 225240116Smarcel} 226240116Smarcel 227240116SmarcelH_CHECK_ERRNO(no_error, -1, errno_ok_stub() == -1); 228240116SmarcelH_CHECK_ERRNO(errno_ok, 2, errno_fail_stub(2) == -1); 229240116SmarcelH_CHECK_ERRNO(errno_fail, 3, errno_fail_stub(4) == -1); 230240116Smarcel 231240116SmarcelH_REQUIRE_ERRNO(no_error, -1, errno_ok_stub() == -1); 232240116SmarcelH_REQUIRE_ERRNO(errno_ok, 2, errno_fail_stub(2) == -1); 233240116SmarcelH_REQUIRE_ERRNO(errno_fail, 3, errno_fail_stub(4) == -1); 234240116Smarcel 235240116SmarcelATF_TC(check_errno); 236240116SmarcelATF_TC_HEAD(check_errno, tc) 237240116Smarcel{ 238240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_ERRNO macro"); 239240116Smarcel} 240240116SmarcelATF_TC_BODY(check_errno, tc) 241240116Smarcel{ 242240116Smarcel struct test { 243240116Smarcel void (*head)(atf_tc_t *); 244240116Smarcel void (*body)(const atf_tc_t *); 245240116Smarcel bool ok; 246240116Smarcel const char *exp_regex; 247240116Smarcel } *t, tests[] = { 248240116Smarcel { H_CHECK_ERRNO_HEAD_NAME(no_error), 249240116Smarcel H_CHECK_ERRNO_BODY_NAME(no_error), 250240116Smarcel false, "Expected true value in errno_ok_stub\\(\\) == -1" }, 251240116Smarcel { H_CHECK_ERRNO_HEAD_NAME(errno_ok), 252240116Smarcel H_CHECK_ERRNO_BODY_NAME(errno_ok), 253240116Smarcel true, NULL }, 254240116Smarcel { H_CHECK_ERRNO_HEAD_NAME(errno_fail), 255240116Smarcel H_CHECK_ERRNO_BODY_NAME(errno_fail), 256240116Smarcel false, "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" }, 257240116Smarcel { NULL, NULL, false, NULL } 258240116Smarcel }; 259240116Smarcel 260240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 261240116Smarcel init_and_run_h_tc("h_check_errno", t->head, t->body); 262240116Smarcel 263240116Smarcel ATF_REQUIRE(exists("before")); 264240116Smarcel ATF_REQUIRE(exists("after")); 265240116Smarcel 266240116Smarcel if (t->ok) { 267260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^passed", "result")); 268240116Smarcel } else { 269260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^failed", "result")); 270260029Sjmmv ATF_REQUIRE(atf_utils_grep_file( 271260029Sjmmv "macros_test.c:[0-9]+: %s$", "error", t->exp_regex)); 272240116Smarcel } 273240116Smarcel 274240116Smarcel ATF_REQUIRE(unlink("before") != -1); 275240116Smarcel ATF_REQUIRE(unlink("after") != -1); 276240116Smarcel } 277240116Smarcel} 278240116Smarcel 279240116SmarcelATF_TC(require_errno); 280240116SmarcelATF_TC_HEAD(require_errno, tc) 281240116Smarcel{ 282240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_ERRNO macro"); 283240116Smarcel} 284240116SmarcelATF_TC_BODY(require_errno, tc) 285240116Smarcel{ 286240116Smarcel struct test { 287240116Smarcel void (*head)(atf_tc_t *); 288240116Smarcel void (*body)(const atf_tc_t *); 289240116Smarcel bool ok; 290240116Smarcel const char *exp_regex; 291240116Smarcel } *t, tests[] = { 292240116Smarcel { H_REQUIRE_ERRNO_HEAD_NAME(no_error), 293240116Smarcel H_REQUIRE_ERRNO_BODY_NAME(no_error), 294240116Smarcel false, "Expected true value in errno_ok_stub\\(\\) == -1" }, 295240116Smarcel { H_REQUIRE_ERRNO_HEAD_NAME(errno_ok), 296240116Smarcel H_REQUIRE_ERRNO_BODY_NAME(errno_ok), 297240116Smarcel true, NULL }, 298240116Smarcel { H_REQUIRE_ERRNO_HEAD_NAME(errno_fail), 299240116Smarcel H_REQUIRE_ERRNO_BODY_NAME(errno_fail), 300240116Smarcel false, "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" }, 301240116Smarcel { NULL, NULL, false, NULL } 302240116Smarcel }; 303240116Smarcel 304240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 305240116Smarcel init_and_run_h_tc("h_require_errno", t->head, t->body); 306240116Smarcel 307240116Smarcel ATF_REQUIRE(exists("before")); 308240116Smarcel if (t->ok) { 309260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^passed", "result")); 310240116Smarcel ATF_REQUIRE(exists("after")); 311240116Smarcel } else { 312260029Sjmmv ATF_REQUIRE(atf_utils_grep_file( 313260029Sjmmv "^failed: .*macros_test.c:[0-9]+: %s$", "result", 314260029Sjmmv t->exp_regex)); 315240116Smarcel ATF_REQUIRE(!exists("after")); 316240116Smarcel } 317240116Smarcel 318240116Smarcel ATF_REQUIRE(unlink("before") != -1); 319240116Smarcel if (t->ok) 320240116Smarcel ATF_REQUIRE(unlink("after") != -1); 321240116Smarcel } 322240116Smarcel} 323240116Smarcel 324240116Smarcel/* --------------------------------------------------------------------- 325240116Smarcel * Test cases for the ATF_CHECK and ATF_CHECK_MSG macros. 326240116Smarcel * --------------------------------------------------------------------- */ 327240116Smarcel 328240116SmarcelH_CHECK(0, 0); 329240116SmarcelH_CHECK(1, 1); 330240116SmarcelH_CHECK_MSG(0, 0, "expected a false value"); 331240116SmarcelH_CHECK_MSG(1, 1, "expected a true value"); 332240116Smarcel 333240116SmarcelATF_TC(check); 334240116SmarcelATF_TC_HEAD(check, tc) 335240116Smarcel{ 336240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK and " 337240116Smarcel "ATF_CHECK_MSG macros"); 338240116Smarcel} 339240116SmarcelATF_TC_BODY(check, tc) 340240116Smarcel{ 341240116Smarcel struct test { 342240116Smarcel void (*head)(atf_tc_t *); 343240116Smarcel void (*body)(const atf_tc_t *); 344240116Smarcel bool value; 345240116Smarcel const char *msg; 346240116Smarcel bool ok; 347240116Smarcel } *t, tests[] = { 348240116Smarcel { H_CHECK_HEAD_NAME(0), H_CHECK_BODY_NAME(0), 0, 349240116Smarcel "0 not met", false }, 350240116Smarcel { H_CHECK_HEAD_NAME(1), H_CHECK_BODY_NAME(1), 1, 351240116Smarcel "1 not met", true }, 352240116Smarcel { H_CHECK_MSG_HEAD_NAME(0), H_CHECK_MSG_BODY_NAME(0), 0, 353240116Smarcel "expected a false value", false }, 354240116Smarcel { H_CHECK_MSG_HEAD_NAME(1), H_CHECK_MSG_BODY_NAME(1), 1, 355240116Smarcel "expected a true value", true }, 356240116Smarcel { NULL, NULL, false, NULL, false } 357240116Smarcel }; 358240116Smarcel 359240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 360240116Smarcel printf("Checking with a %d value\n", t->value); 361240116Smarcel 362240116Smarcel init_and_run_h_tc("h_check", t->head, t->body); 363240116Smarcel 364240116Smarcel ATF_REQUIRE(exists("before")); 365240116Smarcel ATF_REQUIRE(exists("after")); 366240116Smarcel 367240116Smarcel if (t->ok) { 368260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^passed", "result")); 369240116Smarcel } else { 370260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^failed", "result")); 371260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("Check failed: .*" 372260029Sjmmv "macros_test.c:[0-9]+: %s$", "error", t->msg)); 373240116Smarcel } 374240116Smarcel 375240116Smarcel ATF_REQUIRE(unlink("before") != -1); 376240116Smarcel ATF_REQUIRE(unlink("after") != -1); 377240116Smarcel } 378240116Smarcel} 379240116Smarcel 380240116Smarcel/* --------------------------------------------------------------------- 381240116Smarcel * Test cases for the ATF_CHECK_*EQ_ macros. 382240116Smarcel * --------------------------------------------------------------------- */ 383240116Smarcel 384240116Smarcelstruct check_eq_test { 385240116Smarcel void (*head)(atf_tc_t *); 386240116Smarcel void (*body)(const atf_tc_t *); 387240116Smarcel const char *v1; 388240116Smarcel const char *v2; 389240116Smarcel const char *msg; 390240116Smarcel bool ok; 391240116Smarcel}; 392240116Smarcel 393240116Smarcelstatic 394240116Smarcelvoid 395240116Smarceldo_check_eq_tests(const struct check_eq_test *tests) 396240116Smarcel{ 397240116Smarcel const struct check_eq_test *t; 398240116Smarcel 399240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 400240116Smarcel printf("Checking with %s, %s and expecting %s\n", t->v1, t->v2, 401240116Smarcel t->ok ? "true" : "false"); 402240116Smarcel 403240116Smarcel init_and_run_h_tc("h_check", t->head, t->body); 404240116Smarcel 405240116Smarcel ATF_CHECK(exists("before")); 406240116Smarcel ATF_CHECK(exists("after")); 407240116Smarcel 408240116Smarcel if (t->ok) { 409260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^passed", "result")); 410240116Smarcel } else { 411260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^failed", "result")); 412260029Sjmmv ATF_CHECK(atf_utils_grep_file("Check failed: .*" 413260029Sjmmv "macros_test.c:[0-9]+: %s$", "error", t->msg)); 414240116Smarcel } 415240116Smarcel 416240116Smarcel ATF_CHECK(unlink("before") != -1); 417240116Smarcel ATF_CHECK(unlink("after") != -1); 418240116Smarcel } 419240116Smarcel} 420240116Smarcel 421240116SmarcelH_CHECK_EQ(1_1, 1, 1); 422240116SmarcelH_CHECK_EQ(1_2, 1, 2); 423240116SmarcelH_CHECK_EQ(2_1, 2, 1); 424240116SmarcelH_CHECK_EQ(2_2, 2, 2); 425240116SmarcelH_CHECK_EQ_MSG(1_1, 1, 1, "1 does not match 1"); 426240116SmarcelH_CHECK_EQ_MSG(1_2, 1, 2, "1 does not match 2"); 427240116SmarcelH_CHECK_EQ_MSG(2_1, 2, 1, "2 does not match 1"); 428240116SmarcelH_CHECK_EQ_MSG(2_2, 2, 2, "2 does not match 2"); 429240116Smarcel 430240116SmarcelATF_TC(check_eq); 431240116SmarcelATF_TC_HEAD(check_eq, tc) 432240116Smarcel{ 433240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_EQ and " 434240116Smarcel "ATF_CHECK_EQ_MSG macros"); 435240116Smarcel} 436240116SmarcelATF_TC_BODY(check_eq, tc) 437240116Smarcel{ 438240116Smarcel struct check_eq_test tests[] = { 439240116Smarcel { H_CHECK_EQ_HEAD_NAME(1_1), H_CHECK_EQ_BODY_NAME(1_1), 440240116Smarcel "1", "1", "1 != 1", true }, 441240116Smarcel { H_CHECK_EQ_HEAD_NAME(1_2), H_CHECK_EQ_BODY_NAME(1_2), 442240116Smarcel "1", "2", "1 != 2", false }, 443240116Smarcel { H_CHECK_EQ_HEAD_NAME(2_1), H_CHECK_EQ_BODY_NAME(2_1), 444240116Smarcel "2", "1", "2 != 1", false }, 445240116Smarcel { H_CHECK_EQ_HEAD_NAME(2_2), H_CHECK_EQ_BODY_NAME(2_2), 446240116Smarcel "2", "2", "2 != 2", true }, 447240116Smarcel { H_CHECK_EQ_MSG_HEAD_NAME(1_1), H_CHECK_EQ_MSG_BODY_NAME(1_1), 448240116Smarcel "1", "1", "1 != 1: 1 does not match 1", true }, 449240116Smarcel { H_CHECK_EQ_MSG_HEAD_NAME(1_2), H_CHECK_EQ_MSG_BODY_NAME(1_2), 450240116Smarcel "1", "2", "1 != 2: 1 does not match 2", false }, 451240116Smarcel { H_CHECK_EQ_MSG_HEAD_NAME(2_1), H_CHECK_EQ_MSG_BODY_NAME(2_1), 452240116Smarcel "2", "1", "2 != 1: 2 does not match 1", false }, 453240116Smarcel { H_CHECK_EQ_MSG_HEAD_NAME(2_2), H_CHECK_EQ_MSG_BODY_NAME(2_2), 454240116Smarcel "2", "2", "2 != 2: 2 does not match 2", true }, 455240116Smarcel { NULL, NULL, 0, 0, "", false } 456240116Smarcel }; 457240116Smarcel do_check_eq_tests(tests); 458240116Smarcel} 459240116Smarcel 460240116SmarcelH_CHECK_STREQ(1_1, "1", "1"); 461240116SmarcelH_CHECK_STREQ(1_2, "1", "2"); 462240116SmarcelH_CHECK_STREQ(2_1, "2", "1"); 463240116SmarcelH_CHECK_STREQ(2_2, "2", "2"); 464240116SmarcelH_CHECK_STREQ_MSG(1_1, "1", "1", "1 does not match 1"); 465240116SmarcelH_CHECK_STREQ_MSG(1_2, "1", "2", "1 does not match 2"); 466240116SmarcelH_CHECK_STREQ_MSG(2_1, "2", "1", "2 does not match 1"); 467240116SmarcelH_CHECK_STREQ_MSG(2_2, "2", "2", "2 does not match 2"); 468240116Smarcel#define CHECK_STREQ_VAR1 "5" 469240116Smarcel#define CHECK_STREQ_VAR2 "9" 470260029Sjmmvconst char *check_streq_var1 = CHECK_STREQ_VAR1; 471260029Sjmmvconst char *check_streq_var2 = CHECK_STREQ_VAR2; 472240116SmarcelH_CHECK_STREQ(vars, check_streq_var1, check_streq_var2); 473240116Smarcel 474240116SmarcelATF_TC(check_streq); 475240116SmarcelATF_TC_HEAD(check_streq, tc) 476240116Smarcel{ 477240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_STREQ and " 478240116Smarcel "ATF_CHECK_STREQ_MSG macros"); 479240116Smarcel} 480240116SmarcelATF_TC_BODY(check_streq, tc) 481240116Smarcel{ 482240116Smarcel struct check_eq_test tests[] = { 483240116Smarcel { H_CHECK_STREQ_HEAD_NAME(1_1), H_CHECK_STREQ_BODY_NAME(1_1), 484240116Smarcel "1", "1", "\"1\" != \"1\" \\(1 != 1\\)", true }, 485240116Smarcel { H_CHECK_STREQ_HEAD_NAME(1_2), H_CHECK_STREQ_BODY_NAME(1_2), 486240116Smarcel "1", "2", "\"1\" != \"2\" \\(1 != 2\\)", false }, 487240116Smarcel { H_CHECK_STREQ_HEAD_NAME(2_1), H_CHECK_STREQ_BODY_NAME(2_1), 488240116Smarcel "2", "1", "\"2\" != \"1\" \\(2 != 1\\)", false }, 489240116Smarcel { H_CHECK_STREQ_HEAD_NAME(2_2), H_CHECK_STREQ_BODY_NAME(2_2), 490240116Smarcel "2", "2", "\"2\" != \"2\" \\(2 != 2\\)", true }, 491240116Smarcel { H_CHECK_STREQ_MSG_HEAD_NAME(1_1), 492240116Smarcel H_CHECK_STREQ_MSG_BODY_NAME(1_1), 493240116Smarcel "1", "1", "\"1\" != \"1\" \\(1 != 1\\): 1 does not match 1", true }, 494240116Smarcel { H_CHECK_STREQ_MSG_HEAD_NAME(1_2), 495240116Smarcel H_CHECK_STREQ_MSG_BODY_NAME(1_2), 496240116Smarcel "1", "2", "\"1\" != \"2\" \\(1 != 2\\): 1 does not match 2", false }, 497240116Smarcel { H_CHECK_STREQ_MSG_HEAD_NAME(2_1), 498240116Smarcel H_CHECK_STREQ_MSG_BODY_NAME(2_1), 499240116Smarcel "2", "1", "\"2\" != \"1\" \\(2 != 1\\): 2 does not match 1", false }, 500240116Smarcel { H_CHECK_STREQ_MSG_HEAD_NAME(2_2), 501240116Smarcel H_CHECK_STREQ_MSG_BODY_NAME(2_2), 502240116Smarcel "2", "2", "\"2\" != \"2\" \\(2 != 2\\): 2 does not match 2", true }, 503240116Smarcel { H_CHECK_STREQ_HEAD_NAME(vars), H_CHECK_STREQ_BODY_NAME(vars), 504240116Smarcel check_streq_var1, check_streq_var2, 505240116Smarcel "check_streq_var1 != check_streq_var2 \\(" 506240116Smarcel CHECK_STREQ_VAR1 " != " CHECK_STREQ_VAR2 "\\)", false }, 507240116Smarcel { NULL, NULL, 0, 0, "", false } 508240116Smarcel }; 509240116Smarcel do_check_eq_tests(tests); 510240116Smarcel} 511240116Smarcel 512240116Smarcel/* --------------------------------------------------------------------- 513260029Sjmmv * Test cases for the ATF_CHECK_MATCH and ATF_CHECK_MATCH_MSG macros. 514260029Sjmmv * --------------------------------------------------------------------- */ 515260029Sjmmv 516260029SjmmvH_CHECK_MATCH(yes, "hello [a-z]+", "abc hello world"); 517260029SjmmvH_CHECK_MATCH(no, "hello [a-z]+", "abc hello WORLD"); 518260029SjmmvH_CHECK_MATCH_MSG(yes, "hello [a-z]+", "abc hello world", "lowercase"); 519260029SjmmvH_CHECK_MATCH_MSG(no, "hello [a-z]+", "abc hello WORLD", "uppercase"); 520260029Sjmmv 521260029SjmmvATF_TC(check_match); 522260029SjmmvATF_TC_HEAD(check_match, tc) 523260029Sjmmv{ 524260029Sjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_MATCH and " 525260029Sjmmv "ATF_CHECK_MATCH_MSG macros"); 526260029Sjmmv} 527260029SjmmvATF_TC_BODY(check_match, tc) 528260029Sjmmv{ 529260029Sjmmv struct check_eq_test tests[] = { 530260029Sjmmv { H_CHECK_MATCH_HEAD_NAME(yes), H_CHECK_MATCH_BODY_NAME(yes), 531260029Sjmmv "hello [a-z]+", "abc hello world", "", true }, 532260029Sjmmv { H_CHECK_MATCH_HEAD_NAME(no), H_CHECK_MATCH_BODY_NAME(no), 533260029Sjmmv "hello [a-z]+", "abc hello WORLD", 534260029Sjmmv "'hello \\[a-z\\]\\+' not matched in 'abc hello WORLD'", false }, 535260029Sjmmv { H_CHECK_MATCH_MSG_HEAD_NAME(yes), H_CHECK_MATCH_MSG_BODY_NAME(yes), 536260029Sjmmv "hello [a-z]+", "abc hello world", "", true }, 537260029Sjmmv { H_CHECK_MATCH_MSG_HEAD_NAME(no), H_CHECK_MATCH_MSG_BODY_NAME(no), 538260029Sjmmv "hello [a-z]+", "abc hello WORLD", 539260029Sjmmv "'hello \\[a-z\\]\\+' not matched in 'abc hello WORLD': uppercase", 540260029Sjmmv false }, 541260029Sjmmv { NULL, NULL, 0, 0, "", false } 542260029Sjmmv }; 543260029Sjmmv do_check_eq_tests(tests); 544260029Sjmmv} 545260029Sjmmv 546260029Sjmmv/* --------------------------------------------------------------------- 547240116Smarcel * Test cases for the ATF_REQUIRE and ATF_REQUIRE_MSG macros. 548240116Smarcel * --------------------------------------------------------------------- */ 549240116Smarcel 550240116SmarcelH_REQUIRE(0, 0); 551240116SmarcelH_REQUIRE(1, 1); 552240116SmarcelH_REQUIRE_MSG(0, 0, "expected a false value"); 553240116SmarcelH_REQUIRE_MSG(1, 1, "expected a true value"); 554240116Smarcel 555240116SmarcelATF_TC(require); 556240116SmarcelATF_TC_HEAD(require, tc) 557240116Smarcel{ 558240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE and " 559240116Smarcel "ATF_REQUIRE_MSG macros"); 560240116Smarcel} 561240116SmarcelATF_TC_BODY(require, tc) 562240116Smarcel{ 563240116Smarcel struct test { 564240116Smarcel void (*head)(atf_tc_t *); 565240116Smarcel void (*body)(const atf_tc_t *); 566240116Smarcel bool value; 567240116Smarcel const char *msg; 568240116Smarcel bool ok; 569240116Smarcel } *t, tests[] = { 570240116Smarcel { H_REQUIRE_HEAD_NAME(0), H_REQUIRE_BODY_NAME(0), 0, 571240116Smarcel "0 not met", false }, 572240116Smarcel { H_REQUIRE_HEAD_NAME(1), H_REQUIRE_BODY_NAME(1), 1, 573240116Smarcel "1 not met", true }, 574240116Smarcel { H_REQUIRE_MSG_HEAD_NAME(0), H_REQUIRE_MSG_BODY_NAME(0), 0, 575240116Smarcel "expected a false value", false }, 576240116Smarcel { H_REQUIRE_MSG_HEAD_NAME(1), H_REQUIRE_MSG_BODY_NAME(1), 1, 577240116Smarcel "expected a true value", true }, 578240116Smarcel { NULL, NULL, false, NULL, false } 579240116Smarcel }; 580240116Smarcel 581240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 582240116Smarcel printf("Checking with a %d value\n", t->value); 583240116Smarcel 584240116Smarcel init_and_run_h_tc("h_require", t->head, t->body); 585240116Smarcel 586240116Smarcel ATF_REQUIRE(exists("before")); 587240116Smarcel if (t->ok) { 588260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^passed", "result")); 589240116Smarcel ATF_REQUIRE(exists("after")); 590240116Smarcel } else { 591260029Sjmmv ATF_REQUIRE(atf_utils_grep_file( 592260029Sjmmv "^failed: .*macros_test.c:[0-9]+: %s$", "result", t->msg)); 593240116Smarcel ATF_REQUIRE(!exists("after")); 594240116Smarcel } 595240116Smarcel 596240116Smarcel ATF_REQUIRE(unlink("before") != -1); 597240116Smarcel if (t->ok) 598240116Smarcel ATF_REQUIRE(unlink("after") != -1); 599240116Smarcel } 600240116Smarcel} 601240116Smarcel 602240116Smarcel/* --------------------------------------------------------------------- 603240116Smarcel * Test cases for the ATF_REQUIRE_*EQ_ macros. 604240116Smarcel * --------------------------------------------------------------------- */ 605240116Smarcel 606240116Smarcelstruct require_eq_test { 607240116Smarcel void (*head)(atf_tc_t *); 608240116Smarcel void (*body)(const atf_tc_t *); 609240116Smarcel const char *v1; 610240116Smarcel const char *v2; 611240116Smarcel const char *msg; 612240116Smarcel bool ok; 613240116Smarcel}; 614240116Smarcel 615240116Smarcelstatic 616240116Smarcelvoid 617240116Smarceldo_require_eq_tests(const struct require_eq_test *tests) 618240116Smarcel{ 619240116Smarcel const struct require_eq_test *t; 620240116Smarcel 621240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 622240116Smarcel printf("Checking with %s, %s and expecting %s\n", t->v1, t->v2, 623240116Smarcel t->ok ? "true" : "false"); 624240116Smarcel 625240116Smarcel init_and_run_h_tc("h_require", t->head, t->body); 626240116Smarcel 627240116Smarcel ATF_REQUIRE(exists("before")); 628240116Smarcel if (t->ok) { 629260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^passed", "result")); 630240116Smarcel ATF_REQUIRE(exists("after")); 631240116Smarcel } else { 632260029Sjmmv ATF_REQUIRE(atf_utils_grep_file("^failed: .*macros_test.c" 633260029Sjmmv ":[0-9]+: %s$", "result", t->msg)); 634240116Smarcel ATF_REQUIRE(!exists("after")); 635240116Smarcel } 636240116Smarcel 637240116Smarcel ATF_REQUIRE(unlink("before") != -1); 638240116Smarcel if (t->ok) 639240116Smarcel ATF_REQUIRE(unlink("after") != -1); 640240116Smarcel } 641240116Smarcel} 642240116Smarcel 643240116SmarcelH_REQUIRE_EQ(1_1, 1, 1); 644240116SmarcelH_REQUIRE_EQ(1_2, 1, 2); 645240116SmarcelH_REQUIRE_EQ(2_1, 2, 1); 646240116SmarcelH_REQUIRE_EQ(2_2, 2, 2); 647240116SmarcelH_REQUIRE_EQ_MSG(1_1, 1, 1, "1 does not match 1"); 648240116SmarcelH_REQUIRE_EQ_MSG(1_2, 1, 2, "1 does not match 2"); 649240116SmarcelH_REQUIRE_EQ_MSG(2_1, 2, 1, "2 does not match 1"); 650240116SmarcelH_REQUIRE_EQ_MSG(2_2, 2, 2, "2 does not match 2"); 651240116Smarcel 652240116SmarcelATF_TC(require_eq); 653240116SmarcelATF_TC_HEAD(require_eq, tc) 654240116Smarcel{ 655240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_EQ and " 656240116Smarcel "ATF_REQUIRE_EQ_MSG macros"); 657240116Smarcel} 658240116SmarcelATF_TC_BODY(require_eq, tc) 659240116Smarcel{ 660240116Smarcel struct require_eq_test tests[] = { 661240116Smarcel { H_REQUIRE_EQ_HEAD_NAME(1_1), H_REQUIRE_EQ_BODY_NAME(1_1), 662240116Smarcel "1", "1", "1 != 1", true }, 663240116Smarcel { H_REQUIRE_EQ_HEAD_NAME(1_2), H_REQUIRE_EQ_BODY_NAME(1_2), 664240116Smarcel "1", "2", "1 != 2", false }, 665240116Smarcel { H_REQUIRE_EQ_HEAD_NAME(2_1), H_REQUIRE_EQ_BODY_NAME(2_1), 666240116Smarcel "2", "1", "2 != 1", false }, 667240116Smarcel { H_REQUIRE_EQ_HEAD_NAME(2_2), H_REQUIRE_EQ_BODY_NAME(2_2), 668240116Smarcel "2", "2", "2 != 2", true }, 669240116Smarcel { H_REQUIRE_EQ_MSG_HEAD_NAME(1_1), H_REQUIRE_EQ_MSG_BODY_NAME(1_1), 670240116Smarcel "1", "1", "1 != 1: 1 does not match 1", true }, 671240116Smarcel { H_REQUIRE_EQ_MSG_HEAD_NAME(1_2), H_REQUIRE_EQ_MSG_BODY_NAME(1_2), 672240116Smarcel "1", "2", "1 != 2: 1 does not match 2", false }, 673240116Smarcel { H_REQUIRE_EQ_MSG_HEAD_NAME(2_1), H_REQUIRE_EQ_MSG_BODY_NAME(2_1), 674240116Smarcel "2", "1", "2 != 1: 2 does not match 1", false }, 675240116Smarcel { H_REQUIRE_EQ_MSG_HEAD_NAME(2_2), H_REQUIRE_EQ_MSG_BODY_NAME(2_2), 676240116Smarcel "2", "2", "2 != 2: 2 does not match 2", true }, 677240116Smarcel { NULL, NULL, 0, 0, "", false } 678240116Smarcel }; 679240116Smarcel do_require_eq_tests(tests); 680240116Smarcel} 681240116Smarcel 682240116SmarcelH_REQUIRE_STREQ(1_1, "1", "1"); 683240116SmarcelH_REQUIRE_STREQ(1_2, "1", "2"); 684240116SmarcelH_REQUIRE_STREQ(2_1, "2", "1"); 685240116SmarcelH_REQUIRE_STREQ(2_2, "2", "2"); 686240116SmarcelH_REQUIRE_STREQ_MSG(1_1, "1", "1", "1 does not match 1"); 687240116SmarcelH_REQUIRE_STREQ_MSG(1_2, "1", "2", "1 does not match 2"); 688240116SmarcelH_REQUIRE_STREQ_MSG(2_1, "2", "1", "2 does not match 1"); 689240116SmarcelH_REQUIRE_STREQ_MSG(2_2, "2", "2", "2 does not match 2"); 690240116Smarcel#define REQUIRE_STREQ_VAR1 "5" 691240116Smarcel#define REQUIRE_STREQ_VAR2 "9" 692260029Sjmmvconst char *require_streq_var1 = REQUIRE_STREQ_VAR1; 693260029Sjmmvconst char *require_streq_var2 = REQUIRE_STREQ_VAR2; 694240116SmarcelH_REQUIRE_STREQ(vars, require_streq_var1, require_streq_var2); 695240116Smarcel 696240116SmarcelATF_TC(require_streq); 697240116SmarcelATF_TC_HEAD(require_streq, tc) 698240116Smarcel{ 699240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_STREQ and " 700240116Smarcel "ATF_REQUIRE_STREQ_MSG macros"); 701240116Smarcel} 702240116SmarcelATF_TC_BODY(require_streq, tc) 703240116Smarcel{ 704240116Smarcel struct require_eq_test tests[] = { 705240116Smarcel { H_REQUIRE_STREQ_HEAD_NAME(1_1), H_REQUIRE_STREQ_BODY_NAME(1_1), 706240116Smarcel "1", "1", "\"1\" != \"1\" \\(1 != 1\\)", true }, 707240116Smarcel { H_REQUIRE_STREQ_HEAD_NAME(1_2), H_REQUIRE_STREQ_BODY_NAME(1_2), 708240116Smarcel "1", "2", "\"1\" != \"2\" \\(1 != 2\\)", false }, 709240116Smarcel { H_REQUIRE_STREQ_HEAD_NAME(2_1), H_REQUIRE_STREQ_BODY_NAME(2_1), 710240116Smarcel "2", "1", "\"2\" != \"1\" \\(2 != 1\\)", false }, 711240116Smarcel { H_REQUIRE_STREQ_HEAD_NAME(2_2), H_REQUIRE_STREQ_BODY_NAME(2_2), 712240116Smarcel "2", "2", "\"2\" != \"2\" \\(2 != 2\\)", true }, 713240116Smarcel { H_REQUIRE_STREQ_MSG_HEAD_NAME(1_1), 714240116Smarcel H_REQUIRE_STREQ_MSG_BODY_NAME(1_1), 715240116Smarcel "1", "1", "\"1\" != \"1\" \\(1 != 1\\): 1 does not match 1", true }, 716240116Smarcel { H_REQUIRE_STREQ_MSG_HEAD_NAME(1_2), 717240116Smarcel H_REQUIRE_STREQ_MSG_BODY_NAME(1_2), 718240116Smarcel "1", "2", "\"1\" != \"2\" \\(1 != 2\\): 1 does not match 2", false }, 719240116Smarcel { H_REQUIRE_STREQ_MSG_HEAD_NAME(2_1), 720240116Smarcel H_REQUIRE_STREQ_MSG_BODY_NAME(2_1), 721240116Smarcel "2", "1", "\"2\" != \"1\" \\(2 != 1\\): 2 does not match 1", false }, 722240116Smarcel { H_REQUIRE_STREQ_MSG_HEAD_NAME(2_2), 723240116Smarcel H_REQUIRE_STREQ_MSG_BODY_NAME(2_2), 724240116Smarcel "2", "2", "\"2\" != \"2\" \\(2 != 2\\): 2 does not match 2", true }, 725240116Smarcel { H_REQUIRE_STREQ_HEAD_NAME(vars), H_REQUIRE_STREQ_BODY_NAME(vars), 726240116Smarcel require_streq_var1, require_streq_var2, 727240116Smarcel "require_streq_var1 != require_streq_var2 \\(" 728240116Smarcel REQUIRE_STREQ_VAR1 " != " REQUIRE_STREQ_VAR2 "\\)", false }, 729240116Smarcel { NULL, NULL, 0, 0, "", false } 730240116Smarcel }; 731240116Smarcel do_require_eq_tests(tests); 732240116Smarcel} 733240116Smarcel 734240116Smarcel/* --------------------------------------------------------------------- 735260029Sjmmv * Test cases for the ATF_REQUIRE_MATCH and ATF_REQUIRE_MATCH_MSG macros. 736260029Sjmmv * --------------------------------------------------------------------- */ 737260029Sjmmv 738260029SjmmvH_REQUIRE_MATCH(yes, "hello [a-z]+", "abc hello world"); 739260029SjmmvH_REQUIRE_MATCH(no, "hello [a-z]+", "abc hello WORLD"); 740260029SjmmvH_REQUIRE_MATCH_MSG(yes, "hello [a-z]+", "abc hello world", "lowercase"); 741260029SjmmvH_REQUIRE_MATCH_MSG(no, "hello [a-z]+", "abc hello WORLD", "uppercase"); 742260029Sjmmv 743260029SjmmvATF_TC(require_match); 744260029SjmmvATF_TC_HEAD(require_match, tc) 745260029Sjmmv{ 746260029Sjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_MATCH and " 747260029Sjmmv "ATF_REQUIRE_MATCH_MSG macros"); 748260029Sjmmv} 749260029SjmmvATF_TC_BODY(require_match, tc) 750260029Sjmmv{ 751260029Sjmmv struct require_eq_test tests[] = { 752260029Sjmmv { H_REQUIRE_MATCH_HEAD_NAME(yes), H_REQUIRE_MATCH_BODY_NAME(yes), 753260029Sjmmv "hello [a-z]+", "abc hello world", "", true }, 754260029Sjmmv { H_REQUIRE_MATCH_HEAD_NAME(no), H_REQUIRE_MATCH_BODY_NAME(no), 755260029Sjmmv "hello [a-z]+", "abc hello WORLD", 756260029Sjmmv "'hello \\[a-z\\]\\+' not matched in 'abc hello WORLD'", false }, 757260029Sjmmv { H_REQUIRE_MATCH_MSG_HEAD_NAME(yes), 758260029Sjmmv H_REQUIRE_MATCH_MSG_BODY_NAME(yes), 759260029Sjmmv "hello [a-z]+", "abc hello world", "", true }, 760260029Sjmmv { H_REQUIRE_MATCH_MSG_HEAD_NAME(no), H_REQUIRE_MATCH_MSG_BODY_NAME(no), 761260029Sjmmv "hello [a-z]+", "abc hello WORLD", 762260029Sjmmv "'hello \\[a-z\\]\\+' not matched in 'abc hello WORLD': uppercase", 763260029Sjmmv false }, 764260029Sjmmv { NULL, NULL, 0, 0, "", false } 765260029Sjmmv }; 766260029Sjmmv do_require_eq_tests(tests); 767260029Sjmmv} 768260029Sjmmv 769260029Sjmmv/* --------------------------------------------------------------------- 770240116Smarcel * Miscellaneous test cases covering several macros. 771240116Smarcel * --------------------------------------------------------------------- */ 772240116Smarcel 773240116Smarcelstatic 774240116Smarcelbool 775240116Smarcelaux_bool(const char *fmt ATF_DEFS_ATTRIBUTE_UNUSED) 776240116Smarcel{ 777240116Smarcel return false; 778240116Smarcel} 779240116Smarcel 780240116Smarcelstatic 781240116Smarcelconst char * 782240116Smarcelaux_str(const char *fmt ATF_DEFS_ATTRIBUTE_UNUSED) 783240116Smarcel{ 784240116Smarcel return "foo"; 785240116Smarcel} 786240116Smarcel 787240116SmarcelH_CHECK(msg, aux_bool("%d")); 788240116SmarcelH_REQUIRE(msg, aux_bool("%d")); 789240116SmarcelH_CHECK_STREQ(msg, aux_str("%d"), ""); 790240116SmarcelH_REQUIRE_STREQ(msg, aux_str("%d"), ""); 791240116Smarcel 792240116SmarcelATF_TC(msg_embedded_fmt); 793240116SmarcelATF_TC_HEAD(msg_embedded_fmt, tc) 794240116Smarcel{ 795240116Smarcel atf_tc_set_md_var(tc, "descr", "Tests that format strings passed " 796240116Smarcel "as part of the automatically-generated messages " 797240116Smarcel "do not get expanded"); 798240116Smarcel} 799240116SmarcelATF_TC_BODY(msg_embedded_fmt, tc) 800240116Smarcel{ 801240116Smarcel struct test { 802240116Smarcel void (*head)(atf_tc_t *); 803240116Smarcel void (*body)(const atf_tc_t *); 804240116Smarcel bool fatal; 805240116Smarcel const char *msg; 806240116Smarcel } *t, tests[] = { 807240116Smarcel { H_CHECK_HEAD_NAME(msg), H_CHECK_BODY_NAME(msg), false, 808240116Smarcel "aux_bool\\(\"%d\"\\) not met" }, 809240116Smarcel { H_REQUIRE_HEAD_NAME(msg), H_REQUIRE_BODY_NAME(msg), true, 810240116Smarcel "aux_bool\\(\"%d\"\\) not met" }, 811240116Smarcel { H_CHECK_STREQ_HEAD_NAME(msg), H_CHECK_STREQ_BODY_NAME(msg), false, 812240116Smarcel "aux_str\\(\"%d\"\\) != \"\" \\(foo != \\)" }, 813240116Smarcel { H_REQUIRE_STREQ_HEAD_NAME(msg), H_REQUIRE_STREQ_BODY_NAME(msg), true, 814240116Smarcel "aux_str\\(\"%d\"\\) != \"\" \\(foo != \\)" }, 815240116Smarcel { NULL, NULL, false, NULL } 816240116Smarcel }; 817240116Smarcel 818240116Smarcel for (t = &tests[0]; t->head != NULL; t++) { 819240116Smarcel printf("Checking with an expected '%s' message\n", t->msg); 820240116Smarcel 821240116Smarcel init_and_run_h_tc("h_check", t->head, t->body); 822240116Smarcel 823240116Smarcel if (t->fatal) { 824240116Smarcel bool matched = 825260029Sjmmv atf_utils_grep_file( 826260029Sjmmv "^failed: .*macros_test.c:[0-9]+: %s$", "result", t->msg); 827240116Smarcel ATF_CHECK_MSG(matched, "couldn't find error string in result"); 828240116Smarcel } else { 829260029Sjmmv bool matched = atf_utils_grep_file("Check failed: .*" 830260029Sjmmv "macros_test.c:[0-9]+: %s$", "error", t->msg); 831240116Smarcel ATF_CHECK_MSG(matched, "couldn't find error string in output"); 832240116Smarcel } 833240116Smarcel } 834240116Smarcel} 835240116Smarcel 836240116Smarcel/* --------------------------------------------------------------------- 837240116Smarcel * Tests cases for the header file. 838240116Smarcel * --------------------------------------------------------------------- */ 839240116Smarcel 840240116SmarcelHEADER_TC(include, "atf-c/macros.h"); 841240116SmarcelBUILD_TC(use, "macros_h_test.c", 842240116Smarcel "Tests that the macros provided by the atf-c/macros.h file " 843240116Smarcel "do not cause syntax errors when used", 844240116Smarcel "Build of macros_h_test.c failed; some macros in atf-c/macros.h " 845240116Smarcel "are broken"); 846240116Smarcel 847262855SjmmvATF_TC(detect_unused_tests); 848262855SjmmvATF_TC_HEAD(detect_unused_tests, tc) 849262855Sjmmv{ 850262855Sjmmv atf_tc_set_md_var(tc, "descr", 851262855Sjmmv "Tests that defining an unused test case raises a " 852262855Sjmmv "warning (and thus an error)"); 853262855Sjmmv} 854262855SjmmvATF_TC_BODY(detect_unused_tests, tc) 855262855Sjmmv{ 856262855Sjmmv const char* validate_compiler = 857262855Sjmmv "struct test_struct { int dummy; };\n" 858262855Sjmmv "#define define_unused static struct test_struct unused\n" 859262855Sjmmv "define_unused;\n"; 860262855Sjmmv 861262855Sjmmv atf_utils_create_file("compiler_test.c", "%s", validate_compiler); 862262855Sjmmv if (build_check_c_o("compiler_test.c")) 863262855Sjmmv atf_tc_expect_fail("Compiler does not raise a warning on an unused " 864262855Sjmmv "static global variable declared by a macro"); 865262855Sjmmv 866262855Sjmmv if (build_check_c_o_srcdir(tc, "unused_test.c")) 867262855Sjmmv atf_tc_fail("Build of unused_test.c passed; unused test cases are " 868262855Sjmmv "not properly detected"); 869262855Sjmmv} 870262855Sjmmv 871240116Smarcel/* --------------------------------------------------------------------- 872240116Smarcel * Main. 873240116Smarcel * --------------------------------------------------------------------- */ 874240116Smarcel 875240116SmarcelATF_TP_ADD_TCS(tp) 876240116Smarcel{ 877240116Smarcel ATF_TP_ADD_TC(tp, check); 878240116Smarcel ATF_TP_ADD_TC(tp, check_eq); 879240116Smarcel ATF_TP_ADD_TC(tp, check_streq); 880240116Smarcel ATF_TP_ADD_TC(tp, check_errno); 881260029Sjmmv ATF_TP_ADD_TC(tp, check_match); 882240116Smarcel 883240116Smarcel ATF_TP_ADD_TC(tp, require); 884240116Smarcel ATF_TP_ADD_TC(tp, require_eq); 885240116Smarcel ATF_TP_ADD_TC(tp, require_streq); 886240116Smarcel ATF_TP_ADD_TC(tp, require_errno); 887260029Sjmmv ATF_TP_ADD_TC(tp, require_match); 888240116Smarcel 889240116Smarcel ATF_TP_ADD_TC(tp, msg_embedded_fmt); 890240116Smarcel 891240116Smarcel /* Add the test cases for the header file. */ 892240116Smarcel ATF_TP_ADD_TC(tp, include); 893240116Smarcel ATF_TP_ADD_TC(tp, use); 894240116Smarcel ATF_TP_ADD_TC(tp, detect_unused_tests); 895240116Smarcel 896240116Smarcel return atf_no_error(); 897240116Smarcel} 898