4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
6 // Stefan Bund <g0dil@berlios.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 //#include "scheduler.test.hh"
26 //#include "scheduler.test.ih"
29 #include <sys/types.h>
33 #include <sys/socket.h>
38 #include <boost/bind.hpp>
40 #include "Scheduler.hh"
42 #include "../Utils/auto_unit_test.hh"
43 #include <boost/test/test_tools.hpp>
46 ///////////////////////////////cc.p////////////////////////////////////////
50 char const * SOCK_PATH = "/tmp/sched_test.sock";
52 void error(char const * fn, char const * proc="")
54 std::cerr << "\n" << proc << fn << ": " << strerror(errno) << std::endl;
57 void fail(char const * fn)
65 int sock = socket(PF_UNIX,SOCK_STREAM,0);
66 if (sock<0) fail("socket");
67 struct sockaddr_un sun;
68 memset(&sun,0,sizeof(sun));
69 sun.sun_family = AF_UNIX;
70 strcpy(sun.sun_path,SOCK_PATH);
71 if (bind(sock,(struct sockaddr*)&sun,sizeof(sun))<0) fail("bind");
72 if (listen(sock,1)<0) fail("listen");
73 int conn = accept(sock,0,0);
74 if (conn < 0) fail("accept");
76 ///////////////////////////////////////////////////////////////////////////
78 if (write(conn,"READ",4)<0) fail("write");
80 int size = read(conn,buffer,1024);
81 if (size<0) fail("read");
84 if (strcmp(buffer,"WRITE")==0) {
85 if (write(conn,"OK",2)<0) fail("write");
87 if (write(conn,"FAIL",4)<0) fail("write");
89 if (write(conn,"FAIL",4)<0) fail("write");
91 ///////////////////////////////////////////////////////////////////////////
102 signal(SIGCHLD, SIG_IGN);
110 signal(SIGCHLD, SIG_DFL);
112 sleep(1); // Wait for the server socket to be opened
116 bool stop_server(int pid)
118 sleep(1); // Wait for the server to terminate
119 if (kill(pid,SIGTERM)<0) {
124 if (waitpid(pid,&status,0)<0) {
129 if (WIFSIGNALED(status)) {
130 std::cerr << "\nserver terminated with signal " << WTERMSIG(status) << std::endl;
133 if (WEXITSTATUS(status)!=0) {
134 std::cerr << "\nserver terminated with exit status " << WEXITSTATUS(status) << std::endl;
144 void callback(int fd, int ev)
147 switch (event & senf::scheduler::FdEvent::EV_ALL) {
148 case senf::scheduler::FdEvent::EV_READ:
149 size = recv(fd,buffer,1024,0);
151 case senf::scheduler::FdEvent::EV_PRIO:
152 size = recv(fd,buffer,1024,MSG_OOB);
154 case senf::scheduler::FdEvent::EV_WRITE:
155 size = write(fd,buffer,size);
158 senf::scheduler::terminate();
161 bool timeoutCalled = false;
164 timeoutCalled = true;
165 senf::scheduler::terminate();
170 HandleWrapper(int fd,std::string const & tag) : fd_(fd), tag_(tag) {}
175 int retrieve_filehandle(HandleWrapper const & handle)
180 void handleCallback(HandleWrapper const & handle, int event)
182 if (handle.tag_ != "TheTag")
184 callback(handle.fd_,event);
187 bool is_close(senf::ClockService::clock_type a, senf::ClockService::clock_type b)
189 return (a<b ? b-a : a-b) < senf::ClockService::milliseconds(100);
192 senf::ClockService::clock_type sigtime (0);
194 void sigusr(siginfo_t const &)
196 sigtime = senf::ClockService::now();
197 senf::scheduler::terminate();
200 void delay(unsigned long milliseconds)
203 ts.tv_sec = milliseconds / 1000;
204 ts.tv_nsec = (milliseconds % 1000) * 1000000;
205 while (nanosleep(&ts,&ts) < 0 && errno == EINTR) ;
208 void blockingHandler()
211 senf::scheduler::terminate();
214 unsigned eventCount (0);
216 void eventeventhandler()
224 int pid = start_server();
227 int sock = socket(PF_UNIX,SOCK_STREAM,0);
230 BOOST_FAIL("socket");
232 struct sockaddr_un sun;
233 memset(&sun,0,sizeof(sun));
234 sun.sun_family = AF_UNIX;
235 strcpy(sun.sun_path,SOCK_PATH);
237 if (connect(sock,(struct sockaddr*)&sun,sizeof(sun))<0) {
239 BOOST_FAIL("connect");
242 ///////////////////////////////////////////////////////////////////////////
244 senf::scheduler::EventHook evev ("eventCounter", eventeventhandler, true,
245 senf::scheduler::EventHook::PRE);
248 senf::scheduler::FdEvent fde1 ("testFdEvent", boost::bind(&callback, sock, _1),
249 sock, senf::scheduler::FdEvent::EV_READ);
250 event = senf::scheduler::FdEvent::EV_NONE;
251 SENF_CHECK_NO_THROW( senf::scheduler::process() );
252 BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ );
253 BOOST_REQUIRE_EQUAL( size, 4 );
255 BOOST_CHECK_EQUAL( buffer, "READ" );
257 HandleWrapper handle(sock,"TheTag");
258 senf::scheduler::FdEvent fde2 ("testFdEvent", boost::bind(&handleCallback,handle,_1),
259 handle, senf::scheduler::FdEvent::EV_WRITE);
260 strcpy(buffer,"WRITE");
262 event = senf::scheduler::FdEvent::EV_NONE;
263 SENF_CHECK_NO_THROW( senf::scheduler::process() );
264 BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_WRITE );
266 SENF_CHECK_NO_THROW( fde2.disable() );
267 event = senf::scheduler::FdEvent::EV_NONE;
269 SENF_CHECK_NO_THROW( senf::scheduler::process() );
270 BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ|senf::scheduler::FdEvent::EV_HUP );
271 BOOST_REQUIRE_EQUAL( size, 2 );
273 BOOST_CHECK_EQUAL( buffer, "OK" );
277 senf::scheduler::TimerEvent timer1 ("testTimer1", &timeout,
278 senf::ClockService::now()+senf::ClockService::milliseconds(200));
279 senf::scheduler::TimerEvent timer2 ("testTimer2", &timeout,
280 senf::ClockService::now()+senf::ClockService::milliseconds(400));
282 event = senf::scheduler::FdEvent::EV_NONE;
283 senf::ClockService::clock_type t (senf::ClockService::now());
284 SENF_CHECK_NO_THROW( senf::scheduler::process() );
285 BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()-t) (senf::ClockService::milliseconds(200)) );
286 BOOST_CHECK( timeoutCalled );
287 BOOST_CHECK( ! timer1.enabled() );
288 BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_NONE );
289 BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (senf::scheduler::eventTime()) );
290 timeoutCalled = false;
291 SENF_CHECK_NO_THROW( senf::scheduler::process() );
292 BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()-t) (senf::ClockService::milliseconds(400)) );
293 BOOST_CHECK( timeoutCalled );
294 BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_NONE );
295 BOOST_CHECK( ! timer2.enabled() );
297 BOOST_MESSAGE( "A 'Scheduler task hanging' error is expected to be signaled here." );
298 SENF_CHECK_NO_THROW( timer1.action(&blockingHandler) );
299 SENF_CHECK_NO_THROW( timer1.timeout(senf::ClockService::now()) );
300 SENF_CHECK_NO_THROW( senf::scheduler::process() );
301 BOOST_CHECK_EQUAL( senf::scheduler::watchdogEvents(), 1u );
305 senf::scheduler::TimerEvent timer ("testWatchdog", &timeout,
306 senf::ClockService::now()+senf::ClockService::milliseconds(400));
307 senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
309 senf::ClockService::clock_type t = senf::ClockService::now();
310 ::kill(::getpid(), SIGUSR1);
312 SENF_CHECK_NO_THROW( senf::scheduler::process() );
313 BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (t+senf::ClockService::milliseconds(200)) );
314 BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+senf::ClockService::milliseconds(200)) );
315 SENF_CHECK_NO_THROW( senf::scheduler::process() );
318 BOOST_CHECK( eventCount >= 8u );
321 ///////////////////////////////////////////////////////////////////////////
325 BOOST_CHECK (stop_server(pid));
328 BOOST_AUTO_UNIT_TEST(testSchedulerPollTimers)
330 BOOST_CHECK( ! senf::scheduler::usingHiresTimers() );
334 BOOST_AUTO_UNIT_TEST(testSchedulerHiresTimers)
336 if (senf::scheduler::haveScalableHiresTimers())
337 BOOST_MESSAGE( "Using timerfd() hires timers" );
339 BOOST_MESSAGE( "Using POSIX hires timers");
340 SENF_CHECK_NO_THROW( senf::scheduler::hiresTimers() );
341 BOOST_CHECK( senf::scheduler::usingHiresTimers() );
343 SENF_CHECK_NO_THROW( senf::scheduler::loresTimers() );
344 BOOST_CHECK( ! senf::scheduler::usingHiresTimers() );
347 BOOST_AUTO_UNIT_TEST(testSchedulerPOSIXTimers)
349 if (senf::scheduler::haveScalableHiresTimers()) {
350 SENF_CHECK_NO_THROW( senf::scheduler::detail::TimerDispatcher::instance().timerSource(
351 std::auto_ptr<senf::scheduler::detail::TimerSource>(
352 new senf::scheduler::detail::POSIXTimerSource())) );
354 senf::scheduler::loresTimers();
362 senf::scheduler::BlockSignals signalBlocker;
363 signalBlocker.block();
364 signalBlocker.unblock();
365 BOOST_CHECK( ! signalBlocker.blocked() );
366 signalBlocker.unblock();
367 signalBlocker.block();
368 BOOST_CHECK( signalBlocker.blocked() );
369 ::kill(::getpid(), SIGUSR1);
375 BOOST_AUTO_UNIT_TEST(blockSignals)
377 senf::scheduler::TimerEvent signaler ("sigme", &sigme, senf::ClockService::now());
378 senf::scheduler::TimerEvent timer (
379 "testWatchdog", &timeout, senf::ClockService::now()+senf::ClockService::milliseconds(400));
380 senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
382 senf::ClockService::clock_type t = senf::ClockService::now();
383 SENF_CHECK_NO_THROW( senf::scheduler::process() );
385 BOOST_CHECK_PREDICATE( is_close,
386 (senf::ClockService::now())
387 (t+senf::ClockService::milliseconds(200)) );
388 BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+senf::ClockService::milliseconds(200)) );
390 SENF_CHECK_NO_THROW( senf::scheduler::process() );
393 ///////////////////////////////cc.e////////////////////////////////////////
400 // c-file-style: "senf"
401 // indent-tabs-mode: nil
402 // ispell-local-dictionary: "american"
403 // compile-command: "scons -u test"
404 // comment-column: 40