1 //
2 // Automated Testing Framework (atf)
3 //
4 // Copyright (c) 2007 The NetBSD Foundation, Inc.
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
9 // are met:
10 // 1. Redistributions of source code must retain the above copyright
11 //    notice, this list of conditions and the following disclaimer.
12 // 2. Redistributions in binary form must reproduce the above copyright
13 //    notice, this list of conditions and the following disclaimer in the
14 //    documentation and/or other materials provided with the distribution.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 //
29 
30 #include <cstring>
31 
32 extern "C" {
33 #include "atf-c/build.h"
34 #include "atf-c/error.h"
35 }
36 
37 #include "check.hpp"
38 
39 #include "detail/exceptions.hpp"
40 #include "detail/process.hpp"
41 #include "detail/sanity.hpp"
42 
43 namespace impl = atf::check;
44 #define IMPL_NAME "atf::check"
45 
46 // ------------------------------------------------------------------------
47 // The "check_result" class.
48 // ------------------------------------------------------------------------
49 
50 impl::check_result::check_result(const atf_check_result_t* result)
51 {
52     std::memcpy(&m_result, result, sizeof(m_result));
53 }
54 
55 impl::check_result::~check_result(void)
56 {
57     atf_check_result_fini(&m_result);
58 }
59 
60 bool
61 impl::check_result::exited(void)
62     const
63 {
64     return atf_check_result_exited(&m_result);
65 }
66 
67 int
68 impl::check_result::exitcode(void)
69     const
70 {
71     PRE(exited());
72     return atf_check_result_exitcode(&m_result);
73 }
74 
75 bool
76 impl::check_result::signaled(void)
77     const
78 {
79     return atf_check_result_signaled(&m_result);
80 }
81 
82 int
83 impl::check_result::termsig(void)
84     const
85 {
86     PRE(signaled());
87     return atf_check_result_termsig(&m_result);
88 }
89 
90 const std::string
91 impl::check_result::stdout_path(void) const
92 {
93     return atf_check_result_stdout(&m_result);
94 }
95 
96 const std::string
97 impl::check_result::stderr_path(void) const
98 {
99     return atf_check_result_stderr(&m_result);
100 }
101 
102 // ------------------------------------------------------------------------
103 // Free functions.
104 // ------------------------------------------------------------------------
105 
106 bool
107 impl::build_c_o(const std::string& sfile, const std::string& ofile,
108                 const atf::process::argv_array& optargs)
109 {
110     bool success;
111 
112     atf_error_t err = atf_check_build_c_o(sfile.c_str(), ofile.c_str(),
113                                           optargs.exec_argv(), &success);
114     if (atf_is_error(err))
115         throw_atf_error(err);
116 
117     return success;
118 }
119 
120 bool
121 impl::build_cpp(const std::string& sfile, const std::string& ofile,
122                 const atf::process::argv_array& optargs)
123 {
124     bool success;
125 
126     atf_error_t err = atf_check_build_cpp(sfile.c_str(), ofile.c_str(),
127                                           optargs.exec_argv(), &success);
128     if (atf_is_error(err))
129         throw_atf_error(err);
130 
131     return success;
132 }
133 
134 bool
135 impl::build_cxx_o(const std::string& sfile, const std::string& ofile,
136                   const atf::process::argv_array& optargs)
137 {
138     bool success;
139 
140     atf_error_t err = atf_check_build_cxx_o(sfile.c_str(), ofile.c_str(),
141                                             optargs.exec_argv(), &success);
142     if (atf_is_error(err))
143         throw_atf_error(err);
144 
145     return success;
146 }
147 
148 std::auto_ptr< impl::check_result >
149 impl::exec(const atf::process::argv_array& argva)
150 {
151     atf_check_result_t result;
152 
153     atf_error_t err = atf_check_exec_array(argva.exec_argv(), &result);
154     if (atf_is_error(err))
155         throw_atf_error(err);
156 
157     return std::auto_ptr< impl::check_result >(new impl::check_result(&result));
158 }
159