X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Scheduler%2FScheduler.test.cc;h=e270b060374a306ad02ca70b9b7761556fc24661;hb=989a3b185a4e8854a1a1a01c5b190c9e6dcaf2af;hp=b45b1a3cdb6fcf91f874085afda3eb916db227eb;hpb=d785ab5820076da44b4a71b05cc231ef7e97c7bf;p=senf.git

diff --git a/Scheduler/Scheduler.test.cc b/Scheduler/Scheduler.test.cc
index b45b1a3..e270b06 100644
--- a/Scheduler/Scheduler.test.cc
+++ b/Scheduler/Scheduler.test.cc
@@ -36,6 +36,7 @@
 #include <errno.h>
 #include <string.h>
 #include <iostream>
+#include <boost/bind.hpp>
 
 #include "Scheduler.hh"
 
@@ -144,27 +145,25 @@ namespace {
     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
@@ -196,7 +195,7 @@ namespace {
     void sigusr(siginfo_t const &)
     {
         sigtime = ClockService::now();
-        Scheduler::instance().terminate();
+        senf::scheduler::terminate();
     }
 
     void delay(unsigned long milliseconds)
@@ -210,7 +209,7 @@ namespace {
     void blockingHandler()
     {
         delay(2200);
-        Scheduler::instance().terminate();
+        senf::scheduler::terminate();
     }
 
 }
@@ -237,69 +236,76 @@ BOOST_AUTO_UNIT_TEST(testScheduler)
 
     ///////////////////////////////////////////////////////////////////////////
 
-    BOOST_CHECK_NO_THROW( Scheduler::instance() );
-
-    BOOST_CHECK_NO_THROW( Scheduler::instance().add(sock,boost::bind(&callback, sock, _1),
-                                                    Scheduler::EV_READ) );
-    event = Scheduler::EV_NONE;
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_EQUAL( event, Scheduler::EV_READ );
-    BOOST_REQUIRE_EQUAL( size, 4 );
-    buffer[size]=0;
-    BOOST_CHECK_EQUAL( buffer, "READ" );
-
-    event = Scheduler::EV_NONE;
-    BOOST_CHECK_NO_THROW( Scheduler::instance().timeout(
-                              ClockService::now()+ClockService::milliseconds(200),&timeout) );
-    BOOST_CHECK_NO_THROW( Scheduler::instance().timeout(
-                              ClockService::now()+ClockService::milliseconds(400),&timeout) );
-    ClockService::clock_type t (ClockService::now());
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_PREDICATE( is_close, (ClockService::now()-t) (ClockService::milliseconds(200)) );
-    BOOST_CHECK( timeoutCalled );
-    BOOST_CHECK_EQUAL( event, Scheduler::EV_NONE );
-    BOOST_CHECK_PREDICATE( is_close, (ClockService::now()) (Scheduler::instance().eventTime()) );
-    timeoutCalled = false;
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_PREDICATE( is_close, (ClockService::now()-t) (ClockService::milliseconds(400)) );
-    BOOST_CHECK( timeoutCalled );
-    BOOST_CHECK_EQUAL( event, Scheduler::EV_NONE );
-
-    BOOST_CHECK_NO_THROW( Scheduler::instance().timeout(ClockService::now(), &blockingHandler) );
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_EQUAL( Scheduler::instance().hangCount(), 1u );
-
-    HandleWrapper handle(sock,"TheTag");
-    BOOST_CHECK_NO_THROW( Scheduler::instance().add(handle,
-                                                    boost::bind(&handleCallback,handle,_1),
-                                                    Scheduler::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 );
-
-    BOOST_CHECK_NO_THROW( Scheduler::instance().remove(handle,Scheduler::EV_WRITE) );
-    event = Scheduler::EV_NONE;
-    sleep(1);
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_EQUAL( event, Scheduler::EventId(Scheduler::EV_READ|Scheduler::EV_HUP) );
-    BOOST_REQUIRE_EQUAL( size, 2 );
-    buffer[size]=0;
-    BOOST_CHECK_EQUAL( buffer, "OK" );
-    BOOST_CHECK_NO_THROW( Scheduler::instance().remove(handle) );
-
-    unsigned tid (Scheduler::instance().timeout(
-                      ClockService::now()+ClockService::milliseconds(400),&timeout));
-    BOOST_CHECK_NO_THROW( Scheduler::instance().registerSignal(SIGUSR1, &sigusr) );
-    t = 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)) );
-    Scheduler::instance().cancelTimeout(tid);
-    BOOST_CHECK_NO_THROW( Scheduler::instance().unregisterSignal(SIGUSR1) );
+    {
+        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() );
+        BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ );
+        BOOST_REQUIRE_EQUAL( size, 4 );
+        buffer[size]=0;
+        BOOST_CHECK_EQUAL( buffer, "READ" );
+
+        HandleWrapper handle(sock,"TheTag");
+        senf::scheduler::FdEvent fde2 ("testFdEvent", boost::bind(&handleCallback,handle,_1),
+                                      handle, senf::scheduler::FdEvent::EV_WRITE);
+        strcpy(buffer,"WRITE");
+        size=5;
+        event = senf::scheduler::FdEvent::EV_NONE;
+        BOOST_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() );
+        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::scheduler::TimerEvent timer2 ("testTimer2", &timeout,
+                                            ClockService::now()+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)) );
+        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()) );
+        timeoutCalled = false;
+        BOOST_CHECK_NO_THROW( senf::scheduler::process() );
+        BOOST_CHECK_PREDICATE( is_close, (ClockService::now()-t) (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 );
+    }
+
+    {
+        senf::scheduler::TimerEvent timer ("testWatchdog", &timeout,
+                                           ClockService::now()+ClockService::milliseconds(400));
+        senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
+
+        ClockService::clock_type t = 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() ); 
+    } 
 
     ///////////////////////////////////////////////////////////////////////////