X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Scheduler%2FScheduler.test.cc;h=0a135182e2abfe34b4d070d822365eab52d4c629;hb=f2f5d59e83863f3b513950173baee1b6da2aee3c;hp=e270b060374a306ad02ca70b9b7761556fc24661;hpb=ac90835cbb00ca83a51ab9efb23fdcb75518e808;p=senf.git

diff --git a/Scheduler/Scheduler.test.cc b/Scheduler/Scheduler.test.cc
index e270b06..0a13518 100644
--- a/Scheduler/Scheduler.test.cc
+++ b/Scheduler/Scheduler.test.cc
@@ -1,4 +1,3 @@
-
 // $Id$
 //
 // Copyright (C) 2006
@@ -21,10 +20,11 @@
 // 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>
@@ -46,8 +46,6 @@
 #define prefix_
 ///////////////////////////////cc.p////////////////////////////////////////
 
-using namespace senf;
-
 namespace {
 
     char const * SOCK_PATH = "/tmp/sched_test.sock";
@@ -102,6 +100,7 @@ namespace {
         unlink(SOCK_PATH);
         int pid = fork();
         if (pid == 0) {
+            signal(SIGCHLD, SIG_IGN);
             server();
             _exit(0);
         }
@@ -109,6 +108,7 @@ namespace {
             error("fork");
             return 0;
         }
+        signal(SIGCHLD, SIG_DFL);
 
         sleep(1); // Wait for the server socket to be opened
         return pid;
@@ -185,16 +185,16 @@ namespace {
         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();
+        sigtime = senf::ClockService::now();
         senf::scheduler::terminate();
     }
 
@@ -212,9 +212,15 @@ namespace {
         senf::scheduler::terminate();
     }
 
+    unsigned eventCount (0);
+
+    void eventeventhandler()
+    {
+        ++ eventCount;
+    }
 }
 
-BOOST_AUTO_UNIT_TEST(testScheduler)
+void schedulerTest()
 {
     int pid = start_server();
     BOOST_REQUIRE (pid);
@@ -236,11 +242,14 @@ BOOST_AUTO_UNIT_TEST(testScheduler)
 
     ///////////////////////////////////////////////////////////////////////////
 
+    senf::scheduler::EventHook evev ("eventCounter", eventeventhandler, true,
+                                      senf::scheduler::EventHook::PRE);
+
     {
         senf::scheduler::FdEvent fde1 ("testFdEvent", boost::bind(&callback, sock, _1),
                                       sock, senf::scheduler::FdEvent::EV_READ);
         event = senf::scheduler::FdEvent::EV_NONE;
-        BOOST_CHECK_NO_THROW( senf::scheduler::process() );
+        SENF_CHECK_NO_THROW( senf::scheduler::process() );
         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ );
         BOOST_REQUIRE_EQUAL( size, 4 );
         buffer[size]=0;
@@ -252,13 +261,13 @@ BOOST_AUTO_UNIT_TEST(testScheduler)
         strcpy(buffer,"WRITE");
         size=5;
         event = senf::scheduler::FdEvent::EV_NONE;
-        BOOST_CHECK_NO_THROW( senf::scheduler::process() );
+        SENF_CHECK_NO_THROW( senf::scheduler::process() );
         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_WRITE );
 
         SENF_CHECK_NO_THROW( fde2.disable() );
         event = senf::scheduler::FdEvent::EV_NONE;
         sleep(1);
-        BOOST_CHECK_NO_THROW( senf::scheduler::process() );
+        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;
@@ -267,46 +276,49 @@ BOOST_AUTO_UNIT_TEST(testScheduler)
     
     {
         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 = senf::scheduler::FdEvent::EV_NONE;
-        ClockService::clock_type t (ClockService::now());
-        BOOST_CHECK_NO_THROW( senf::scheduler::process() );
-        BOOST_CHECK_PREDICATE( is_close, (ClockService::now()-t) (ClockService::milliseconds(200)) );
+        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, senf::scheduler::FdEvent::EV_NONE );
-        BOOST_CHECK_PREDICATE( is_close, (ClockService::now()) (senf::scheduler::eventTime()) );
+        BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (senf::scheduler::eventTime()) );
         timeoutCalled = false;
-        BOOST_CHECK_NO_THROW( senf::scheduler::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, 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( senf::scheduler::process() );
-        BOOST_CHECK_EQUAL( senf::scheduler::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( senf::scheduler::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( senf::scheduler::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);
@@ -314,6 +326,71 @@ BOOST_AUTO_UNIT_TEST(testScheduler)
     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_