1*edebbb8eSjmmv /* 2*edebbb8eSjmmv * Automated Testing Framework (atf) 3*edebbb8eSjmmv * 4*edebbb8eSjmmv * Copyright (c) 2008, 2009, 2010 The NetBSD Foundation, Inc. 5*edebbb8eSjmmv * All rights reserved. 6*edebbb8eSjmmv * 7*edebbb8eSjmmv * Redistribution and use in source and binary forms, with or without 8*edebbb8eSjmmv * modification, are permitted provided that the following conditions 9*edebbb8eSjmmv * are met: 10*edebbb8eSjmmv * 1. Redistributions of source code must retain the above copyright 11*edebbb8eSjmmv * notice, this list of conditions and the following disclaimer. 12*edebbb8eSjmmv * 2. Redistributions in binary form must reproduce the above copyright 13*edebbb8eSjmmv * notice, this list of conditions and the following disclaimer in the 14*edebbb8eSjmmv * documentation and/or other materials provided with the distribution. 15*edebbb8eSjmmv * 16*edebbb8eSjmmv * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17*edebbb8eSjmmv * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18*edebbb8eSjmmv * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19*edebbb8eSjmmv * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20*edebbb8eSjmmv * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21*edebbb8eSjmmv * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22*edebbb8eSjmmv * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23*edebbb8eSjmmv * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24*edebbb8eSjmmv * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25*edebbb8eSjmmv * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26*edebbb8eSjmmv * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27*edebbb8eSjmmv * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28*edebbb8eSjmmv */ 29*edebbb8eSjmmv 30*edebbb8eSjmmv #include <sys/types.h> 31*edebbb8eSjmmv #include <sys/wait.h> 32*edebbb8eSjmmv 33*edebbb8eSjmmv #include <errno.h> 34*edebbb8eSjmmv #include <fcntl.h> 35*edebbb8eSjmmv #include <stdarg.h> 36*edebbb8eSjmmv #include <stdbool.h> 37*edebbb8eSjmmv #include <stdio.h> 38*edebbb8eSjmmv #include <stdlib.h> 39*edebbb8eSjmmv #include <string.h> 40*edebbb8eSjmmv #include <unistd.h> 41*edebbb8eSjmmv 42*edebbb8eSjmmv #include <atf-c.h> 43*edebbb8eSjmmv 44*edebbb8eSjmmv #include "atf-c/fs.h" 45*edebbb8eSjmmv #include "atf-c/process.h" 46*edebbb8eSjmmv #include "atf-c/text.h" 47*edebbb8eSjmmv 48*edebbb8eSjmmv #include "test_helpers.h" 49*edebbb8eSjmmv 50*edebbb8eSjmmv /* --------------------------------------------------------------------- 51*edebbb8eSjmmv * Auxiliary functions. 52*edebbb8eSjmmv * --------------------------------------------------------------------- */ 53*edebbb8eSjmmv 54*edebbb8eSjmmv static 55*edebbb8eSjmmv void 56*edebbb8eSjmmv create_ctl_file(const atf_tc_t *tc, const char *name) 57*edebbb8eSjmmv { 58*edebbb8eSjmmv atf_fs_path_t p; 59*edebbb8eSjmmv 60*edebbb8eSjmmv RE(atf_fs_path_init_fmt(&p, "%s", name)); 61*edebbb8eSjmmv ATF_REQUIRE(open(atf_fs_path_cstring(&p), 62*edebbb8eSjmmv O_CREAT | O_WRONLY | O_TRUNC, 0644) != -1); 63*edebbb8eSjmmv atf_fs_path_fini(&p); 64*edebbb8eSjmmv } 65*edebbb8eSjmmv 66*edebbb8eSjmmv static 67*edebbb8eSjmmv bool 68*edebbb8eSjmmv exists(const char *p) 69*edebbb8eSjmmv { 70*edebbb8eSjmmv bool b; 71*edebbb8eSjmmv atf_fs_path_t pp; 72*edebbb8eSjmmv 73*edebbb8eSjmmv RE(atf_fs_path_init_fmt(&pp, "%s", p)); 74*edebbb8eSjmmv RE(atf_fs_exists(&pp, &b)); 75*edebbb8eSjmmv atf_fs_path_fini(&pp); 76*edebbb8eSjmmv 77*edebbb8eSjmmv return b; 78*edebbb8eSjmmv } 79*edebbb8eSjmmv 80*edebbb8eSjmmv static 81*edebbb8eSjmmv void 82*edebbb8eSjmmv init_and_run_h_tc(const char *name, void (*head)(atf_tc_t *), 83*edebbb8eSjmmv void (*body)(const atf_tc_t *)) 84*edebbb8eSjmmv { 85*edebbb8eSjmmv atf_tc_t tc; 86*edebbb8eSjmmv atf_map_t config; 87*edebbb8eSjmmv 88*edebbb8eSjmmv RE(atf_map_init(&config)); 89*edebbb8eSjmmv RE(atf_tc_init(&tc, name, head, body, NULL, &config)); 90*edebbb8eSjmmv run_h_tc(&tc, "output", "error", "result"); 91*edebbb8eSjmmv atf_tc_fini(&tc); 92*edebbb8eSjmmv atf_map_fini(&config); 93*edebbb8eSjmmv } 94*edebbb8eSjmmv 95*edebbb8eSjmmv /* --------------------------------------------------------------------- 96*edebbb8eSjmmv * Helper test cases. 97*edebbb8eSjmmv * --------------------------------------------------------------------- */ 98*edebbb8eSjmmv 99*edebbb8eSjmmv #define H_DEF(id, macro) \ 100*edebbb8eSjmmv ATF_TC_HEAD(h_ ## id, tc) \ 101*edebbb8eSjmmv { \ 102*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Helper test case"); \ 103*edebbb8eSjmmv } \ 104*edebbb8eSjmmv ATF_TC_BODY(h_ ## id, tc) \ 105*edebbb8eSjmmv { \ 106*edebbb8eSjmmv create_ctl_file(tc, "before"); \ 107*edebbb8eSjmmv macro; \ 108*edebbb8eSjmmv create_ctl_file(tc, "after"); \ 109*edebbb8eSjmmv } 110*edebbb8eSjmmv 111*edebbb8eSjmmv #define H_CHECK_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_ ## id) 112*edebbb8eSjmmv #define H_CHECK_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_ ## id) 113*edebbb8eSjmmv #define H_CHECK(id, condition) \ 114*edebbb8eSjmmv H_DEF(check_ ## id, ATF_CHECK(condition)) 115*edebbb8eSjmmv 116*edebbb8eSjmmv #define H_CHECK_MSG_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_msg_ ## id) 117*edebbb8eSjmmv #define H_CHECK_MSG_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_msg_ ## id) 118*edebbb8eSjmmv #define H_CHECK_MSG(id, condition, msg) \ 119*edebbb8eSjmmv H_DEF(check_msg_ ## id, ATF_CHECK_MSG(condition, msg)) 120*edebbb8eSjmmv 121*edebbb8eSjmmv #define H_CHECK_EQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_eq_ ## id) 122*edebbb8eSjmmv #define H_CHECK_EQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_eq_ ## id) 123*edebbb8eSjmmv #define H_CHECK_EQ(id, v1, v2) \ 124*edebbb8eSjmmv H_DEF(check_eq_ ## id, ATF_CHECK_EQ(v1, v2)) 125*edebbb8eSjmmv 126*edebbb8eSjmmv #define H_CHECK_STREQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_streq_ ## id) 127*edebbb8eSjmmv #define H_CHECK_STREQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_streq_ ## id) 128*edebbb8eSjmmv #define H_CHECK_STREQ(id, v1, v2) \ 129*edebbb8eSjmmv H_DEF(check_streq_ ## id, ATF_CHECK_STREQ(v1, v2)) 130*edebbb8eSjmmv 131*edebbb8eSjmmv #define H_CHECK_EQ_MSG_HEAD_NAME(id) \ 132*edebbb8eSjmmv ATF_TC_HEAD_NAME(h_check_eq_msg_ ## id) 133*edebbb8eSjmmv #define H_CHECK_EQ_MSG_BODY_NAME(id) \ 134*edebbb8eSjmmv ATF_TC_BODY_NAME(h_check_eq_msg_ ## id) 135*edebbb8eSjmmv #define H_CHECK_EQ_MSG(id, v1, v2, msg) \ 136*edebbb8eSjmmv H_DEF(check_eq_msg_ ## id, ATF_CHECK_EQ_MSG(v1, v2, msg)) 137*edebbb8eSjmmv 138*edebbb8eSjmmv #define H_CHECK_STREQ_MSG_HEAD_NAME(id) \ 139*edebbb8eSjmmv ATF_TC_HEAD_NAME(h_check_streq_msg_ ## id) 140*edebbb8eSjmmv #define H_CHECK_STREQ_MSG_BODY_NAME(id) \ 141*edebbb8eSjmmv ATF_TC_BODY_NAME(h_check_streq_msg_ ## id) 142*edebbb8eSjmmv #define H_CHECK_STREQ_MSG(id, v1, v2, msg) \ 143*edebbb8eSjmmv H_DEF(check_streq_msg_ ## id, ATF_CHECK_STREQ_MSG(v1, v2, msg)) 144*edebbb8eSjmmv 145*edebbb8eSjmmv #define H_CHECK_ERRNO_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_check_errno_ ## id) 146*edebbb8eSjmmv #define H_CHECK_ERRNO_BODY_NAME(id) ATF_TC_BODY_NAME(h_check_errno_ ## id) 147*edebbb8eSjmmv #define H_CHECK_ERRNO(id, exp_errno, bool_expr) \ 148*edebbb8eSjmmv H_DEF(check_errno_ ## id, ATF_CHECK_ERRNO(exp_errno, bool_expr)) 149*edebbb8eSjmmv 150*edebbb8eSjmmv #define H_REQUIRE_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_ ## id) 151*edebbb8eSjmmv #define H_REQUIRE_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_ ## id) 152*edebbb8eSjmmv #define H_REQUIRE(id, condition) \ 153*edebbb8eSjmmv H_DEF(require_ ## id, ATF_REQUIRE(condition)) 154*edebbb8eSjmmv 155*edebbb8eSjmmv #define H_REQUIRE_MSG_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_msg_ ## id) 156*edebbb8eSjmmv #define H_REQUIRE_MSG_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_msg_ ## id) 157*edebbb8eSjmmv #define H_REQUIRE_MSG(id, condition, msg) \ 158*edebbb8eSjmmv H_DEF(require_msg_ ## id, ATF_REQUIRE_MSG(condition, msg)) 159*edebbb8eSjmmv 160*edebbb8eSjmmv #define H_REQUIRE_EQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_eq_ ## id) 161*edebbb8eSjmmv #define H_REQUIRE_EQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_eq_ ## id) 162*edebbb8eSjmmv #define H_REQUIRE_EQ(id, v1, v2) \ 163*edebbb8eSjmmv H_DEF(require_eq_ ## id, ATF_REQUIRE_EQ(v1, v2)) 164*edebbb8eSjmmv 165*edebbb8eSjmmv #define H_REQUIRE_STREQ_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_streq_ ## id) 166*edebbb8eSjmmv #define H_REQUIRE_STREQ_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_streq_ ## id) 167*edebbb8eSjmmv #define H_REQUIRE_STREQ(id, v1, v2) \ 168*edebbb8eSjmmv H_DEF(require_streq_ ## id, ATF_REQUIRE_STREQ(v1, v2)) 169*edebbb8eSjmmv 170*edebbb8eSjmmv #define H_REQUIRE_EQ_MSG_HEAD_NAME(id) \ 171*edebbb8eSjmmv ATF_TC_HEAD_NAME(h_require_eq_msg_ ## id) 172*edebbb8eSjmmv #define H_REQUIRE_EQ_MSG_BODY_NAME(id) \ 173*edebbb8eSjmmv ATF_TC_BODY_NAME(h_require_eq_msg_ ## id) 174*edebbb8eSjmmv #define H_REQUIRE_EQ_MSG(id, v1, v2, msg) \ 175*edebbb8eSjmmv H_DEF(require_eq_msg_ ## id, ATF_REQUIRE_EQ_MSG(v1, v2, msg)) 176*edebbb8eSjmmv 177*edebbb8eSjmmv #define H_REQUIRE_STREQ_MSG_HEAD_NAME(id) \ 178*edebbb8eSjmmv ATF_TC_HEAD_NAME(h_require_streq_msg_ ## id) 179*edebbb8eSjmmv #define H_REQUIRE_STREQ_MSG_BODY_NAME(id) \ 180*edebbb8eSjmmv ATF_TC_BODY_NAME(h_require_streq_msg_ ## id) 181*edebbb8eSjmmv #define H_REQUIRE_STREQ_MSG(id, v1, v2, msg) \ 182*edebbb8eSjmmv H_DEF(require_streq_msg_ ## id, ATF_REQUIRE_STREQ_MSG(v1, v2, msg)) 183*edebbb8eSjmmv 184*edebbb8eSjmmv #define H_REQUIRE_ERRNO_HEAD_NAME(id) ATF_TC_HEAD_NAME(h_require_errno_ ## id) 185*edebbb8eSjmmv #define H_REQUIRE_ERRNO_BODY_NAME(id) ATF_TC_BODY_NAME(h_require_errno_ ## id) 186*edebbb8eSjmmv #define H_REQUIRE_ERRNO(id, exp_errno, bool_expr) \ 187*edebbb8eSjmmv H_DEF(require_errno_ ## id, ATF_REQUIRE_ERRNO(exp_errno, bool_expr)) 188*edebbb8eSjmmv 189*edebbb8eSjmmv /* --------------------------------------------------------------------- 190*edebbb8eSjmmv * Test cases for the ATF_{CHECK,REQUIRE}_ERRNO macros. 191*edebbb8eSjmmv * --------------------------------------------------------------------- */ 192*edebbb8eSjmmv 193*edebbb8eSjmmv static int 194*edebbb8eSjmmv errno_fail_stub(const int raised_errno) 195*edebbb8eSjmmv { 196*edebbb8eSjmmv errno = raised_errno; 197*edebbb8eSjmmv return -1; 198*edebbb8eSjmmv } 199*edebbb8eSjmmv 200*edebbb8eSjmmv static int 201*edebbb8eSjmmv errno_ok_stub(void) 202*edebbb8eSjmmv { 203*edebbb8eSjmmv return 0; 204*edebbb8eSjmmv } 205*edebbb8eSjmmv 206*edebbb8eSjmmv H_CHECK_ERRNO(no_error, -1, errno_ok_stub() == -1); 207*edebbb8eSjmmv H_CHECK_ERRNO(errno_ok, 2, errno_fail_stub(2) == -1); 208*edebbb8eSjmmv H_CHECK_ERRNO(errno_fail, 3, errno_fail_stub(4) == -1); 209*edebbb8eSjmmv 210*edebbb8eSjmmv H_REQUIRE_ERRNO(no_error, -1, errno_ok_stub() == -1); 211*edebbb8eSjmmv H_REQUIRE_ERRNO(errno_ok, 2, errno_fail_stub(2) == -1); 212*edebbb8eSjmmv H_REQUIRE_ERRNO(errno_fail, 3, errno_fail_stub(4) == -1); 213*edebbb8eSjmmv 214*edebbb8eSjmmv ATF_TC(check_errno); 215*edebbb8eSjmmv ATF_TC_HEAD(check_errno, tc) 216*edebbb8eSjmmv { 217*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_ERRNO macro"); 218*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 219*edebbb8eSjmmv } 220*edebbb8eSjmmv ATF_TC_BODY(check_errno, tc) 221*edebbb8eSjmmv { 222*edebbb8eSjmmv struct test { 223*edebbb8eSjmmv void (*head)(atf_tc_t *); 224*edebbb8eSjmmv void (*body)(const atf_tc_t *); 225*edebbb8eSjmmv bool ok; 226*edebbb8eSjmmv const char *exp_regex; 227*edebbb8eSjmmv } *t, tests[] = { 228*edebbb8eSjmmv { H_CHECK_ERRNO_HEAD_NAME(no_error), 229*edebbb8eSjmmv H_CHECK_ERRNO_BODY_NAME(no_error), 230*edebbb8eSjmmv false, "Expected true value in errno_ok_stub\\(\\) == -1" }, 231*edebbb8eSjmmv { H_CHECK_ERRNO_HEAD_NAME(errno_ok), 232*edebbb8eSjmmv H_CHECK_ERRNO_BODY_NAME(errno_ok), 233*edebbb8eSjmmv true, NULL }, 234*edebbb8eSjmmv { H_CHECK_ERRNO_HEAD_NAME(errno_fail), 235*edebbb8eSjmmv H_CHECK_ERRNO_BODY_NAME(errno_fail), 236*edebbb8eSjmmv false, "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" }, 237*edebbb8eSjmmv { NULL, NULL, false, NULL } 238*edebbb8eSjmmv }; 239*edebbb8eSjmmv 240*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 241*edebbb8eSjmmv init_and_run_h_tc("h_check_errno", t->head, t->body); 242*edebbb8eSjmmv 243*edebbb8eSjmmv ATF_REQUIRE(exists("before")); 244*edebbb8eSjmmv ATF_REQUIRE(exists("after")); 245*edebbb8eSjmmv 246*edebbb8eSjmmv if (t->ok) { 247*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^passed")); 248*edebbb8eSjmmv } else { 249*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^failed")); 250*edebbb8eSjmmv ATF_REQUIRE(grep_file("error", "macros_test.c:[0-9]+: %s$", 251*edebbb8eSjmmv t->exp_regex)); 252*edebbb8eSjmmv } 253*edebbb8eSjmmv 254*edebbb8eSjmmv ATF_REQUIRE(unlink("before") != -1); 255*edebbb8eSjmmv ATF_REQUIRE(unlink("after") != -1); 256*edebbb8eSjmmv } 257*edebbb8eSjmmv } 258*edebbb8eSjmmv 259*edebbb8eSjmmv ATF_TC(require_errno); 260*edebbb8eSjmmv ATF_TC_HEAD(require_errno, tc) 261*edebbb8eSjmmv { 262*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_ERRNO macro"); 263*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 264*edebbb8eSjmmv } 265*edebbb8eSjmmv ATF_TC_BODY(require_errno, tc) 266*edebbb8eSjmmv { 267*edebbb8eSjmmv struct test { 268*edebbb8eSjmmv void (*head)(atf_tc_t *); 269*edebbb8eSjmmv void (*body)(const atf_tc_t *); 270*edebbb8eSjmmv bool ok; 271*edebbb8eSjmmv const char *exp_regex; 272*edebbb8eSjmmv } *t, tests[] = { 273*edebbb8eSjmmv { H_REQUIRE_ERRNO_HEAD_NAME(no_error), 274*edebbb8eSjmmv H_REQUIRE_ERRNO_BODY_NAME(no_error), 275*edebbb8eSjmmv false, "Expected true value in errno_ok_stub\\(\\) == -1" }, 276*edebbb8eSjmmv { H_REQUIRE_ERRNO_HEAD_NAME(errno_ok), 277*edebbb8eSjmmv H_REQUIRE_ERRNO_BODY_NAME(errno_ok), 278*edebbb8eSjmmv true, NULL }, 279*edebbb8eSjmmv { H_REQUIRE_ERRNO_HEAD_NAME(errno_fail), 280*edebbb8eSjmmv H_REQUIRE_ERRNO_BODY_NAME(errno_fail), 281*edebbb8eSjmmv false, "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" }, 282*edebbb8eSjmmv { NULL, NULL, false, NULL } 283*edebbb8eSjmmv }; 284*edebbb8eSjmmv 285*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 286*edebbb8eSjmmv init_and_run_h_tc("h_require_errno", t->head, t->body); 287*edebbb8eSjmmv 288*edebbb8eSjmmv ATF_REQUIRE(exists("before")); 289*edebbb8eSjmmv if (t->ok) { 290*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^passed")); 291*edebbb8eSjmmv ATF_REQUIRE(exists("after")); 292*edebbb8eSjmmv } else { 293*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^failed: .*macros_test.c:[0-9]+: " 294*edebbb8eSjmmv "%s$", t->exp_regex)); 295*edebbb8eSjmmv ATF_REQUIRE(!exists("after")); 296*edebbb8eSjmmv } 297*edebbb8eSjmmv 298*edebbb8eSjmmv ATF_REQUIRE(unlink("before") != -1); 299*edebbb8eSjmmv if (t->ok) 300*edebbb8eSjmmv ATF_REQUIRE(unlink("after") != -1); 301*edebbb8eSjmmv } 302*edebbb8eSjmmv } 303*edebbb8eSjmmv 304*edebbb8eSjmmv /* --------------------------------------------------------------------- 305*edebbb8eSjmmv * Test cases for the ATF_CHECK and ATF_CHECK_MSG macros. 306*edebbb8eSjmmv * --------------------------------------------------------------------- */ 307*edebbb8eSjmmv 308*edebbb8eSjmmv H_CHECK(0, 0); 309*edebbb8eSjmmv H_CHECK(1, 1); 310*edebbb8eSjmmv H_CHECK_MSG(0, 0, "expected a false value"); 311*edebbb8eSjmmv H_CHECK_MSG(1, 1, "expected a true value"); 312*edebbb8eSjmmv 313*edebbb8eSjmmv ATF_TC(check); 314*edebbb8eSjmmv ATF_TC_HEAD(check, tc) 315*edebbb8eSjmmv { 316*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK and " 317*edebbb8eSjmmv "ATF_CHECK_MSG macros"); 318*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 319*edebbb8eSjmmv } 320*edebbb8eSjmmv ATF_TC_BODY(check, tc) 321*edebbb8eSjmmv { 322*edebbb8eSjmmv struct test { 323*edebbb8eSjmmv void (*head)(atf_tc_t *); 324*edebbb8eSjmmv void (*body)(const atf_tc_t *); 325*edebbb8eSjmmv bool value; 326*edebbb8eSjmmv const char *msg; 327*edebbb8eSjmmv bool ok; 328*edebbb8eSjmmv } *t, tests[] = { 329*edebbb8eSjmmv { H_CHECK_HEAD_NAME(0), H_CHECK_BODY_NAME(0), 0, 330*edebbb8eSjmmv "0 not met", false }, 331*edebbb8eSjmmv { H_CHECK_HEAD_NAME(1), H_CHECK_BODY_NAME(1), 1, 332*edebbb8eSjmmv "1 not met", true }, 333*edebbb8eSjmmv { H_CHECK_MSG_HEAD_NAME(0), H_CHECK_MSG_BODY_NAME(0), 0, 334*edebbb8eSjmmv "expected a false value", false }, 335*edebbb8eSjmmv { H_CHECK_MSG_HEAD_NAME(1), H_CHECK_MSG_BODY_NAME(1), 1, 336*edebbb8eSjmmv "expected a true value", true }, 337*edebbb8eSjmmv { NULL, NULL, false, NULL, false } 338*edebbb8eSjmmv }; 339*edebbb8eSjmmv 340*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 341*edebbb8eSjmmv printf("Checking with a %d value\n", t->value); 342*edebbb8eSjmmv 343*edebbb8eSjmmv init_and_run_h_tc("h_check", t->head, t->body); 344*edebbb8eSjmmv 345*edebbb8eSjmmv ATF_REQUIRE(exists("before")); 346*edebbb8eSjmmv ATF_REQUIRE(exists("after")); 347*edebbb8eSjmmv 348*edebbb8eSjmmv if (t->ok) { 349*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^passed")); 350*edebbb8eSjmmv } else { 351*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^failed")); 352*edebbb8eSjmmv ATF_REQUIRE(grep_file("error", "Check failed: .*" 353*edebbb8eSjmmv "macros_test.c:[0-9]+: %s$", t->msg)); 354*edebbb8eSjmmv } 355*edebbb8eSjmmv 356*edebbb8eSjmmv ATF_REQUIRE(unlink("before") != -1); 357*edebbb8eSjmmv ATF_REQUIRE(unlink("after") != -1); 358*edebbb8eSjmmv } 359*edebbb8eSjmmv } 360*edebbb8eSjmmv 361*edebbb8eSjmmv /* --------------------------------------------------------------------- 362*edebbb8eSjmmv * Test cases for the ATF_CHECK_*EQ_ macros. 363*edebbb8eSjmmv * --------------------------------------------------------------------- */ 364*edebbb8eSjmmv 365*edebbb8eSjmmv struct check_eq_test { 366*edebbb8eSjmmv void (*head)(atf_tc_t *); 367*edebbb8eSjmmv void (*body)(const atf_tc_t *); 368*edebbb8eSjmmv const char *v1; 369*edebbb8eSjmmv const char *v2; 370*edebbb8eSjmmv const char *msg; 371*edebbb8eSjmmv bool ok; 372*edebbb8eSjmmv }; 373*edebbb8eSjmmv 374*edebbb8eSjmmv static 375*edebbb8eSjmmv void 376*edebbb8eSjmmv do_check_eq_tests(const struct check_eq_test *tests) 377*edebbb8eSjmmv { 378*edebbb8eSjmmv const struct check_eq_test *t; 379*edebbb8eSjmmv 380*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 381*edebbb8eSjmmv printf("Checking with %s, %s and expecting %s\n", t->v1, t->v2, 382*edebbb8eSjmmv t->ok ? "true" : "false"); 383*edebbb8eSjmmv 384*edebbb8eSjmmv init_and_run_h_tc("h_check", t->head, t->body); 385*edebbb8eSjmmv 386*edebbb8eSjmmv ATF_CHECK(exists("before")); 387*edebbb8eSjmmv ATF_CHECK(exists("after")); 388*edebbb8eSjmmv 389*edebbb8eSjmmv if (t->ok) { 390*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^passed")); 391*edebbb8eSjmmv } else { 392*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^failed")); 393*edebbb8eSjmmv ATF_CHECK(grep_file("error", "Check failed: .*" 394*edebbb8eSjmmv "macros_test.c:[0-9]+: %s$", t->msg)); 395*edebbb8eSjmmv } 396*edebbb8eSjmmv 397*edebbb8eSjmmv ATF_CHECK(unlink("before") != -1); 398*edebbb8eSjmmv ATF_CHECK(unlink("after") != -1); 399*edebbb8eSjmmv } 400*edebbb8eSjmmv } 401*edebbb8eSjmmv 402*edebbb8eSjmmv H_CHECK_EQ(1_1, 1, 1); 403*edebbb8eSjmmv H_CHECK_EQ(1_2, 1, 2); 404*edebbb8eSjmmv H_CHECK_EQ(2_1, 2, 1); 405*edebbb8eSjmmv H_CHECK_EQ(2_2, 2, 2); 406*edebbb8eSjmmv H_CHECK_EQ_MSG(1_1, 1, 1, "1 does not match 1"); 407*edebbb8eSjmmv H_CHECK_EQ_MSG(1_2, 1, 2, "1 does not match 2"); 408*edebbb8eSjmmv H_CHECK_EQ_MSG(2_1, 2, 1, "2 does not match 1"); 409*edebbb8eSjmmv H_CHECK_EQ_MSG(2_2, 2, 2, "2 does not match 2"); 410*edebbb8eSjmmv 411*edebbb8eSjmmv ATF_TC(check_eq); 412*edebbb8eSjmmv ATF_TC_HEAD(check_eq, tc) 413*edebbb8eSjmmv { 414*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_EQ and " 415*edebbb8eSjmmv "ATF_CHECK_EQ_MSG macros"); 416*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 417*edebbb8eSjmmv } 418*edebbb8eSjmmv ATF_TC_BODY(check_eq, tc) 419*edebbb8eSjmmv { 420*edebbb8eSjmmv struct check_eq_test tests[] = { 421*edebbb8eSjmmv { H_CHECK_EQ_HEAD_NAME(1_1), H_CHECK_EQ_BODY_NAME(1_1), 422*edebbb8eSjmmv "1", "1", "1 != 1", true }, 423*edebbb8eSjmmv { H_CHECK_EQ_HEAD_NAME(1_2), H_CHECK_EQ_BODY_NAME(1_2), 424*edebbb8eSjmmv "1", "2", "1 != 2", false }, 425*edebbb8eSjmmv { H_CHECK_EQ_HEAD_NAME(2_1), H_CHECK_EQ_BODY_NAME(2_1), 426*edebbb8eSjmmv "2", "1", "2 != 1", false }, 427*edebbb8eSjmmv { H_CHECK_EQ_HEAD_NAME(2_2), H_CHECK_EQ_BODY_NAME(2_2), 428*edebbb8eSjmmv "2", "2", "2 != 2", true }, 429*edebbb8eSjmmv { H_CHECK_EQ_MSG_HEAD_NAME(1_1), H_CHECK_EQ_MSG_BODY_NAME(1_1), 430*edebbb8eSjmmv "1", "1", "1 != 1: 1 does not match 1", true }, 431*edebbb8eSjmmv { H_CHECK_EQ_MSG_HEAD_NAME(1_2), H_CHECK_EQ_MSG_BODY_NAME(1_2), 432*edebbb8eSjmmv "1", "2", "1 != 2: 1 does not match 2", false }, 433*edebbb8eSjmmv { H_CHECK_EQ_MSG_HEAD_NAME(2_1), H_CHECK_EQ_MSG_BODY_NAME(2_1), 434*edebbb8eSjmmv "2", "1", "2 != 1: 2 does not match 1", false }, 435*edebbb8eSjmmv { H_CHECK_EQ_MSG_HEAD_NAME(2_2), H_CHECK_EQ_MSG_BODY_NAME(2_2), 436*edebbb8eSjmmv "2", "2", "2 != 2: 2 does not match 2", true }, 437*edebbb8eSjmmv { NULL, NULL, 0, 0, "", false } 438*edebbb8eSjmmv }; 439*edebbb8eSjmmv do_check_eq_tests(tests); 440*edebbb8eSjmmv } 441*edebbb8eSjmmv 442*edebbb8eSjmmv H_CHECK_STREQ(1_1, "1", "1"); 443*edebbb8eSjmmv H_CHECK_STREQ(1_2, "1", "2"); 444*edebbb8eSjmmv H_CHECK_STREQ(2_1, "2", "1"); 445*edebbb8eSjmmv H_CHECK_STREQ(2_2, "2", "2"); 446*edebbb8eSjmmv H_CHECK_STREQ_MSG(1_1, "1", "1", "1 does not match 1"); 447*edebbb8eSjmmv H_CHECK_STREQ_MSG(1_2, "1", "2", "1 does not match 2"); 448*edebbb8eSjmmv H_CHECK_STREQ_MSG(2_1, "2", "1", "2 does not match 1"); 449*edebbb8eSjmmv H_CHECK_STREQ_MSG(2_2, "2", "2", "2 does not match 2"); 450*edebbb8eSjmmv #define CHECK_STREQ_VAR1 "5" 451*edebbb8eSjmmv #define CHECK_STREQ_VAR2 "9" 452*edebbb8eSjmmv const const char *check_streq_var1 = CHECK_STREQ_VAR1; 453*edebbb8eSjmmv const const char *check_streq_var2 = CHECK_STREQ_VAR2; 454*edebbb8eSjmmv H_CHECK_STREQ(vars, check_streq_var1, check_streq_var2); 455*edebbb8eSjmmv 456*edebbb8eSjmmv ATF_TC(check_streq); 457*edebbb8eSjmmv ATF_TC_HEAD(check_streq, tc) 458*edebbb8eSjmmv { 459*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_CHECK_STREQ and " 460*edebbb8eSjmmv "ATF_CHECK_STREQ_MSG macros"); 461*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 462*edebbb8eSjmmv } 463*edebbb8eSjmmv ATF_TC_BODY(check_streq, tc) 464*edebbb8eSjmmv { 465*edebbb8eSjmmv struct check_eq_test tests[] = { 466*edebbb8eSjmmv { H_CHECK_STREQ_HEAD_NAME(1_1), H_CHECK_STREQ_BODY_NAME(1_1), 467*edebbb8eSjmmv "1", "1", "\"1\" != \"1\" \\(1 != 1\\)", true }, 468*edebbb8eSjmmv { H_CHECK_STREQ_HEAD_NAME(1_2), H_CHECK_STREQ_BODY_NAME(1_2), 469*edebbb8eSjmmv "1", "2", "\"1\" != \"2\" \\(1 != 2\\)", false }, 470*edebbb8eSjmmv { H_CHECK_STREQ_HEAD_NAME(2_1), H_CHECK_STREQ_BODY_NAME(2_1), 471*edebbb8eSjmmv "2", "1", "\"2\" != \"1\" \\(2 != 1\\)", false }, 472*edebbb8eSjmmv { H_CHECK_STREQ_HEAD_NAME(2_2), H_CHECK_STREQ_BODY_NAME(2_2), 473*edebbb8eSjmmv "2", "2", "\"2\" != \"2\" \\(2 != 2\\)", true }, 474*edebbb8eSjmmv { H_CHECK_STREQ_MSG_HEAD_NAME(1_1), 475*edebbb8eSjmmv H_CHECK_STREQ_MSG_BODY_NAME(1_1), 476*edebbb8eSjmmv "1", "1", "\"1\" != \"1\" \\(1 != 1\\): 1 does not match 1", true }, 477*edebbb8eSjmmv { H_CHECK_STREQ_MSG_HEAD_NAME(1_2), 478*edebbb8eSjmmv H_CHECK_STREQ_MSG_BODY_NAME(1_2), 479*edebbb8eSjmmv "1", "2", "\"1\" != \"2\" \\(1 != 2\\): 1 does not match 2", false }, 480*edebbb8eSjmmv { H_CHECK_STREQ_MSG_HEAD_NAME(2_1), 481*edebbb8eSjmmv H_CHECK_STREQ_MSG_BODY_NAME(2_1), 482*edebbb8eSjmmv "2", "1", "\"2\" != \"1\" \\(2 != 1\\): 2 does not match 1", false }, 483*edebbb8eSjmmv { H_CHECK_STREQ_MSG_HEAD_NAME(2_2), 484*edebbb8eSjmmv H_CHECK_STREQ_MSG_BODY_NAME(2_2), 485*edebbb8eSjmmv "2", "2", "\"2\" != \"2\" \\(2 != 2\\): 2 does not match 2", true }, 486*edebbb8eSjmmv { H_CHECK_STREQ_HEAD_NAME(vars), H_CHECK_STREQ_BODY_NAME(vars), 487*edebbb8eSjmmv check_streq_var1, check_streq_var2, 488*edebbb8eSjmmv "check_streq_var1 != check_streq_var2 \\(" 489*edebbb8eSjmmv CHECK_STREQ_VAR1 " != " CHECK_STREQ_VAR2 "\\)", false }, 490*edebbb8eSjmmv { NULL, NULL, 0, 0, "", false } 491*edebbb8eSjmmv }; 492*edebbb8eSjmmv do_check_eq_tests(tests); 493*edebbb8eSjmmv } 494*edebbb8eSjmmv 495*edebbb8eSjmmv /* --------------------------------------------------------------------- 496*edebbb8eSjmmv * Test cases for the ATF_REQUIRE and ATF_REQUIRE_MSG macros. 497*edebbb8eSjmmv * --------------------------------------------------------------------- */ 498*edebbb8eSjmmv 499*edebbb8eSjmmv H_REQUIRE(0, 0); 500*edebbb8eSjmmv H_REQUIRE(1, 1); 501*edebbb8eSjmmv H_REQUIRE_MSG(0, 0, "expected a false value"); 502*edebbb8eSjmmv H_REQUIRE_MSG(1, 1, "expected a true value"); 503*edebbb8eSjmmv 504*edebbb8eSjmmv ATF_TC(require); 505*edebbb8eSjmmv ATF_TC_HEAD(require, tc) 506*edebbb8eSjmmv { 507*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE and " 508*edebbb8eSjmmv "ATF_REQUIRE_MSG macros"); 509*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 510*edebbb8eSjmmv } 511*edebbb8eSjmmv ATF_TC_BODY(require, tc) 512*edebbb8eSjmmv { 513*edebbb8eSjmmv struct test { 514*edebbb8eSjmmv void (*head)(atf_tc_t *); 515*edebbb8eSjmmv void (*body)(const atf_tc_t *); 516*edebbb8eSjmmv bool value; 517*edebbb8eSjmmv const char *msg; 518*edebbb8eSjmmv bool ok; 519*edebbb8eSjmmv } *t, tests[] = { 520*edebbb8eSjmmv { H_REQUIRE_HEAD_NAME(0), H_REQUIRE_BODY_NAME(0), 0, 521*edebbb8eSjmmv "0 not met", false }, 522*edebbb8eSjmmv { H_REQUIRE_HEAD_NAME(1), H_REQUIRE_BODY_NAME(1), 1, 523*edebbb8eSjmmv "1 not met", true }, 524*edebbb8eSjmmv { H_REQUIRE_MSG_HEAD_NAME(0), H_REQUIRE_MSG_BODY_NAME(0), 0, 525*edebbb8eSjmmv "expected a false value", false }, 526*edebbb8eSjmmv { H_REQUIRE_MSG_HEAD_NAME(1), H_REQUIRE_MSG_BODY_NAME(1), 1, 527*edebbb8eSjmmv "expected a true value", true }, 528*edebbb8eSjmmv { NULL, NULL, false, NULL, false } 529*edebbb8eSjmmv }; 530*edebbb8eSjmmv 531*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 532*edebbb8eSjmmv printf("Checking with a %d value\n", t->value); 533*edebbb8eSjmmv 534*edebbb8eSjmmv init_and_run_h_tc("h_require", t->head, t->body); 535*edebbb8eSjmmv 536*edebbb8eSjmmv ATF_REQUIRE(exists("before")); 537*edebbb8eSjmmv if (t->ok) { 538*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^passed")); 539*edebbb8eSjmmv ATF_REQUIRE(exists("after")); 540*edebbb8eSjmmv } else { 541*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^failed: .*macros_test.c:[0-9]+: " 542*edebbb8eSjmmv "%s$", t->msg)); 543*edebbb8eSjmmv ATF_REQUIRE(!exists("after")); 544*edebbb8eSjmmv } 545*edebbb8eSjmmv 546*edebbb8eSjmmv ATF_REQUIRE(unlink("before") != -1); 547*edebbb8eSjmmv if (t->ok) 548*edebbb8eSjmmv ATF_REQUIRE(unlink("after") != -1); 549*edebbb8eSjmmv } 550*edebbb8eSjmmv } 551*edebbb8eSjmmv 552*edebbb8eSjmmv /* --------------------------------------------------------------------- 553*edebbb8eSjmmv * Test cases for the ATF_REQUIRE_*EQ_ macros. 554*edebbb8eSjmmv * --------------------------------------------------------------------- */ 555*edebbb8eSjmmv 556*edebbb8eSjmmv struct require_eq_test { 557*edebbb8eSjmmv void (*head)(atf_tc_t *); 558*edebbb8eSjmmv void (*body)(const atf_tc_t *); 559*edebbb8eSjmmv const char *v1; 560*edebbb8eSjmmv const char *v2; 561*edebbb8eSjmmv const char *msg; 562*edebbb8eSjmmv bool ok; 563*edebbb8eSjmmv }; 564*edebbb8eSjmmv 565*edebbb8eSjmmv static 566*edebbb8eSjmmv void 567*edebbb8eSjmmv do_require_eq_tests(const struct require_eq_test *tests) 568*edebbb8eSjmmv { 569*edebbb8eSjmmv const struct require_eq_test *t; 570*edebbb8eSjmmv 571*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 572*edebbb8eSjmmv printf("Checking with %s, %s and expecting %s\n", t->v1, t->v2, 573*edebbb8eSjmmv t->ok ? "true" : "false"); 574*edebbb8eSjmmv 575*edebbb8eSjmmv init_and_run_h_tc("h_require", t->head, t->body); 576*edebbb8eSjmmv 577*edebbb8eSjmmv ATF_REQUIRE(exists("before")); 578*edebbb8eSjmmv if (t->ok) { 579*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^passed")); 580*edebbb8eSjmmv ATF_REQUIRE(exists("after")); 581*edebbb8eSjmmv } else { 582*edebbb8eSjmmv ATF_REQUIRE(grep_file("result", "^failed: .*macros_test.c" 583*edebbb8eSjmmv ":[0-9]+: %s$", t->msg)); 584*edebbb8eSjmmv ATF_REQUIRE(!exists("after")); 585*edebbb8eSjmmv } 586*edebbb8eSjmmv 587*edebbb8eSjmmv ATF_REQUIRE(unlink("before") != -1); 588*edebbb8eSjmmv if (t->ok) 589*edebbb8eSjmmv ATF_REQUIRE(unlink("after") != -1); 590*edebbb8eSjmmv } 591*edebbb8eSjmmv } 592*edebbb8eSjmmv 593*edebbb8eSjmmv H_REQUIRE_EQ(1_1, 1, 1); 594*edebbb8eSjmmv H_REQUIRE_EQ(1_2, 1, 2); 595*edebbb8eSjmmv H_REQUIRE_EQ(2_1, 2, 1); 596*edebbb8eSjmmv H_REQUIRE_EQ(2_2, 2, 2); 597*edebbb8eSjmmv H_REQUIRE_EQ_MSG(1_1, 1, 1, "1 does not match 1"); 598*edebbb8eSjmmv H_REQUIRE_EQ_MSG(1_2, 1, 2, "1 does not match 2"); 599*edebbb8eSjmmv H_REQUIRE_EQ_MSG(2_1, 2, 1, "2 does not match 1"); 600*edebbb8eSjmmv H_REQUIRE_EQ_MSG(2_2, 2, 2, "2 does not match 2"); 601*edebbb8eSjmmv 602*edebbb8eSjmmv ATF_TC(require_eq); 603*edebbb8eSjmmv ATF_TC_HEAD(require_eq, tc) 604*edebbb8eSjmmv { 605*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_EQ and " 606*edebbb8eSjmmv "ATF_REQUIRE_EQ_MSG macros"); 607*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 608*edebbb8eSjmmv } 609*edebbb8eSjmmv ATF_TC_BODY(require_eq, tc) 610*edebbb8eSjmmv { 611*edebbb8eSjmmv struct require_eq_test tests[] = { 612*edebbb8eSjmmv { H_REQUIRE_EQ_HEAD_NAME(1_1), H_REQUIRE_EQ_BODY_NAME(1_1), 613*edebbb8eSjmmv "1", "1", "1 != 1", true }, 614*edebbb8eSjmmv { H_REQUIRE_EQ_HEAD_NAME(1_2), H_REQUIRE_EQ_BODY_NAME(1_2), 615*edebbb8eSjmmv "1", "2", "1 != 2", false }, 616*edebbb8eSjmmv { H_REQUIRE_EQ_HEAD_NAME(2_1), H_REQUIRE_EQ_BODY_NAME(2_1), 617*edebbb8eSjmmv "2", "1", "2 != 1", false }, 618*edebbb8eSjmmv { H_REQUIRE_EQ_HEAD_NAME(2_2), H_REQUIRE_EQ_BODY_NAME(2_2), 619*edebbb8eSjmmv "2", "2", "2 != 2", true }, 620*edebbb8eSjmmv { H_REQUIRE_EQ_MSG_HEAD_NAME(1_1), H_REQUIRE_EQ_MSG_BODY_NAME(1_1), 621*edebbb8eSjmmv "1", "1", "1 != 1: 1 does not match 1", true }, 622*edebbb8eSjmmv { H_REQUIRE_EQ_MSG_HEAD_NAME(1_2), H_REQUIRE_EQ_MSG_BODY_NAME(1_2), 623*edebbb8eSjmmv "1", "2", "1 != 2: 1 does not match 2", false }, 624*edebbb8eSjmmv { H_REQUIRE_EQ_MSG_HEAD_NAME(2_1), H_REQUIRE_EQ_MSG_BODY_NAME(2_1), 625*edebbb8eSjmmv "2", "1", "2 != 1: 2 does not match 1", false }, 626*edebbb8eSjmmv { H_REQUIRE_EQ_MSG_HEAD_NAME(2_2), H_REQUIRE_EQ_MSG_BODY_NAME(2_2), 627*edebbb8eSjmmv "2", "2", "2 != 2: 2 does not match 2", true }, 628*edebbb8eSjmmv { NULL, NULL, 0, 0, "", false } 629*edebbb8eSjmmv }; 630*edebbb8eSjmmv do_require_eq_tests(tests); 631*edebbb8eSjmmv } 632*edebbb8eSjmmv 633*edebbb8eSjmmv H_REQUIRE_STREQ(1_1, "1", "1"); 634*edebbb8eSjmmv H_REQUIRE_STREQ(1_2, "1", "2"); 635*edebbb8eSjmmv H_REQUIRE_STREQ(2_1, "2", "1"); 636*edebbb8eSjmmv H_REQUIRE_STREQ(2_2, "2", "2"); 637*edebbb8eSjmmv H_REQUIRE_STREQ_MSG(1_1, "1", "1", "1 does not match 1"); 638*edebbb8eSjmmv H_REQUIRE_STREQ_MSG(1_2, "1", "2", "1 does not match 2"); 639*edebbb8eSjmmv H_REQUIRE_STREQ_MSG(2_1, "2", "1", "2 does not match 1"); 640*edebbb8eSjmmv H_REQUIRE_STREQ_MSG(2_2, "2", "2", "2 does not match 2"); 641*edebbb8eSjmmv #define REQUIRE_STREQ_VAR1 "5" 642*edebbb8eSjmmv #define REQUIRE_STREQ_VAR2 "9" 643*edebbb8eSjmmv const const char *require_streq_var1 = REQUIRE_STREQ_VAR1; 644*edebbb8eSjmmv const const char *require_streq_var2 = REQUIRE_STREQ_VAR2; 645*edebbb8eSjmmv H_REQUIRE_STREQ(vars, require_streq_var1, require_streq_var2); 646*edebbb8eSjmmv 647*edebbb8eSjmmv ATF_TC(require_streq); 648*edebbb8eSjmmv ATF_TC_HEAD(require_streq, tc) 649*edebbb8eSjmmv { 650*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests the ATF_REQUIRE_STREQ and " 651*edebbb8eSjmmv "ATF_REQUIRE_STREQ_MSG macros"); 652*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 653*edebbb8eSjmmv } 654*edebbb8eSjmmv ATF_TC_BODY(require_streq, tc) 655*edebbb8eSjmmv { 656*edebbb8eSjmmv struct require_eq_test tests[] = { 657*edebbb8eSjmmv { H_REQUIRE_STREQ_HEAD_NAME(1_1), H_REQUIRE_STREQ_BODY_NAME(1_1), 658*edebbb8eSjmmv "1", "1", "\"1\" != \"1\" \\(1 != 1\\)", true }, 659*edebbb8eSjmmv { H_REQUIRE_STREQ_HEAD_NAME(1_2), H_REQUIRE_STREQ_BODY_NAME(1_2), 660*edebbb8eSjmmv "1", "2", "\"1\" != \"2\" \\(1 != 2\\)", false }, 661*edebbb8eSjmmv { H_REQUIRE_STREQ_HEAD_NAME(2_1), H_REQUIRE_STREQ_BODY_NAME(2_1), 662*edebbb8eSjmmv "2", "1", "\"2\" != \"1\" \\(2 != 1\\)", false }, 663*edebbb8eSjmmv { H_REQUIRE_STREQ_HEAD_NAME(2_2), H_REQUIRE_STREQ_BODY_NAME(2_2), 664*edebbb8eSjmmv "2", "2", "\"2\" != \"2\" \\(2 != 2\\)", true }, 665*edebbb8eSjmmv { H_REQUIRE_STREQ_MSG_HEAD_NAME(1_1), 666*edebbb8eSjmmv H_REQUIRE_STREQ_MSG_BODY_NAME(1_1), 667*edebbb8eSjmmv "1", "1", "\"1\" != \"1\" \\(1 != 1\\): 1 does not match 1", true }, 668*edebbb8eSjmmv { H_REQUIRE_STREQ_MSG_HEAD_NAME(1_2), 669*edebbb8eSjmmv H_REQUIRE_STREQ_MSG_BODY_NAME(1_2), 670*edebbb8eSjmmv "1", "2", "\"1\" != \"2\" \\(1 != 2\\): 1 does not match 2", false }, 671*edebbb8eSjmmv { H_REQUIRE_STREQ_MSG_HEAD_NAME(2_1), 672*edebbb8eSjmmv H_REQUIRE_STREQ_MSG_BODY_NAME(2_1), 673*edebbb8eSjmmv "2", "1", "\"2\" != \"1\" \\(2 != 1\\): 2 does not match 1", false }, 674*edebbb8eSjmmv { H_REQUIRE_STREQ_MSG_HEAD_NAME(2_2), 675*edebbb8eSjmmv H_REQUIRE_STREQ_MSG_BODY_NAME(2_2), 676*edebbb8eSjmmv "2", "2", "\"2\" != \"2\" \\(2 != 2\\): 2 does not match 2", true }, 677*edebbb8eSjmmv { H_REQUIRE_STREQ_HEAD_NAME(vars), H_REQUIRE_STREQ_BODY_NAME(vars), 678*edebbb8eSjmmv require_streq_var1, require_streq_var2, 679*edebbb8eSjmmv "require_streq_var1 != require_streq_var2 \\(" 680*edebbb8eSjmmv REQUIRE_STREQ_VAR1 " != " REQUIRE_STREQ_VAR2 "\\)", false }, 681*edebbb8eSjmmv { NULL, NULL, 0, 0, "", false } 682*edebbb8eSjmmv }; 683*edebbb8eSjmmv do_require_eq_tests(tests); 684*edebbb8eSjmmv } 685*edebbb8eSjmmv 686*edebbb8eSjmmv /* --------------------------------------------------------------------- 687*edebbb8eSjmmv * Miscellaneous test cases covering several macros. 688*edebbb8eSjmmv * --------------------------------------------------------------------- */ 689*edebbb8eSjmmv 690*edebbb8eSjmmv static 691*edebbb8eSjmmv bool 692*edebbb8eSjmmv aux_bool(const char *fmt) 693*edebbb8eSjmmv { 694*edebbb8eSjmmv return false; 695*edebbb8eSjmmv } 696*edebbb8eSjmmv 697*edebbb8eSjmmv static 698*edebbb8eSjmmv const char * 699*edebbb8eSjmmv aux_str(const char *fmt) 700*edebbb8eSjmmv { 701*edebbb8eSjmmv return "foo"; 702*edebbb8eSjmmv } 703*edebbb8eSjmmv 704*edebbb8eSjmmv H_CHECK(msg, aux_bool("%d")); 705*edebbb8eSjmmv H_REQUIRE(msg, aux_bool("%d")); 706*edebbb8eSjmmv H_CHECK_STREQ(msg, aux_str("%d"), ""); 707*edebbb8eSjmmv H_REQUIRE_STREQ(msg, aux_str("%d"), ""); 708*edebbb8eSjmmv 709*edebbb8eSjmmv ATF_TC(msg_embedded_fmt); 710*edebbb8eSjmmv ATF_TC_HEAD(msg_embedded_fmt, tc) 711*edebbb8eSjmmv { 712*edebbb8eSjmmv atf_tc_set_md_var(tc, "descr", "Tests that format strings passed " 713*edebbb8eSjmmv "as part of the automatically-generated messages " 714*edebbb8eSjmmv "do not get expanded"); 715*edebbb8eSjmmv atf_tc_set_md_var(tc, "use.fs", "true"); 716*edebbb8eSjmmv } 717*edebbb8eSjmmv ATF_TC_BODY(msg_embedded_fmt, tc) 718*edebbb8eSjmmv { 719*edebbb8eSjmmv struct test { 720*edebbb8eSjmmv void (*head)(atf_tc_t *); 721*edebbb8eSjmmv void (*body)(const atf_tc_t *); 722*edebbb8eSjmmv bool fatal; 723*edebbb8eSjmmv const char *msg; 724*edebbb8eSjmmv } *t, tests[] = { 725*edebbb8eSjmmv { H_CHECK_HEAD_NAME(msg), H_CHECK_BODY_NAME(msg), false, 726*edebbb8eSjmmv "aux_bool\\(\"%d\"\\) not met" }, 727*edebbb8eSjmmv { H_REQUIRE_HEAD_NAME(msg), H_REQUIRE_BODY_NAME(msg), true, 728*edebbb8eSjmmv "aux_bool\\(\"%d\"\\) not met" }, 729*edebbb8eSjmmv { H_CHECK_STREQ_HEAD_NAME(msg), H_CHECK_STREQ_BODY_NAME(msg), false, 730*edebbb8eSjmmv "aux_str\\(\"%d\"\\) != \"\" \\(foo != \\)" }, 731*edebbb8eSjmmv { H_REQUIRE_STREQ_HEAD_NAME(msg), H_REQUIRE_STREQ_BODY_NAME(msg), true, 732*edebbb8eSjmmv "aux_str\\(\"%d\"\\) != \"\" \\(foo != \\)" }, 733*edebbb8eSjmmv { NULL, NULL, false, NULL } 734*edebbb8eSjmmv }; 735*edebbb8eSjmmv 736*edebbb8eSjmmv for (t = &tests[0]; t->head != NULL; t++) { 737*edebbb8eSjmmv printf("Checking with an expected '%s' message\n", t->msg); 738*edebbb8eSjmmv 739*edebbb8eSjmmv init_and_run_h_tc("h_check", t->head, t->body); 740*edebbb8eSjmmv 741*edebbb8eSjmmv if (t->fatal) { 742*edebbb8eSjmmv bool matched = 743*edebbb8eSjmmv grep_file("result", "^failed: .*macros_test.c:[0-9]+: " 744*edebbb8eSjmmv "%s$", t->msg); 745*edebbb8eSjmmv ATF_CHECK_MSG(matched, "couldn't find error string in result"); 746*edebbb8eSjmmv } else { 747*edebbb8eSjmmv bool matched = grep_file("error", "Check failed: .*" 748*edebbb8eSjmmv "macros_test.c:[0-9]+: %s$", t->msg); 749*edebbb8eSjmmv ATF_CHECK_MSG(matched, "couldn't find error string in output"); 750*edebbb8eSjmmv } 751*edebbb8eSjmmv } 752*edebbb8eSjmmv } 753*edebbb8eSjmmv 754*edebbb8eSjmmv /* --------------------------------------------------------------------- 755*edebbb8eSjmmv * Tests cases for the header file. 756*edebbb8eSjmmv * --------------------------------------------------------------------- */ 757*edebbb8eSjmmv 758*edebbb8eSjmmv HEADER_TC(include, "atf-c/macros.h"); 759*edebbb8eSjmmv BUILD_TC(use, "macros_h_test.c", 760*edebbb8eSjmmv "Tests that the macros provided by the atf-c/macros.h file " 761*edebbb8eSjmmv "do not cause syntax errors when used", 762*edebbb8eSjmmv "Build of macros_h_test.c failed; some macros in atf-c/macros.h " 763*edebbb8eSjmmv "are broken"); 764*edebbb8eSjmmv 765*edebbb8eSjmmv /* --------------------------------------------------------------------- 766*edebbb8eSjmmv * Main. 767*edebbb8eSjmmv * --------------------------------------------------------------------- */ 768*edebbb8eSjmmv 769*edebbb8eSjmmv ATF_TP_ADD_TCS(tp) 770*edebbb8eSjmmv { 771*edebbb8eSjmmv ATF_TP_ADD_TC(tp, check); 772*edebbb8eSjmmv ATF_TP_ADD_TC(tp, check_eq); 773*edebbb8eSjmmv ATF_TP_ADD_TC(tp, check_streq); 774*edebbb8eSjmmv ATF_TP_ADD_TC(tp, check_errno); 775*edebbb8eSjmmv 776*edebbb8eSjmmv ATF_TP_ADD_TC(tp, require); 777*edebbb8eSjmmv ATF_TP_ADD_TC(tp, require_eq); 778*edebbb8eSjmmv ATF_TP_ADD_TC(tp, require_streq); 779*edebbb8eSjmmv ATF_TP_ADD_TC(tp, require_errno); 780*edebbb8eSjmmv 781*edebbb8eSjmmv ATF_TP_ADD_TC(tp, msg_embedded_fmt); 782*edebbb8eSjmmv 783*edebbb8eSjmmv /* Add the test cases for the header file. */ 784*edebbb8eSjmmv ATF_TP_ADD_TC(tp, include); 785*edebbb8eSjmmv ATF_TP_ADD_TC(tp, use); 786*edebbb8eSjmmv 787*edebbb8eSjmmv return atf_no_error(); 788*edebbb8eSjmmv } 789