build_test.c revision 275988 
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
43static
44bool
45equal_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
68static
69void
70check_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
93static
94void
95verbose_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
105ATF_TC(equal_arrays);
106ATF_TC_HEAD(equal_arrays, tc)
107{
108    atf_tc_set_md_var(tc, "descr", "Tests the test case internal "
109                      "equal_arrays function");
110}
111ATF_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
148ATF_TC(c_o);
149ATF_TC_HEAD(c_o, tc)
150{
151    atf_tc_set_md_var(tc, "descr", "Tests the atf_build_c_o function");
152}
153ATF_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
177ATF_TC(cpp);
178ATF_TC_HEAD(cpp, tc)
179{
180    atf_tc_set_md_var(tc, "descr", "Tests the atf_build_cpp function");
181}
182ATF_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
205ATF_TC(cxx_o);
206ATF_TC_HEAD(cxx_o, tc)
207{
208    atf_tc_set_md_var(tc, "descr", "Tests the atf_build_cxx_o function");
209}
210ATF_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
238ATF_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}
250