-
// $Id$
//
// Copyright (C) 2006
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-// Unit tests
+/** \file
+ \brief Scheduler unit tests */
-//#include "scheduler.test.hh"
-//#include "scheduler.test.ih"
+//#include "Scheduler.test.hh"
+//#include "Scheduler.test.ih"
// Custom includes
#include <sys/types.h>
#define prefix_
///////////////////////////////cc.p////////////////////////////////////////
-using namespace senf;
-
namespace {
char const * SOCK_PATH = "/tmp/sched_test.sock";
unlink(SOCK_PATH);
int pid = fork();
if (pid == 0) {
+ signal(SIGCHLD, SIG_IGN);
server();
_exit(0);
}
error("fork");
return 0;
}
+ signal(SIGCHLD, SIG_DFL);
sleep(1); // Wait for the server socket to be opened
return pid;
void callback(int fd, int ev)
{
event = ev;
- switch (event & Scheduler::EV_ALL) {
- case Scheduler::EV_READ:
+ switch (event & senf::scheduler::FdEvent::EV_ALL) {
+ case senf::scheduler::FdEvent::EV_READ:
size = recv(fd,buffer,1024,0);
break;
- case Scheduler::EV_PRIO:
+ case senf::scheduler::FdEvent::EV_PRIO:
size = recv(fd,buffer,1024,MSG_OOB);
- Scheduler::instance().terminate();
break;
- case Scheduler::EV_WRITE:
+ case senf::scheduler::FdEvent::EV_WRITE:
size = write(fd,buffer,size);
- Scheduler::instance().terminate();
break;
}
- Scheduler::instance().terminate();
+ senf::scheduler::terminate();
}
bool timeoutCalled = false;
void timeout()
{
timeoutCalled = true;
- Scheduler::instance().terminate();
+ senf::scheduler::terminate();
}
struct HandleWrapper
callback(handle.fd_,event);
}
- bool is_close(ClockService::clock_type a, ClockService::clock_type b)
+ bool is_close(senf::ClockService::clock_type a, senf::ClockService::clock_type b)
{
- return (a<b ? b-a : a-b) < ClockService::milliseconds(100);
+ return (a<b ? b-a : a-b) < senf::ClockService::milliseconds(100);
}
- ClockService::clock_type sigtime (0);
+ senf::ClockService::clock_type sigtime (0);
void sigusr(siginfo_t const &)
{
- sigtime = ClockService::now();
- Scheduler::instance().terminate();
+ sigtime = senf::ClockService::now();
+ senf::scheduler::terminate();
}
void delay(unsigned long milliseconds)
void blockingHandler()
{
delay(2200);
- Scheduler::instance().terminate();
+ senf::scheduler::terminate();
}
+ unsigned eventCount (0);
+
+ void eventeventhandler()
+ {
+ ++ eventCount;
+ }
}
-BOOST_AUTO_UNIT_TEST(testScheduler)
+void schedulerTest()
{
int pid = start_server();
BOOST_REQUIRE (pid);
///////////////////////////////////////////////////////////////////////////
- BOOST_CHECK_NO_THROW( Scheduler::instance() );
+ senf::scheduler::EventHook evev ("eventCounter", eventeventhandler,
+ senf::scheduler::EventHook::PRE);
{
senf::scheduler::FdEvent fde1 ("testFdEvent", boost::bind(&callback, sock, _1),
sock, senf::scheduler::FdEvent::EV_READ);
- event = Scheduler::EV_NONE;
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_EQUAL( event, Scheduler::EV_READ );
+ event = senf::scheduler::FdEvent::EV_NONE;
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ );
BOOST_REQUIRE_EQUAL( size, 4 );
buffer[size]=0;
BOOST_CHECK_EQUAL( buffer, "READ" );
handle, senf::scheduler::FdEvent::EV_WRITE);
strcpy(buffer,"WRITE");
size=5;
- event = Scheduler::EV_NONE;
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_EQUAL( event, Scheduler::EV_WRITE );
+ event = senf::scheduler::FdEvent::EV_NONE;
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_WRITE );
SENF_CHECK_NO_THROW( fde2.disable() );
- event = Scheduler::EV_NONE;
+ event = senf::scheduler::FdEvent::EV_NONE;
sleep(1);
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_EQUAL( event, Scheduler::EventId(Scheduler::EV_READ|Scheduler::EV_HUP) );
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ|senf::scheduler::FdEvent::EV_HUP );
BOOST_REQUIRE_EQUAL( size, 2 );
buffer[size]=0;
BOOST_CHECK_EQUAL( buffer, "OK" );
{
senf::scheduler::TimerEvent timer1 ("testTimer1", &timeout,
- ClockService::now()+ClockService::milliseconds(200));
+ senf::ClockService::now()+senf::ClockService::milliseconds(200));
senf::scheduler::TimerEvent timer2 ("testTimer2", &timeout,
- ClockService::now()+ClockService::milliseconds(400));
+ senf::ClockService::now()+senf::ClockService::milliseconds(400));
- event = Scheduler::EV_NONE;
- ClockService::clock_type t (ClockService::now());
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_PREDICATE( is_close, (ClockService::now()-t) (ClockService::milliseconds(200)) );
+ event = senf::scheduler::FdEvent::EV_NONE;
+ senf::ClockService::clock_type t (senf::ClockService::now());
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()-t) (senf::ClockService::milliseconds(200)) );
BOOST_CHECK( timeoutCalled );
BOOST_CHECK( ! timer1.enabled() );
- BOOST_CHECK_EQUAL( event, Scheduler::EV_NONE );
- BOOST_CHECK_PREDICATE( is_close, (ClockService::now()) (Scheduler::instance().eventTime()) );
+ BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_NONE );
+ BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (senf::scheduler::eventTime()) );
timeoutCalled = false;
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_PREDICATE( is_close, (ClockService::now()-t) (ClockService::milliseconds(400)) );
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()-t) (senf::ClockService::milliseconds(400)) );
BOOST_CHECK( timeoutCalled );
- BOOST_CHECK_EQUAL( event, Scheduler::EV_NONE );
+ BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_NONE );
BOOST_CHECK( ! timer2.enabled() );
- BOOST_WARN_MESSAGE( false, "A 'Scheduler task hanging' error is expected to be signaled here." );
- BOOST_CHECK_NO_THROW( timer1.action(&blockingHandler) );
- BOOST_CHECK_NO_THROW( timer1.timeout(ClockService::now()) );
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_EQUAL( Scheduler::instance().hangCount(), 1u );
+ BOOST_MESSAGE( "A 'Scheduler task hanging' error is expected to be signaled here." );
+ SENF_CHECK_NO_THROW( timer1.action(&blockingHandler) );
+ SENF_CHECK_NO_THROW( timer1.timeout(senf::ClockService::now()) );
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_EQUAL( senf::scheduler::watchdogEvents(), 1u );
}
{
senf::scheduler::TimerEvent timer ("testWatchdog", &timeout,
- ClockService::now()+ClockService::milliseconds(400));
+ senf::ClockService::now()+senf::ClockService::milliseconds(400));
senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
- ClockService::clock_type t = ClockService::now();
+ senf::ClockService::clock_type t = senf::ClockService::now();
::kill(::getpid(), SIGUSR1);
- delay(100);
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
- BOOST_CHECK_PREDICATE( is_close, (ClockService::now()) (t+ClockService::milliseconds(200)) );
- BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+ClockService::milliseconds(200)) );
- BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
+ delay(200);
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+ BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (t+senf::ClockService::milliseconds(200)) );
+ BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+senf::ClockService::milliseconds(200)) );
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
}
+ BOOST_CHECK( eventCount >= 8u );
+
+
///////////////////////////////////////////////////////////////////////////
close(sock);
BOOST_CHECK (stop_server(pid));
}
+BOOST_AUTO_UNIT_TEST(testSchedulerPollTimers)
+{
+ BOOST_CHECK( ! senf::scheduler::usingHiresTimers() );
+ schedulerTest();
+}
+
+BOOST_AUTO_UNIT_TEST(testSchedulerHiresTimers)
+{
+ if (senf::scheduler::haveScalableHiresTimers())
+ BOOST_MESSAGE( "Using timerfd() hires timers" );
+ else
+ BOOST_MESSAGE( "Using POSIX hires timers");
+ SENF_CHECK_NO_THROW( senf::scheduler::hiresTimers() );
+ BOOST_CHECK( senf::scheduler::usingHiresTimers() );
+ schedulerTest();
+ SENF_CHECK_NO_THROW( senf::scheduler::loresTimers() );
+ BOOST_CHECK( ! senf::scheduler::usingHiresTimers() );
+}
+
+BOOST_AUTO_UNIT_TEST(testSchedulerPOSIXTimers)
+{
+ if (senf::scheduler::haveScalableHiresTimers()) {
+ SENF_CHECK_NO_THROW( senf::scheduler::detail::TimerDispatcher::instance().timerSource(
+ std::auto_ptr<senf::scheduler::detail::TimerSource>(
+ new senf::scheduler::detail::POSIXTimerSource())) );
+ schedulerTest();
+ senf::scheduler::loresTimers();
+ }
+}
+
+namespace {
+
+ void sigme()
+ {
+ senf::scheduler::BlockSignals signalBlocker;
+ signalBlocker.block();
+ signalBlocker.unblock();
+ BOOST_CHECK( ! signalBlocker.blocked() );
+ signalBlocker.unblock();
+ signalBlocker.block();
+ BOOST_CHECK( signalBlocker.blocked() );
+ ::kill(::getpid(), SIGUSR1);
+ delay(200);
+ }
+
+}
+
+BOOST_AUTO_UNIT_TEST(blockSignals)
+{
+ senf::scheduler::TimerEvent signaler ("sigme", &sigme, senf::ClockService::now());
+ senf::scheduler::TimerEvent timer (
+ "testWatchdog", &timeout, senf::ClockService::now()+senf::ClockService::milliseconds(400));
+ senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
+
+ senf::ClockService::clock_type t = senf::ClockService::now();
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+
+ BOOST_CHECK_PREDICATE( is_close,
+ (senf::ClockService::now())
+ (t+senf::ClockService::milliseconds(200)) );
+ BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+senf::ClockService::milliseconds(200)) );
+
+ SENF_CHECK_NO_THROW( senf::scheduler::process() );
+}
+
///////////////////////////////cc.e////////////////////////////////////////
#undef prefix_
projects / senf.git / blobdiff