1 // Copyright 2010 The Kyua Authors.
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 are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of Google Inc. nor the names of its contributors
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29 #include "utils/sanity.hpp"
30
31 extern "C" {
32 #include <signal.h>
33 #include <unistd.h>
34 }
35
36 #include <cstdlib>
37 #include <iostream>
38
39 #include <atf-c++.hpp>
40
41 #include "utils/format/macros.hpp"
42 #include "utils/fs/path.hpp"
43 #include "utils/process/child.ipp"
44 #include "utils/process/status.hpp"
45 #include "utils/test_utils.ipp"
46
47 namespace fs = utils::fs;
48 namespace process = utils::process;
49
50
51 #define FILE_REGEXP __FILE__ ":[0-9]+: "
52
53
54 static const fs::path Stdout_File("stdout.txt");
55 static const fs::path Stderr_File("stderr.txt");
56
57
58 #if NDEBUG
59 static bool NDebug = true;
60 #else
61 static bool NDebug = false;
62 #endif
63
64
65 template< typename Function >
66 static process::status
run_test(Function function)67 run_test(Function function)
68 {
69 utils::avoid_coredump_on_crash();
70
71 const process::status status = process::child::fork_files(
72 function, Stdout_File, Stderr_File)->wait();
73 atf::utils::cat_file(Stdout_File.str(), "Helper stdout: ");
74 atf::utils::cat_file(Stderr_File.str(), "Helper stderr: ");
75 return status;
76 }
77
78
79 static void
verify_success(const process::status & status)80 verify_success(const process::status& status)
81 {
82 ATF_REQUIRE(status.exited());
83 ATF_REQUIRE_EQ(EXIT_SUCCESS, status.exitstatus());
84 ATF_REQUIRE(atf::utils::grep_file("Before test", Stdout_File.str()));
85 ATF_REQUIRE(atf::utils::grep_file("After test", Stdout_File.str()));
86 }
87
88
89 static void
verify_failed(const process::status & status,const char * type,const char * exp_message,const bool check_ndebug)90 verify_failed(const process::status& status, const char* type,
91 const char* exp_message, const bool check_ndebug)
92 {
93 if (check_ndebug && NDebug) {
94 std::cout << "Built with NDEBUG; skipping verification\n";
95 verify_success(status);
96 } else {
97 ATF_REQUIRE(status.signaled());
98 ATF_REQUIRE_EQ(SIGABRT, status.termsig());
99 ATF_REQUIRE(atf::utils::grep_file("Before test", Stdout_File.str()));
100 ATF_REQUIRE(!atf::utils::grep_file("After test", Stdout_File.str()));
101 if (exp_message != NULL)
102 ATF_REQUIRE(atf::utils::grep_file(F(FILE_REGEXP "%s: %s") %
103 type % exp_message,
104 Stderr_File.str()));
105 else
106 ATF_REQUIRE(atf::utils::grep_file(F(FILE_REGEXP "%s") % type,
107 Stderr_File.str()));
108 }
109 }
110
111
112 template< bool Expression, bool WithMessage >
113 static void
do_inv_test(void)114 do_inv_test(void)
115 {
116 std::cout << "Before test\n";
117 if (WithMessage)
118 INV_MSG(Expression, "Custom message");
119 else
120 INV(Expression);
121 std::cout << "After test\n";
122 std::exit(EXIT_SUCCESS);
123 }
124
125
126 ATF_TEST_CASE_WITHOUT_HEAD(inv__holds);
ATF_TEST_CASE_BODY(inv__holds)127 ATF_TEST_CASE_BODY(inv__holds)
128 {
129 const process::status status = run_test(do_inv_test< true, false >);
130 verify_success(status);
131 }
132
133
134 ATF_TEST_CASE_WITHOUT_HEAD(inv__triggers_default_message);
ATF_TEST_CASE_BODY(inv__triggers_default_message)135 ATF_TEST_CASE_BODY(inv__triggers_default_message)
136 {
137 const process::status status = run_test(do_inv_test< false, false >);
138 verify_failed(status, "Invariant check failed", "Expression", true);
139 }
140
141
142 ATF_TEST_CASE_WITHOUT_HEAD(inv__triggers_custom_message);
ATF_TEST_CASE_BODY(inv__triggers_custom_message)143 ATF_TEST_CASE_BODY(inv__triggers_custom_message)
144 {
145 const process::status status = run_test(do_inv_test< false, true >);
146 verify_failed(status, "Invariant check failed", "Custom", true);
147 }
148
149
150 template< bool Expression, bool WithMessage >
151 static void
do_pre_test(void)152 do_pre_test(void)
153 {
154 std::cout << "Before test\n";
155 if (WithMessage)
156 PRE_MSG(Expression, "Custom message");
157 else
158 PRE(Expression);
159 std::cout << "After test\n";
160 std::exit(EXIT_SUCCESS);
161 }
162
163
164 ATF_TEST_CASE_WITHOUT_HEAD(pre__holds);
ATF_TEST_CASE_BODY(pre__holds)165 ATF_TEST_CASE_BODY(pre__holds)
166 {
167 const process::status status = run_test(do_pre_test< true, false >);
168 verify_success(status);
169 }
170
171
172 ATF_TEST_CASE_WITHOUT_HEAD(pre__triggers_default_message);
ATF_TEST_CASE_BODY(pre__triggers_default_message)173 ATF_TEST_CASE_BODY(pre__triggers_default_message)
174 {
175 const process::status status = run_test(do_pre_test< false, false >);
176 verify_failed(status, "Precondition check failed", "Expression", true);
177 }
178
179
180 ATF_TEST_CASE_WITHOUT_HEAD(pre__triggers_custom_message);
ATF_TEST_CASE_BODY(pre__triggers_custom_message)181 ATF_TEST_CASE_BODY(pre__triggers_custom_message)
182 {
183 const process::status status = run_test(do_pre_test< false, true >);
184 verify_failed(status, "Precondition check failed", "Custom", true);
185 }
186
187
188 template< bool Expression, bool WithMessage >
189 static void
do_post_test(void)190 do_post_test(void)
191 {
192 std::cout << "Before test\n";
193 if (WithMessage)
194 POST_MSG(Expression, "Custom message");
195 else
196 POST(Expression);
197 std::cout << "After test\n";
198 std::exit(EXIT_SUCCESS);
199 }
200
201
202 ATF_TEST_CASE_WITHOUT_HEAD(post__holds);
ATF_TEST_CASE_BODY(post__holds)203 ATF_TEST_CASE_BODY(post__holds)
204 {
205 const process::status status = run_test(do_post_test< true, false >);
206 verify_success(status);
207 }
208
209
210 ATF_TEST_CASE_WITHOUT_HEAD(post__triggers_default_message);
ATF_TEST_CASE_BODY(post__triggers_default_message)211 ATF_TEST_CASE_BODY(post__triggers_default_message)
212 {
213 const process::status status = run_test(do_post_test< false, false >);
214 verify_failed(status, "Postcondition check failed", "Expression", true);
215 }
216
217
218 ATF_TEST_CASE_WITHOUT_HEAD(post__triggers_custom_message);
ATF_TEST_CASE_BODY(post__triggers_custom_message)219 ATF_TEST_CASE_BODY(post__triggers_custom_message)
220 {
221 const process::status status = run_test(do_post_test< false, true >);
222 verify_failed(status, "Postcondition check failed", "Custom", true);
223 }
224
225
226 template< bool WithMessage >
227 static void
do_unreachable_test(void)228 do_unreachable_test(void)
229 {
230 std::cout << "Before test\n";
231 if (WithMessage)
232 UNREACHABLE_MSG("Custom message");
233 else
234 UNREACHABLE;
235 std::cout << "After test\n";
236 std::exit(EXIT_SUCCESS);
237 }
238
239
240 ATF_TEST_CASE_WITHOUT_HEAD(unreachable__default_message);
ATF_TEST_CASE_BODY(unreachable__default_message)241 ATF_TEST_CASE_BODY(unreachable__default_message)
242 {
243 const process::status status = run_test(do_unreachable_test< false >);
244 verify_failed(status, "Unreachable point reached", NULL, false);
245 }
246
247
248 ATF_TEST_CASE_WITHOUT_HEAD(unreachable__custom_message);
ATF_TEST_CASE_BODY(unreachable__custom_message)249 ATF_TEST_CASE_BODY(unreachable__custom_message)
250 {
251 const process::status status = run_test(do_unreachable_test< true >);
252 verify_failed(status, "Unreachable point reached", "Custom", false);
253 }
254
255
256 template< int Signo >
257 static void
do_crash_handler_test(void)258 do_crash_handler_test(void)
259 {
260 utils::install_crash_handlers("test-log.txt");
261 ::kill(::getpid(), Signo);
262 std::cout << "After signal\n";
263 std::exit(EXIT_FAILURE);
264 }
265
266
267 template< int Signo >
268 static void
crash_handler_test(void)269 crash_handler_test(void)
270 {
271 utils::avoid_coredump_on_crash();
272
273 const process::status status = run_test(do_crash_handler_test< Signo >);
274 ATF_REQUIRE(status.signaled());
275 ATF_REQUIRE_EQ(Signo, status.termsig());
276 ATF_REQUIRE(atf::utils::grep_file(F("Fatal signal %s") % Signo,
277 Stderr_File.str()));
278 ATF_REQUIRE(atf::utils::grep_file("Log file is test-log.txt",
279 Stderr_File.str()));
280 ATF_REQUIRE(!atf::utils::grep_file("After signal", Stdout_File.str()));
281 }
282
283
284 ATF_TEST_CASE_WITHOUT_HEAD(install_crash_handlers__sigabrt);
ATF_TEST_CASE_BODY(install_crash_handlers__sigabrt)285 ATF_TEST_CASE_BODY(install_crash_handlers__sigabrt)
286 {
287 crash_handler_test< SIGABRT >();
288 }
289
290
291 ATF_TEST_CASE_WITHOUT_HEAD(install_crash_handlers__sigbus);
ATF_TEST_CASE_BODY(install_crash_handlers__sigbus)292 ATF_TEST_CASE_BODY(install_crash_handlers__sigbus)
293 {
294 crash_handler_test< SIGBUS >();
295 }
296
297
298 ATF_TEST_CASE_WITHOUT_HEAD(install_crash_handlers__sigsegv);
ATF_TEST_CASE_BODY(install_crash_handlers__sigsegv)299 ATF_TEST_CASE_BODY(install_crash_handlers__sigsegv)
300 {
301 crash_handler_test< SIGSEGV >();
302 }
303
304
ATF_INIT_TEST_CASES(tcs)305 ATF_INIT_TEST_CASES(tcs)
306 {
307 ATF_ADD_TEST_CASE(tcs, inv__holds);
308 ATF_ADD_TEST_CASE(tcs, inv__triggers_default_message);
309 ATF_ADD_TEST_CASE(tcs, inv__triggers_custom_message);
310 ATF_ADD_TEST_CASE(tcs, pre__holds);
311 ATF_ADD_TEST_CASE(tcs, pre__triggers_default_message);
312 ATF_ADD_TEST_CASE(tcs, pre__triggers_custom_message);
313 ATF_ADD_TEST_CASE(tcs, post__holds);
314 ATF_ADD_TEST_CASE(tcs, post__triggers_default_message);
315 ATF_ADD_TEST_CASE(tcs, post__triggers_custom_message);
316 ATF_ADD_TEST_CASE(tcs, unreachable__default_message);
317 ATF_ADD_TEST_CASE(tcs, unreachable__custom_message);
318
319 ATF_ADD_TEST_CASE(tcs, install_crash_handlers__sigabrt);
320 ATF_ADD_TEST_CASE(tcs, install_crash_handlers__sigbus);
321 ATF_ADD_TEST_CASE(tcs, install_crash_handlers__sigsegv);
322 }
323