X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Scheduler%2FScheduler.test.cc;h=c8dc0b4195ac311ae8fb9796879fc388d75b9a2e;hb=79e54eda6a7fb5ac3fa5b37f408dd386454c5bbd;hp=6665f6e5dc13d3873b4d37fd475c400ea0e865d6;hpb=ac6a813d9d99f7add4e13aff7a4bcd314d5604a6;p=senf.git

diff --git a/Scheduler/Scheduler.test.cc b/Scheduler/Scheduler.test.cc
index 6665f6e..c8dc0b4 100644
--- a/Scheduler/Scheduler.test.cc
+++ b/Scheduler/Scheduler.test.cc
@@ -1,9 +1,10 @@
+
 // $Id$
 //
-// Copyright (C) 2006 
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
-//     Stefan Bund <stefan.bund@fokus.fraunhofer.de>
+// Copyright (C) 2006
+// Fraunhofer Institute for Open Communication Systems (FOKUS)
+// Competence Center NETwork research (NET), St. Augustin, GERMANY
+//     Stefan Bund <g0dil@berlios.de>
 //
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -35,10 +36,11 @@
 #include <errno.h>
 #include <string.h>
 #include <iostream>
+#include <boost/bind.hpp>
 
 #include "Scheduler.hh"
 
-#include <boost/test/auto_unit_test.hpp>
+#include "../Utils/auto_unit_test.hh"
 #include <boost/test/test_tools.hpp>
 
 #define prefix_
@@ -47,9 +49,9 @@
 using namespace senf;
 
 namespace {
-    
+
     char const * SOCK_PATH = "/tmp/sched_test.sock";
-    
+
     void error(char const * fn, char const * proc="")
     {
         std::cerr << "\n" << proc << fn << ": " << strerror(errno) << std::endl;
@@ -100,6 +102,7 @@ namespace {
         unlink(SOCK_PATH);
         int pid = fork();
         if (pid == 0) {
+            signal(SIGCHLD, SIG_IGN);
             server();
             _exit(0);
         }
@@ -107,7 +110,8 @@ namespace {
             error("fork");
             return 0;
         }
-            
+        signal(SIGCHLD, SIG_DFL);
+
         sleep(1); // Wait for the server socket to be opened
         return pid;
     }
@@ -140,35 +144,30 @@ namespace {
     int size;
     int event;
 
-    void callback(int fd, Scheduler::EventId ev)
+    void callback(int fd, int ev)
     {
         event = ev;
-        switch (event) {
-        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;
-        case Scheduler::EV_HUP:
-        case Scheduler::EV_ERR:
-        case Scheduler::EV_NONE:
-        case Scheduler::EV_ALL:
-            ;
         }
-        Scheduler::instance().terminate();
+        senf::scheduler::terminate();
     }
 
-    void timeout() 
+    bool timeoutCalled = false;
+    void timeout()
     {
-	Scheduler::instance().terminate();
+        timeoutCalled = true;
+        senf::scheduler::terminate();
     }
-     
+
     struct HandleWrapper
     {
         HandleWrapper(int fd,std::string const & tag) : fd_(fd), tag_(tag) {}
@@ -181,21 +180,49 @@ namespace {
         return handle.fd_;
     }
 
-    void handleCallback(HandleWrapper const & handle, Scheduler::EventId event)
+    void handleCallback(HandleWrapper const & handle, int event)
     {
         if (handle.tag_ != "TheTag")
             return;
         callback(handle.fd_,event);
     }
 
-    bool is_close(MicroTime a, MicroTime b)
+    bool is_close(ClockService::clock_type a, ClockService::clock_type b)
+    {
+        return (a<b ? b-a : a-b) < ClockService::milliseconds(100);
+    }
+    
+    ClockService::clock_type sigtime (0);
+
+    void sigusr(siginfo_t const &)
+    {
+        sigtime = ClockService::now();
+        senf::scheduler::terminate();
+    }
+
+    void delay(unsigned long milliseconds)
+    {
+        struct timespec ts;
+        ts.tv_sec = milliseconds / 1000;
+        ts.tv_nsec = (milliseconds % 1000) * 1000000;
+        while (nanosleep(&ts,&ts) < 0 && errno == EINTR) ;
+    }
+
+    void blockingHandler()
+    {
+        delay(2200);
+        senf::scheduler::terminate();
+    }
+
+    unsigned eventCount (0);
+
+    void eventeventhandler()
     {
-	return (a<b ? b-a : a-b) < 10100; // a little bit over 10ms
+        ++ eventCount;
     }
-	    
 }
 
-BOOST_AUTO_UNIT_TEST(scheduler)
+BOOST_AUTO_UNIT_TEST(testScheduler)
 {
     int pid = start_server();
     BOOST_REQUIRE (pid);
@@ -209,7 +236,7 @@ BOOST_AUTO_UNIT_TEST(scheduler)
     memset(&sun,0,sizeof(sun));
     sun.sun_family = AF_UNIX;
     strcpy(sun.sun_path,SOCK_PATH);
-    
+
     if (connect(sock,(struct sockaddr*)&sun,sizeof(sun))<0) {
         error("connect");
         BOOST_FAIL("connect");
@@ -217,39 +244,81 @@ BOOST_AUTO_UNIT_TEST(scheduler)
 
     ///////////////////////////////////////////////////////////////////////////
 
-    BOOST_CHECK_NO_THROW( Scheduler::instance() );
-
-    BOOST_CHECK_NO_THROW( Scheduler::instance().add(sock,&callback,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" );
-
-    BOOST_CHECK_NO_THROW( Scheduler::instance().timeout(100,&timeout) );
-    BOOST_CHECK_NO_THROW( Scheduler::instance().timeout(200,&timeout) );
-    MicroTime t (now());
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_PREDICATE( is_close, (now()) (t+100*1000) );
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_PREDICATE( is_close, (now()) (t+200*1000) );
+    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() );
+        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" );
+    }
     
-    HandleWrapper handle(sock,"TheTag");
-    BOOST_CHECK_NO_THROW( Scheduler::instance().add(handle,&handleCallback,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;
-    BOOST_CHECK_NO_THROW( Scheduler::instance().process() );
-    BOOST_CHECK_EQUAL( event, Scheduler::EV_READ );
-    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() ); 
+    } 
+
+    BOOST_CHECK_EQUAL( eventCount, 8u );
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ -264,5 +333,10 @@ BOOST_AUTO_UNIT_TEST(scheduler)
 
 // Local Variables:
 // mode: c++
+// fill-column: 100
 // c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// comment-column: 40
 // End: