contrib/atf/atf-c/build_test.c

   1 /* Copyright (c) 2009 The NetBSD Foundation, Inc.
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  14  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  15  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  16  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  20  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  22  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  24  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  */
  25
  26 #include "atf-c/build.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <atf-c.h>
  33
  34 #include "atf-c/detail/env.h"
  35 #include "atf-c/detail/test_helpers.h"
  36 #include "atf-c/h_build.h"
  37 #include "atf-c/utils.h"
  38
  39 /* ---------------------------------------------------------------------
  40  * Auxiliary functions.
  41  * --------------------------------------------------------------------- */
  42
  43 static
  44 bool
  45 equal_arrays(const char *const *exp_array, char **actual_array)
  46 {
  47     bool equal;
  48
  49     if (*exp_array == NULL && *actual_array == NULL)
  50         equal = true;
  51     else if (*exp_array == NULL || *actual_array == NULL)
  52         equal = false;
  53     else {
  54         equal = true;
  55         while (*actual_array != NULL) {
  56             if (*exp_array == NULL || strcmp(*exp_array, *actual_array) != 0) {
  57                 equal = false;
  58                 break;
  59             }
  60             exp_array++;
  61             actual_array++;
  62         }
  63     }
  64
  65     return equal;
  66 }
  67
  68 static
  69 void
  70 check_equal_array(const char *const *exp_array, char **actual_array)
  71 {
  72     {
  73         const char *const *exp_ptr;
  74         printf("Expected arguments:");
  75         for (exp_ptr = exp_array; *exp_ptr != NULL; exp_ptr++)
  76             printf(" '%s'", *exp_ptr);
  77         printf("\n");
  78     }
  79
  80     {
  81         char **actual_ptr;
  82         printf("Returned arguments:");
  83         for (actual_ptr = actual_array; *actual_ptr != NULL; actual_ptr++)
  84             printf(" '%s'", *actual_ptr);
  85         printf("\n");
  86     }
  87
  88     if (!equal_arrays(exp_array, actual_array))
  89         atf_tc_fail_nonfatal("The constructed argv differs from the "
  90                              "expected values");
  91 }
  92
  93 static
  94 void
  95 verbose_set_env(const char *var, const char *val)
  96 {
  97     printf("Setting %s to '%s'\n", var, val);
  98     RE(atf_env_set(var, val));
  99 }
 100
 101 /* ---------------------------------------------------------------------
 102  * Internal test cases.
 103  * --------------------------------------------------------------------- */
 104
 105 ATF_TC(equal_arrays);
 106 ATF_TC_HEAD(equal_arrays, tc)
 107 {
 108     atf_tc_set_md_var(tc, "descr", "Tests the test case internal "
 109                       "equal_arrays function");
 110 }
 111 ATF_TC_BODY(equal_arrays, tc)
 112 {
 113     {
 114         const char *const exp[] = { NULL };
 115         char *actual[] = { NULL };
 116
 117         ATF_CHECK(equal_arrays(exp, actual));
 118     }
 119
 120     {
 121         const char *const exp[] = { NULL };
 122         char *actual[2] = { strdup("foo"), NULL };
 123
 124         ATF_CHECK(!equal_arrays(exp, actual));
 125         free(actual[0]);
 126     }
 127
 128     {
 129         const char *const exp[] = { "foo", NULL };
 130         char *actual[] = { NULL };
 131
 132         ATF_CHECK(!equal_arrays(exp, actual));
 133     }
 134
 135     {
 136         const char *const exp[] = { "foo", NULL };
 137         char *actual[2] = { strdup("foo"), NULL };
 138
 139         ATF_CHECK(equal_arrays(exp, actual));
 140         free(actual[0]);
 141     }
 142 }
 143
 144 /* ---------------------------------------------------------------------
 145  * Test cases for the free functions.
 146  * --------------------------------------------------------------------- */
 147
 148 ATF_TC(c_o);
 149 ATF_TC_HEAD(c_o, tc)
 150 {
 151     atf_tc_set_md_var(tc, "descr", "Tests the atf_build_c_o function");
 152 }
 153 ATF_TC_BODY(c_o, tc)
 154 {
 155     struct c_o_test *test;
 156
 157     for (test = c_o_tests; test->expargv[0] != NULL; test++) {
 158         printf("> Test: %s\n", test->msg);
 159
 160         verbose_set_env("ATF_BUILD_CC", test->cc);
 161         verbose_set_env("ATF_BUILD_CFLAGS", test->cflags);
 162         verbose_set_env("ATF_BUILD_CPPFLAGS", test->cppflags);
 163
 164         {
 165             char **argv;
 166             if (test->hasoptargs)
 167                 RE(atf_build_c_o(test->sfile, test->ofile, test->optargs,
 168                                  &argv));
 169             else
 170                 RE(atf_build_c_o(test->sfile, test->ofile, NULL, &argv));
 171             check_equal_array(test->expargv, argv);
 172             atf_utils_free_charpp(argv);
 173         }
 174     }
 175 }
 176
 177 ATF_TC(cpp);
 178 ATF_TC_HEAD(cpp, tc)
 179 {
 180     atf_tc_set_md_var(tc, "descr", "Tests the atf_build_cpp function");
 181 }
 182 ATF_TC_BODY(cpp, tc)
 183 {
 184     struct cpp_test *test;
 185
 186     for (test = cpp_tests; test->expargv[0] != NULL; test++) {
 187         printf("> Test: %s\n", test->msg);
 188
 189         verbose_set_env("ATF_BUILD_CPP", test->cpp);
 190         verbose_set_env("ATF_BUILD_CPPFLAGS", test->cppflags);
 191
 192         {
 193             char **argv;
 194             if (test->hasoptargs)
 195                 RE(atf_build_cpp(test->sfile, test->ofile, test->optargs,
 196                                  &argv));
 197             else
 198                 RE(atf_build_cpp(test->sfile, test->ofile, NULL, &argv));
 199             check_equal_array(test->expargv, argv);
 200             atf_utils_free_charpp(argv);
 201         }
 202     }
 203 }
 204
 205 ATF_TC(cxx_o);
 206 ATF_TC_HEAD(cxx_o, tc)
 207 {
 208     atf_tc_set_md_var(tc, "descr", "Tests the atf_build_cxx_o function");
 209 }
 210 ATF_TC_BODY(cxx_o, tc)
 211 {
 212     struct cxx_o_test *test;
 213
 214     for (test = cxx_o_tests; test->expargv[0] != NULL; test++) {
 215         printf("> Test: %s\n", test->msg);
 216
 217         verbose_set_env("ATF_BUILD_CXX", test->cxx);
 218         verbose_set_env("ATF_BUILD_CXXFLAGS", test->cxxflags);
 219         verbose_set_env("ATF_BUILD_CPPFLAGS", test->cppflags);
 220
 221         {
 222             char **argv;
 223             if (test->hasoptargs)
 224                 RE(atf_build_cxx_o(test->sfile, test->ofile, test->optargs,
 225                                    &argv));
 226             else
 227                 RE(atf_build_cxx_o(test->sfile, test->ofile, NULL, &argv));
 228             check_equal_array(test->expargv, argv);
 229             atf_utils_free_charpp(argv);
 230         }
 231     }
 232 }
 233
 234 /* ---------------------------------------------------------------------
 235  * Main.
 236  * --------------------------------------------------------------------- */
 237
 238 ATF_TP_ADD_TCS(tp)
 239 {
 240     /* Add the internal test cases. */
 241     ATF_TP_ADD_TC(tp, equal_arrays);
 242
 243     /* Add the test cases for the free functions. */
 244     ATF_TP_ADD_TC(tp, c_o);
 245     ATF_TP_ADD_TC(tp, cpp);
 246     ATF_TP_ADD_TC(tp, cxx_o);
 247
 248     return atf_no_error();
 249 }