1edebbb8eSjmmv //
2edebbb8eSjmmv // Automated Testing Framework (atf)
3edebbb8eSjmmv //
4a551a20fSjmmv // Copyright (c) 2007 The NetBSD Foundation, Inc.
5edebbb8eSjmmv // All rights reserved.
6edebbb8eSjmmv //
7edebbb8eSjmmv // Redistribution and use in source and binary forms, with or without
8edebbb8eSjmmv // modification, are permitted provided that the following conditions
9edebbb8eSjmmv // are met:
10edebbb8eSjmmv // 1. Redistributions of source code must retain the above copyright
11edebbb8eSjmmv // notice, this list of conditions and the following disclaimer.
12edebbb8eSjmmv // 2. Redistributions in binary form must reproduce the above copyright
13edebbb8eSjmmv // notice, this list of conditions and the following disclaimer in the
14edebbb8eSjmmv // documentation and/or other materials provided with the distribution.
15edebbb8eSjmmv //
16edebbb8eSjmmv // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17edebbb8eSjmmv // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18edebbb8eSjmmv // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19edebbb8eSjmmv // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20edebbb8eSjmmv // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21edebbb8eSjmmv // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22edebbb8eSjmmv // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23edebbb8eSjmmv // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24edebbb8eSjmmv // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25edebbb8eSjmmv // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26edebbb8eSjmmv // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27edebbb8eSjmmv // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28edebbb8eSjmmv //
29edebbb8eSjmmv
30edebbb8eSjmmv extern "C" {
31edebbb8eSjmmv #include <fcntl.h>
32edebbb8eSjmmv #include <signal.h>
33edebbb8eSjmmv #include <unistd.h>
34edebbb8eSjmmv }
35edebbb8eSjmmv
36edebbb8eSjmmv #include <cstdlib>
37edebbb8eSjmmv #include <cstring>
38edebbb8eSjmmv #include <fstream>
39edebbb8eSjmmv #include <iostream>
40edebbb8eSjmmv #include <list>
41edebbb8eSjmmv #include <memory>
42edebbb8eSjmmv #include <vector>
43edebbb8eSjmmv
44edebbb8eSjmmv #include <atf-c++.hpp>
45edebbb8eSjmmv
46895f502bSjmmv #include "check.hpp"
47895f502bSjmmv #include "config.hpp"
48895f502bSjmmv #include "utils.hpp"
49edebbb8eSjmmv
50895f502bSjmmv #include "detail/fs.hpp"
51895f502bSjmmv #include "detail/process.hpp"
52895f502bSjmmv #include "detail/test_helpers.hpp"
53895f502bSjmmv #include "detail/text.hpp"
54edebbb8eSjmmv
55edebbb8eSjmmv // ------------------------------------------------------------------------
56edebbb8eSjmmv // Auxiliary functions.
57edebbb8eSjmmv // ------------------------------------------------------------------------
58edebbb8eSjmmv
59edebbb8eSjmmv static
60*ee43138cSchristos std::unique_ptr< atf::check::check_result >
do_exec(const atf::tests::tc * tc,const char * helper_name)61edebbb8eSjmmv do_exec(const atf::tests::tc* tc, const char* helper_name)
62edebbb8eSjmmv {
63edebbb8eSjmmv std::vector< std::string > argv;
64d780102eSjmmv argv.push_back(get_process_helpers_path(*tc, false).str());
65edebbb8eSjmmv argv.push_back(helper_name);
66edebbb8eSjmmv std::cout << "Executing " << argv[0] << " " << argv[1] << "\n";
67edebbb8eSjmmv
68edebbb8eSjmmv atf::process::argv_array argva(argv);
69edebbb8eSjmmv return atf::check::exec(argva);
70edebbb8eSjmmv }
71edebbb8eSjmmv
72edebbb8eSjmmv static
73*ee43138cSchristos std::unique_ptr< atf::check::check_result >
do_exec(const atf::tests::tc * tc,const char * helper_name,const char * carg2)74edebbb8eSjmmv do_exec(const atf::tests::tc* tc, const char* helper_name, const char *carg2)
75edebbb8eSjmmv {
76edebbb8eSjmmv std::vector< std::string > argv;
77d780102eSjmmv argv.push_back(get_process_helpers_path(*tc, false).str());
78edebbb8eSjmmv argv.push_back(helper_name);
79edebbb8eSjmmv argv.push_back(carg2);
80edebbb8eSjmmv std::cout << "Executing " << argv[0] << " " << argv[1] << " "
81edebbb8eSjmmv << argv[2] << "\n";
82edebbb8eSjmmv
83edebbb8eSjmmv atf::process::argv_array argva(argv);
84edebbb8eSjmmv return atf::check::exec(argva);
85edebbb8eSjmmv }
86edebbb8eSjmmv
87edebbb8eSjmmv // ------------------------------------------------------------------------
88edebbb8eSjmmv // Helper test cases for the free functions.
89edebbb8eSjmmv // ------------------------------------------------------------------------
90edebbb8eSjmmv
91edebbb8eSjmmv ATF_TEST_CASE(h_build_c_o_ok);
ATF_TEST_CASE_HEAD(h_build_c_o_ok)92edebbb8eSjmmv ATF_TEST_CASE_HEAD(h_build_c_o_ok)
93edebbb8eSjmmv {
94edebbb8eSjmmv set_md_var("descr", "Helper test case for build_c_o");
95edebbb8eSjmmv }
ATF_TEST_CASE_BODY(h_build_c_o_ok)96edebbb8eSjmmv ATF_TEST_CASE_BODY(h_build_c_o_ok)
97edebbb8eSjmmv {
98edebbb8eSjmmv std::ofstream sfile("test.c");
99edebbb8eSjmmv sfile << "#include <stdio.h>\n";
100edebbb8eSjmmv sfile.close();
101edebbb8eSjmmv
102895f502bSjmmv ATF_REQUIRE(atf::check::build_c_o("test.c", "test.o",
103edebbb8eSjmmv atf::process::argv_array()));
104edebbb8eSjmmv }
105edebbb8eSjmmv
106edebbb8eSjmmv ATF_TEST_CASE(h_build_c_o_fail);
ATF_TEST_CASE_HEAD(h_build_c_o_fail)107edebbb8eSjmmv ATF_TEST_CASE_HEAD(h_build_c_o_fail)
108edebbb8eSjmmv {
109edebbb8eSjmmv set_md_var("descr", "Helper test case for build_c_o");
110edebbb8eSjmmv }
ATF_TEST_CASE_BODY(h_build_c_o_fail)111edebbb8eSjmmv ATF_TEST_CASE_BODY(h_build_c_o_fail)
112edebbb8eSjmmv {
113edebbb8eSjmmv std::ofstream sfile("test.c");
114edebbb8eSjmmv sfile << "void foo(void) { int a = UNDEFINED_SYMBOL; }\n";
115edebbb8eSjmmv sfile.close();
116edebbb8eSjmmv
117895f502bSjmmv ATF_REQUIRE(!atf::check::build_c_o("test.c", "test.o",
118edebbb8eSjmmv atf::process::argv_array()));
119edebbb8eSjmmv }
120edebbb8eSjmmv
121edebbb8eSjmmv ATF_TEST_CASE(h_build_cpp_ok);
ATF_TEST_CASE_HEAD(h_build_cpp_ok)122edebbb8eSjmmv ATF_TEST_CASE_HEAD(h_build_cpp_ok)
123edebbb8eSjmmv {
124edebbb8eSjmmv set_md_var("descr", "Helper test case for build_cpp");
125edebbb8eSjmmv }
ATF_TEST_CASE_BODY(h_build_cpp_ok)126edebbb8eSjmmv ATF_TEST_CASE_BODY(h_build_cpp_ok)
127edebbb8eSjmmv {
128edebbb8eSjmmv std::ofstream sfile("test.c");
129edebbb8eSjmmv sfile << "#define A foo\n";
130edebbb8eSjmmv sfile << "#define B bar\n";
131edebbb8eSjmmv sfile << "A B\n";
132edebbb8eSjmmv sfile.close();
133edebbb8eSjmmv
134895f502bSjmmv ATF_REQUIRE(atf::check::build_cpp("test.c", "test.p",
135edebbb8eSjmmv atf::process::argv_array()));
136edebbb8eSjmmv }
137edebbb8eSjmmv
138edebbb8eSjmmv ATF_TEST_CASE(h_build_cpp_fail);
ATF_TEST_CASE_HEAD(h_build_cpp_fail)139edebbb8eSjmmv ATF_TEST_CASE_HEAD(h_build_cpp_fail)
140edebbb8eSjmmv {
141edebbb8eSjmmv set_md_var("descr", "Helper test case for build_cpp");
142edebbb8eSjmmv }
ATF_TEST_CASE_BODY(h_build_cpp_fail)143edebbb8eSjmmv ATF_TEST_CASE_BODY(h_build_cpp_fail)
144edebbb8eSjmmv {
145edebbb8eSjmmv std::ofstream sfile("test.c");
146edebbb8eSjmmv sfile << "#include \"./non-existent.h\"\n";
147edebbb8eSjmmv sfile.close();
148edebbb8eSjmmv
149895f502bSjmmv ATF_REQUIRE(!atf::check::build_cpp("test.c", "test.p",
150edebbb8eSjmmv atf::process::argv_array()));
151edebbb8eSjmmv }
152edebbb8eSjmmv
153edebbb8eSjmmv ATF_TEST_CASE(h_build_cxx_o_ok);
ATF_TEST_CASE_HEAD(h_build_cxx_o_ok)154edebbb8eSjmmv ATF_TEST_CASE_HEAD(h_build_cxx_o_ok)
155edebbb8eSjmmv {
156edebbb8eSjmmv set_md_var("descr", "Helper test case for build_cxx_o");
157edebbb8eSjmmv }
ATF_TEST_CASE_BODY(h_build_cxx_o_ok)158edebbb8eSjmmv ATF_TEST_CASE_BODY(h_build_cxx_o_ok)
159edebbb8eSjmmv {
160edebbb8eSjmmv std::ofstream sfile("test.cpp");
161edebbb8eSjmmv sfile << "#include <iostream>\n";
162edebbb8eSjmmv sfile.close();
163edebbb8eSjmmv
164895f502bSjmmv ATF_REQUIRE(atf::check::build_cxx_o("test.cpp", "test.o",
165edebbb8eSjmmv atf::process::argv_array()));
166edebbb8eSjmmv }
167edebbb8eSjmmv
168edebbb8eSjmmv ATF_TEST_CASE(h_build_cxx_o_fail);
ATF_TEST_CASE_HEAD(h_build_cxx_o_fail)169edebbb8eSjmmv ATF_TEST_CASE_HEAD(h_build_cxx_o_fail)
170edebbb8eSjmmv {
171edebbb8eSjmmv set_md_var("descr", "Helper test case for build_cxx_o");
172edebbb8eSjmmv }
ATF_TEST_CASE_BODY(h_build_cxx_o_fail)173edebbb8eSjmmv ATF_TEST_CASE_BODY(h_build_cxx_o_fail)
174edebbb8eSjmmv {
175edebbb8eSjmmv std::ofstream sfile("test.cpp");
176edebbb8eSjmmv sfile << "void foo(void) { int a = UNDEFINED_SYMBOL; }\n";
177edebbb8eSjmmv sfile.close();
178edebbb8eSjmmv
179895f502bSjmmv ATF_REQUIRE(!atf::check::build_cxx_o("test.cpp", "test.o",
180edebbb8eSjmmv atf::process::argv_array()));
181edebbb8eSjmmv }
182edebbb8eSjmmv
183edebbb8eSjmmv // ------------------------------------------------------------------------
184edebbb8eSjmmv // Test cases for the free functions.
185edebbb8eSjmmv // ------------------------------------------------------------------------
186edebbb8eSjmmv
187edebbb8eSjmmv ATF_TEST_CASE(build_c_o);
ATF_TEST_CASE_HEAD(build_c_o)188edebbb8eSjmmv ATF_TEST_CASE_HEAD(build_c_o)
189edebbb8eSjmmv {
190edebbb8eSjmmv set_md_var("descr", "Tests the build_c_o function");
191edebbb8eSjmmv }
ATF_TEST_CASE_BODY(build_c_o)192edebbb8eSjmmv ATF_TEST_CASE_BODY(build_c_o)
193edebbb8eSjmmv {
1944e036686Sjmmv ATF_TEST_CASE_USE(h_build_c_o_ok);
195edebbb8eSjmmv run_h_tc< ATF_TEST_CASE_NAME(h_build_c_o_ok) >();
1960659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-o test.o", "stdout"));
1970659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-c test.c", "stdout"));
198edebbb8eSjmmv
1994e036686Sjmmv ATF_TEST_CASE_USE(h_build_c_o_fail);
200edebbb8eSjmmv run_h_tc< ATF_TEST_CASE_NAME(h_build_c_o_fail) >();
2010659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-o test.o", "stdout"));
2020659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-c test.c", "stdout"));
2030659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("test.c", "stderr"));
2040659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("UNDEFINED_SYMBOL", "stderr"));
205edebbb8eSjmmv }
206edebbb8eSjmmv
207edebbb8eSjmmv ATF_TEST_CASE(build_cpp);
ATF_TEST_CASE_HEAD(build_cpp)208edebbb8eSjmmv ATF_TEST_CASE_HEAD(build_cpp)
209edebbb8eSjmmv {
210edebbb8eSjmmv set_md_var("descr", "Tests the build_cpp function");
211edebbb8eSjmmv }
ATF_TEST_CASE_BODY(build_cpp)212edebbb8eSjmmv ATF_TEST_CASE_BODY(build_cpp)
213edebbb8eSjmmv {
2144e036686Sjmmv ATF_TEST_CASE_USE(h_build_cpp_ok);
215edebbb8eSjmmv run_h_tc< ATF_TEST_CASE_NAME(h_build_cpp_ok) >();
2160659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-o.*test.p", "stdout"));
2170659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("test.c", "stdout"));
2180659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("foo bar", "test.p"));
219edebbb8eSjmmv
2204e036686Sjmmv ATF_TEST_CASE_USE(h_build_cpp_fail);
221edebbb8eSjmmv run_h_tc< ATF_TEST_CASE_NAME(h_build_cpp_fail) >();
2220659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-o test.p", "stdout"));
2230659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("test.c", "stdout"));
2240659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("test.c", "stderr"));
2250659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("non-existent.h", "stderr"));
226edebbb8eSjmmv }
227edebbb8eSjmmv
228edebbb8eSjmmv ATF_TEST_CASE(build_cxx_o);
ATF_TEST_CASE_HEAD(build_cxx_o)229edebbb8eSjmmv ATF_TEST_CASE_HEAD(build_cxx_o)
230edebbb8eSjmmv {
231edebbb8eSjmmv set_md_var("descr", "Tests the build_cxx_o function");
232edebbb8eSjmmv }
ATF_TEST_CASE_BODY(build_cxx_o)233edebbb8eSjmmv ATF_TEST_CASE_BODY(build_cxx_o)
234edebbb8eSjmmv {
2354e036686Sjmmv ATF_TEST_CASE_USE(h_build_cxx_o_ok);
236edebbb8eSjmmv run_h_tc< ATF_TEST_CASE_NAME(h_build_cxx_o_ok) >();
2370659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-o test.o", "stdout"));
2380659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-c test.cpp", "stdout"));
239edebbb8eSjmmv
2404e036686Sjmmv ATF_TEST_CASE_USE(h_build_cxx_o_fail);
241edebbb8eSjmmv run_h_tc< ATF_TEST_CASE_NAME(h_build_cxx_o_fail) >();
2420659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-o test.o", "stdout"));
2430659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("-c test.cpp", "stdout"));
2440659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("test.cpp", "stderr"));
2450659fc67Sjmmv ATF_REQUIRE(atf::utils::grep_file("UNDEFINED_SYMBOL", "stderr"));
246edebbb8eSjmmv }
247edebbb8eSjmmv
248edebbb8eSjmmv ATF_TEST_CASE(exec_cleanup);
ATF_TEST_CASE_HEAD(exec_cleanup)249edebbb8eSjmmv ATF_TEST_CASE_HEAD(exec_cleanup)
250edebbb8eSjmmv {
251edebbb8eSjmmv set_md_var("descr", "Tests that exec properly cleans up the temporary "
252edebbb8eSjmmv "files it creates");
253edebbb8eSjmmv }
ATF_TEST_CASE_BODY(exec_cleanup)254edebbb8eSjmmv ATF_TEST_CASE_BODY(exec_cleanup)
255edebbb8eSjmmv {
256*ee43138cSchristos std::unique_ptr< atf::fs::path > out;
257*ee43138cSchristos std::unique_ptr< atf::fs::path > err;
258edebbb8eSjmmv
259edebbb8eSjmmv {
260*ee43138cSchristos std::unique_ptr< atf::check::check_result > r =
2610ebb519dSjmmv do_exec(this, "exit-success");
2620ebb519dSjmmv out.reset(new atf::fs::path(r->stdout_path()));
2630ebb519dSjmmv err.reset(new atf::fs::path(r->stderr_path()));
264895f502bSjmmv ATF_REQUIRE(atf::fs::exists(*out.get()));
265895f502bSjmmv ATF_REQUIRE(atf::fs::exists(*err.get()));
266edebbb8eSjmmv }
267895f502bSjmmv ATF_REQUIRE(!atf::fs::exists(*out.get()));
268895f502bSjmmv ATF_REQUIRE(!atf::fs::exists(*err.get()));
269edebbb8eSjmmv }
270edebbb8eSjmmv
271edebbb8eSjmmv ATF_TEST_CASE(exec_exitstatus);
ATF_TEST_CASE_HEAD(exec_exitstatus)272edebbb8eSjmmv ATF_TEST_CASE_HEAD(exec_exitstatus)
273edebbb8eSjmmv {
274edebbb8eSjmmv set_md_var("descr", "Tests that exec properly captures the exit "
275edebbb8eSjmmv "status of the executed command");
276edebbb8eSjmmv }
ATF_TEST_CASE_BODY(exec_exitstatus)277edebbb8eSjmmv ATF_TEST_CASE_BODY(exec_exitstatus)
278edebbb8eSjmmv {
279edebbb8eSjmmv {
280*ee43138cSchristos std::unique_ptr< atf::check::check_result > r =
2810ebb519dSjmmv do_exec(this, "exit-success");
2820ebb519dSjmmv ATF_REQUIRE(r->exited());
2830ebb519dSjmmv ATF_REQUIRE(!r->signaled());
2840ebb519dSjmmv ATF_REQUIRE_EQ(r->exitcode(), EXIT_SUCCESS);
285edebbb8eSjmmv }
286edebbb8eSjmmv
287edebbb8eSjmmv {
288*ee43138cSchristos std::unique_ptr< atf::check::check_result > r =
2890ebb519dSjmmv do_exec(this, "exit-failure");
2900ebb519dSjmmv ATF_REQUIRE(r->exited());
2910ebb519dSjmmv ATF_REQUIRE(!r->signaled());
2920ebb519dSjmmv ATF_REQUIRE_EQ(r->exitcode(), EXIT_FAILURE);
293edebbb8eSjmmv }
294edebbb8eSjmmv
295edebbb8eSjmmv {
296*ee43138cSchristos std::unique_ptr< atf::check::check_result > r =
2970ebb519dSjmmv do_exec(this, "exit-signal");
2980ebb519dSjmmv ATF_REQUIRE(!r->exited());
2990ebb519dSjmmv ATF_REQUIRE(r->signaled());
3000ebb519dSjmmv ATF_REQUIRE_EQ(r->termsig(), SIGKILL);
301edebbb8eSjmmv }
302edebbb8eSjmmv }
303edebbb8eSjmmv
304edebbb8eSjmmv static
305edebbb8eSjmmv void
check_lines(const std::string & path,const char * outname,const char * resname)306895f502bSjmmv check_lines(const std::string& path, const char* outname,
307edebbb8eSjmmv const char* resname)
308edebbb8eSjmmv {
309edebbb8eSjmmv std::ifstream f(path.c_str());
310895f502bSjmmv ATF_REQUIRE(f);
311edebbb8eSjmmv
312edebbb8eSjmmv std::string line;
313edebbb8eSjmmv std::getline(f, line);
314895f502bSjmmv ATF_REQUIRE_EQ(line, std::string("Line 1 to ") + outname + " for " +
315edebbb8eSjmmv resname);
316edebbb8eSjmmv std::getline(f, line);
317895f502bSjmmv ATF_REQUIRE_EQ(line, std::string("Line 2 to ") + outname + " for " +
318edebbb8eSjmmv resname);
319edebbb8eSjmmv }
320edebbb8eSjmmv
321edebbb8eSjmmv ATF_TEST_CASE(exec_stdout_stderr);
ATF_TEST_CASE_HEAD(exec_stdout_stderr)322edebbb8eSjmmv ATF_TEST_CASE_HEAD(exec_stdout_stderr)
323edebbb8eSjmmv {
324edebbb8eSjmmv set_md_var("descr", "Tests that exec properly captures the stdout "
325edebbb8eSjmmv "and stderr streams of the child process");
326edebbb8eSjmmv }
ATF_TEST_CASE_BODY(exec_stdout_stderr)327edebbb8eSjmmv ATF_TEST_CASE_BODY(exec_stdout_stderr)
328edebbb8eSjmmv {
329*ee43138cSchristos std::unique_ptr< atf::check::check_result > r1 =
3300ebb519dSjmmv do_exec(this, "stdout-stderr", "result1");
3310ebb519dSjmmv ATF_REQUIRE(r1->exited());
3320ebb519dSjmmv ATF_REQUIRE_EQ(r1->exitcode(), EXIT_SUCCESS);
333edebbb8eSjmmv
334*ee43138cSchristos std::unique_ptr< atf::check::check_result > r2 =
3350ebb519dSjmmv do_exec(this, "stdout-stderr", "result2");
3360ebb519dSjmmv ATF_REQUIRE(r2->exited());
3370ebb519dSjmmv ATF_REQUIRE_EQ(r2->exitcode(), EXIT_SUCCESS);
338edebbb8eSjmmv
3390ebb519dSjmmv const std::string out1 = r1->stdout_path();
3400ebb519dSjmmv const std::string out2 = r2->stdout_path();
3410ebb519dSjmmv const std::string err1 = r1->stderr_path();
3420ebb519dSjmmv const std::string err2 = r2->stderr_path();
343edebbb8eSjmmv
344895f502bSjmmv ATF_REQUIRE(out1.find("check.XXXXXX") == std::string::npos);
345895f502bSjmmv ATF_REQUIRE(out2.find("check.XXXXXX") == std::string::npos);
346895f502bSjmmv ATF_REQUIRE(err1.find("check.XXXXXX") == std::string::npos);
347895f502bSjmmv ATF_REQUIRE(err2.find("check.XXXXXX") == std::string::npos);
348edebbb8eSjmmv
349895f502bSjmmv ATF_REQUIRE(out1.find("/check") != std::string::npos);
350895f502bSjmmv ATF_REQUIRE(out2.find("/check") != std::string::npos);
351895f502bSjmmv ATF_REQUIRE(err1.find("/check") != std::string::npos);
352895f502bSjmmv ATF_REQUIRE(err2.find("/check") != std::string::npos);
353edebbb8eSjmmv
354895f502bSjmmv ATF_REQUIRE(out1.find("/stdout") != std::string::npos);
355895f502bSjmmv ATF_REQUIRE(out2.find("/stdout") != std::string::npos);
356895f502bSjmmv ATF_REQUIRE(err1.find("/stderr") != std::string::npos);
357895f502bSjmmv ATF_REQUIRE(err2.find("/stderr") != std::string::npos);
358edebbb8eSjmmv
359895f502bSjmmv ATF_REQUIRE(out1 != out2);
360895f502bSjmmv ATF_REQUIRE(err1 != err2);
361edebbb8eSjmmv
362edebbb8eSjmmv check_lines(out1, "stdout", "result1");
363edebbb8eSjmmv check_lines(out2, "stdout", "result2");
364edebbb8eSjmmv check_lines(err1, "stderr", "result1");
365edebbb8eSjmmv check_lines(err2, "stderr", "result2");
366edebbb8eSjmmv }
367edebbb8eSjmmv
368edebbb8eSjmmv ATF_TEST_CASE(exec_unknown);
ATF_TEST_CASE_HEAD(exec_unknown)369edebbb8eSjmmv ATF_TEST_CASE_HEAD(exec_unknown)
370edebbb8eSjmmv {
371edebbb8eSjmmv set_md_var("descr", "Tests that running a non-existing binary "
372edebbb8eSjmmv "is handled correctly");
373edebbb8eSjmmv }
ATF_TEST_CASE_BODY(exec_unknown)374edebbb8eSjmmv ATF_TEST_CASE_BODY(exec_unknown)
375edebbb8eSjmmv {
376edebbb8eSjmmv std::vector< std::string > argv;
377edebbb8eSjmmv argv.push_back(atf::config::get("atf_workdir") + "/non-existent");
378edebbb8eSjmmv
379edebbb8eSjmmv atf::process::argv_array argva(argv);
380*ee43138cSchristos std::unique_ptr< atf::check::check_result > r = atf::check::exec(argva);
3810ebb519dSjmmv ATF_REQUIRE(r->exited());
3820ebb519dSjmmv ATF_REQUIRE_EQ(r->exitcode(), 127);
383edebbb8eSjmmv }
384edebbb8eSjmmv
385edebbb8eSjmmv // ------------------------------------------------------------------------
386edebbb8eSjmmv // Tests cases for the header file.
387edebbb8eSjmmv // ------------------------------------------------------------------------
388edebbb8eSjmmv
389edebbb8eSjmmv HEADER_TC(include, "atf-c++/check.hpp");
390edebbb8eSjmmv
391edebbb8eSjmmv // ------------------------------------------------------------------------
392edebbb8eSjmmv // Main.
393edebbb8eSjmmv // ------------------------------------------------------------------------
394edebbb8eSjmmv
ATF_INIT_TEST_CASES(tcs)395edebbb8eSjmmv ATF_INIT_TEST_CASES(tcs)
396edebbb8eSjmmv {
397edebbb8eSjmmv // Add the test cases for the free functions.
398edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, build_c_o);
399edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, build_cpp);
400edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, build_cxx_o);
401edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, exec_cleanup);
402edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, exec_exitstatus);
403edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, exec_stdout_stderr);
404edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, exec_unknown);
405edebbb8eSjmmv
406edebbb8eSjmmv // Add the test cases for the header file.
407edebbb8eSjmmv ATF_ADD_TEST_CASE(tcs, include);
408edebbb8eSjmmv }
409