1/*
2 * Automated Testing Framework (atf)
3 *
4 * Copyright (c) 2009 The NetBSD Foundation, Inc.
|
| 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
|
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
|
| 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
|
36#include "atf-c/build.h"
37#include "atf-c/config.h"
|
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
|
40#include "detail/env.h"
41#include "detail/test_helpers.h"
42#include "h_build.h"
43
|
39/* ---------------------------------------------------------------------
40 * Auxiliary functions.
41 * --------------------------------------------------------------------- */
42
|
48void __atf_config_reinit(void);
49
|
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);
|
170 __atf_config_reinit();
|
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);
|
199 __atf_config_reinit();
|
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);
|
229 __atf_config_reinit();
|
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/* ---------------------------------------------------------------------
|
245 * Tests cases for the header file.
246 * --------------------------------------------------------------------- */
247
248HEADER_TC(include, "atf-c/build.h");
249
250/* ---------------------------------------------------------------------
|
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
|
264 /* Add the test cases for the header file. */
265 ATF_TP_ADD_TC(tp, include);
266
|
248 return atf_no_error();
249}
|