1 //
2 // Automated Testing Framework (atf)
3 //
4 // Copyright (c) 2008 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 extern "C" {
31 #include <sys/types.h>
32 #include <signal.h>
33 #include <unistd.h>
34 }
35
36 #include <cerrno>
37 #include <cstdlib>
38 #include <iostream>
39
40 #include <atf-c++.hpp>
41
42 #include "exceptions.hpp"
43 #include "process.hpp"
44 #include "signals.hpp"
45
46 // ------------------------------------------------------------------------
47 // Auxiliary functions.
48 // ------------------------------------------------------------------------
49
50 namespace sigusr1 {
51 static bool happened = false;
52
53 static
54 void
handler(int signo)55 handler(int signo __attribute__((__unused__)))
56 {
57 happened = true;
58 }
59
60 static
61 void
program(void)62 program(void)
63 {
64 struct sigaction sa;
65 sa.sa_handler = handler;
66 sigemptyset(&sa.sa_mask);
67 sa.sa_flags = 0;
68 if (::sigaction(SIGUSR1, &sa, NULL) == -1)
69 throw tools::system_error("sigusr1::program",
70 "sigaction(2) failed", errno);
71 }
72 } // namespace sigusr1
73
74 namespace sigusr1_2 {
75 static bool happened = false;
76
77 static
78 void
handler(int signo)79 handler(int signo __attribute__((__unused__)))
80 {
81 happened = true;
82 }
83 } // namespace sigusr1_2
84
85 // ------------------------------------------------------------------------
86 // Tests for the "signal_holder" class.
87 // ------------------------------------------------------------------------
88
89 ATF_TEST_CASE(signal_holder_preserve);
ATF_TEST_CASE_HEAD(signal_holder_preserve)90 ATF_TEST_CASE_HEAD(signal_holder_preserve)
91 {
92 set_md_var("descr", "Tests that signal_holder preserves the original "
93 "signal handler and restores it upon destruction");
94 }
ATF_TEST_CASE_BODY(signal_holder_preserve)95 ATF_TEST_CASE_BODY(signal_holder_preserve)
96 {
97 using tools::signals::signal_holder;
98
99 sigusr1::program();
100
101 sigusr1::happened = false;
102 ::kill(::getpid(), SIGUSR1);
103 ATF_REQUIRE(sigusr1::happened);
104
105 {
106 signal_holder hld(SIGUSR1);
107 ::kill(::getpid(), SIGUSR1);
108 }
109
110 sigusr1::happened = false;
111 ::kill(::getpid(), SIGUSR1);
112 ATF_REQUIRE(sigusr1::happened);
113 }
114
115 ATF_TEST_CASE(signal_holder_destructor);
ATF_TEST_CASE_HEAD(signal_holder_destructor)116 ATF_TEST_CASE_HEAD(signal_holder_destructor)
117 {
118 set_md_var("descr", "Tests that signal_holder processes a pending "
119 "signal upon destruction");
120 }
ATF_TEST_CASE_BODY(signal_holder_destructor)121 ATF_TEST_CASE_BODY(signal_holder_destructor)
122 {
123 using tools::signals::signal_holder;
124
125 sigusr1::program();
126
127 sigusr1::happened = false;
128 ::kill(::getpid(), SIGUSR1);
129 ATF_REQUIRE(sigusr1::happened);
130
131 {
132 signal_holder hld(SIGUSR1);
133
134 sigusr1::happened = false;
135 ::kill(::getpid(), SIGUSR1);
136 ATF_REQUIRE(!sigusr1::happened);
137 }
138 ATF_REQUIRE(sigusr1::happened);
139 }
140
141 ATF_TEST_CASE(signal_holder_process);
ATF_TEST_CASE_HEAD(signal_holder_process)142 ATF_TEST_CASE_HEAD(signal_holder_process)
143 {
144 set_md_var("descr", "Tests that signal_holder's process method works "
145 "to process a delayed signal explicitly");
146 }
ATF_TEST_CASE_BODY(signal_holder_process)147 ATF_TEST_CASE_BODY(signal_holder_process)
148 {
149 using tools::signals::signal_holder;
150
151 sigusr1::program();
152
153 sigusr1::happened = false;
154 ::kill(::getpid(), SIGUSR1);
155 ATF_REQUIRE(sigusr1::happened);
156
157 {
158 signal_holder hld(SIGUSR1);
159
160 sigusr1::happened = false;
161 ::kill(::getpid(), SIGUSR1);
162 ATF_REQUIRE(!sigusr1::happened);
163
164 hld.process();
165 ATF_REQUIRE(sigusr1::happened);
166
167 sigusr1::happened = false;
168 }
169 ATF_REQUIRE(!sigusr1::happened);
170 }
171
172 // ------------------------------------------------------------------------
173 // Tests for the "signal_programmer" class.
174 // ------------------------------------------------------------------------
175
176 ATF_TEST_CASE(signal_programmer_program);
ATF_TEST_CASE_HEAD(signal_programmer_program)177 ATF_TEST_CASE_HEAD(signal_programmer_program)
178 {
179 set_md_var("descr", "Tests that signal_programmer correctly installs a "
180 "handler");
181 }
ATF_TEST_CASE_BODY(signal_programmer_program)182 ATF_TEST_CASE_BODY(signal_programmer_program)
183 {
184 using tools::signals::signal_programmer;
185
186 signal_programmer sp(SIGUSR1, sigusr1_2::handler);
187
188 sigusr1_2::happened = false;
189 ::kill(::getpid(), SIGUSR1);
190 ATF_REQUIRE(sigusr1_2::happened);
191 }
192
193 ATF_TEST_CASE(signal_programmer_preserve);
ATF_TEST_CASE_HEAD(signal_programmer_preserve)194 ATF_TEST_CASE_HEAD(signal_programmer_preserve)
195 {
196 set_md_var("descr", "Tests that signal_programmer uninstalls the "
197 "handler during destruction");
198 }
ATF_TEST_CASE_BODY(signal_programmer_preserve)199 ATF_TEST_CASE_BODY(signal_programmer_preserve)
200 {
201 using tools::signals::signal_programmer;
202
203 sigusr1::program();
204 sigusr1::happened = false;
205
206 {
207 signal_programmer sp(SIGUSR1, sigusr1_2::handler);
208
209 sigusr1_2::happened = false;
210 ::kill(::getpid(), SIGUSR1);
211 ATF_REQUIRE(sigusr1_2::happened);
212 }
213
214 ATF_REQUIRE(!sigusr1::happened);
215 ::kill(::getpid(), SIGUSR1);
216 ATF_REQUIRE(sigusr1::happened);
217 }
218
219 // ------------------------------------------------------------------------
220 // Tests cases for the free functions.
221 // ------------------------------------------------------------------------
222
223 static
224 void
reset_child(void * v)225 reset_child(void *v __attribute__((__unused__)))
226 {
227 sigusr1::program();
228
229 sigusr1::happened = false;
230 tools::signals::reset(SIGUSR1);
231 kill(::getpid(), SIGUSR1);
232
233 if (sigusr1::happened) {
234 std::cerr << "Signal was not resetted correctly\n";
235 std::abort();
236 } else {
237 std::exit(EXIT_SUCCESS);
238 }
239 }
240
241 ATF_TEST_CASE(reset);
ATF_TEST_CASE_HEAD(reset)242 ATF_TEST_CASE_HEAD(reset)
243 {
244 set_md_var("descr", "Tests the reset function");
245 }
ATF_TEST_CASE_BODY(reset)246 ATF_TEST_CASE_BODY(reset)
247 {
248 tools::process::child c =
249 tools::process::fork(reset_child, tools::process::stream_inherit(),
250 tools::process::stream_inherit(), NULL);
251
252 const tools::process::status s = c.wait();
253 ATF_REQUIRE(s.exited() || s.signaled());
254 ATF_REQUIRE(!s.signaled() || s.termsig() == SIGUSR1);
255 }
256
257 // ------------------------------------------------------------------------
258 // Main.
259 // ------------------------------------------------------------------------
260
ATF_INIT_TEST_CASES(tcs)261 ATF_INIT_TEST_CASES(tcs)
262 {
263 // Add the tests for the "signal_holder" class.
264 ATF_ADD_TEST_CASE(tcs, signal_holder_preserve);
265 ATF_ADD_TEST_CASE(tcs, signal_holder_destructor);
266 ATF_ADD_TEST_CASE(tcs, signal_holder_process);
267
268 // Add the tests for the "signal_programmer" class.
269 ATF_ADD_TEST_CASE(tcs, signal_programmer_program);
270 ATF_ADD_TEST_CASE(tcs, signal_programmer_preserve);
271
272 // Add the test cases for the free functions.
273 ATF_ADD_TEST_CASE(tcs, reset);
274 }
275