ACE/tests/Refcounted_Event_Handler_Test_DevPoll.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Refcounted_Event_Handler_Test_DevPoll.cpp
   5  *
   6  *  This is a simple test that checks the order of dispatching of
   7  *  ACE Reactors.  Order should be: timeout, output, and then input.
   8  *
   9  *  @author Irfan Pyarali <irfan@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "test_config.h"
  15 #include "ace/OS_NS_string.h"
  16 #include "ace/Reactor.h"
  17 #include "ace/Select_Reactor.h"
  18 #include "ace/WFMO_Reactor.h"
  19 #include "ace/Dev_Poll_Reactor.h"
  20 #include "ace/Pipe.h"
  21 #include "ace/ACE.h"
  22
  23
  24
  25 #if defined (ACE_HAS_DEV_POLL) || defined (ACE_HAS_EVENT_POLL)
  26
  27 static const char *message =
  28 "Hello there! Hope you get this message";
  29
  30 class Handler : public ACE_Event_Handler
  31 {
  32 public:
  33   Handler (ACE_Reactor &reactor);
  34
  35   ~Handler();
  36
  37   int handle_timeout (const ACE_Time_Value &tv,
  38                       const void *arg);
  39
  40   int handle_input (ACE_HANDLE fd);
  41
  42   int handle_output (ACE_HANDLE fd);
  43
  44   ACE_HANDLE get_handle (void) const;
  45
  46   // We need to add MSG_OOB data transfer to this test to check the
  47   // order of when <handle_exception> gets called.  I tried with
  48   // Windows 2000 but only one byte of the message came across as
  49   // urgent data.  The rest of the data was treated as normal! There
  50   // was some explanation of Microsoft's TCP/IP deals with out-of-band
  51   // data in "Out-of-Band Data and Push Bit in TCP/IP" in the MSDN
  52   // library.  However, I did not comprehend that well enough.  If
  53   // someone can make this work, please check the order of
  54   // <handle_exception> getting called.
  55   // int handle_exception (ACE_HANDLE fd);
  56
  57   ACE_Pipe pipe_;
  58
  59   int dispatch_order_;
  60   bool ok_;           // Constructed and initialized ok
  61 };
  62
  63 Handler::Handler (ACE_Reactor &reactor)
  64   : ACE_Event_Handler (&reactor),
  65     dispatch_order_ (1),
  66     ok_ (false)
  67 {
  68   // Create the pipe.
  69   if (0 != this->pipe_.open ())
  70     ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("pipe")));
  71   else
  72     {
  73       // Register for all events.
  74       if (0 != this->reactor ()->register_handler
  75                  (this->pipe_.read_handle (),
  76                   this,
  77                   ACE_Event_Handler::READ_MASK | ACE_Event_Handler::WRITE_MASK))
  78         ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("register")));
  79       else
  80         this->ok_ = true;
  81     }
  82 }
  83
  84
  85 Handler::~Handler (void)
  86 {
  87   this->pipe_.close ();
  88 }
  89
  90
  91 ACE_HANDLE
  92 Handler::get_handle (void) const
  93 {
  94   return this->pipe_.read_handle ();
  95 }
  96
  97 int
  98 Handler::handle_timeout (const ACE_Time_Value &,
  99                          const void *)
 100 {
 101   int me = this->dispatch_order_++;
 102   if (me != 1)
 103     ACE_ERROR ((LM_ERROR,
 104                 ACE_TEXT ("handle_timeout should be #1; it's %d\n"),
 105                 me));
 106   else
 107     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Handler::handle_timeout\n")));
 108
 109   return 0;
 110 }
 111
 112 int
 113 Handler::handle_output (ACE_HANDLE)
 114 {
 115   int me = this->dispatch_order_++;
 116   if (me != 2)
 117     ACE_ERROR ((LM_ERROR,
 118                 ACE_TEXT ("handle_output should be #2; it's %d\n"),
 119                 me));
 120   else
 121     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Handler::handle_output\n")));
 122
 123   // Don't want to continually see writeable; only verify its relative order.
 124   this->reactor ()->mask_ops (this->pipe_.read_handle (),
 125                               ACE_Event_Handler::WRITE_MASK,
 126                               ACE_Reactor::CLR_MASK);
 127
 128   return 0;
 129 }
 130
 131 int
 132 Handler::handle_input (ACE_HANDLE fd)
 133 {
 134   int me = this->dispatch_order_++;
 135   if (me != 3)
 136     ACE_ERROR ((LM_ERROR,
 137                 ACE_TEXT ("handle_input should be #3; it's %d\n"),
 138                 me));
 139
 140   char buffer[BUFSIZ];
 141   ssize_t result = ACE::recv (fd, buffer, sizeof buffer);
 142   if (result != ssize_t (ACE_OS::strlen (message)))
 143     ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler recv'd %b bytes; expected %B\n"),
 144                 result, ACE_OS::strlen (message)));
 145   buffer[result] = '\0';
 146
 147   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Handler::handle_input: %C\n"), buffer));
 148
 149   if (ACE_OS::strcmp (buffer, message) != 0)
 150     ACE_ERROR ((LM_ERROR,
 151                 ACE_TEXT ("Handler text mismatch; received \"%C\"; ")
 152                 ACE_TEXT ("expected \"%C\"\n"),
 153                 buffer, message));
 154
 155   this->reactor ()->end_reactor_event_loop ();
 156
 157   return 0;
 158 }
 159
 160 static bool
 161 test_reactor_dispatch_order (ACE_Reactor &reactor)
 162 {
 163   Handler handler (reactor);
 164   if (!handler.ok_)
 165     {
 166       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error initializing test; abort.\n")));
 167       return false;
 168     }
 169
 170   bool ok_to_go = true;
 171
 172   // This should trigger a call to <handle_input>.
 173   ssize_t result =
 174     ACE::send_n (handler.pipe_.write_handle (),
 175                  message,
 176                  ACE_OS::strlen (message));
 177   if (result != ssize_t (ACE_OS::strlen (message)))
 178     {
 179       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler sent %b bytes; should be %B\n"),
 180                   result, ACE_OS::strlen (message)));
 181       ok_to_go = false;
 182     }
 183
 184   // This should trigger a call to <handle_timeout>.
 185   if (-1 == reactor.schedule_timer (&handler,
 186                                     0,
 187                                     ACE_Time_Value (0)))
 188     {
 189       ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer")));
 190       ok_to_go = false;
 191     }
 192
 193   // Suspend the handlers - only the timer should be dispatched
 194   ACE_Time_Value tv (1);
 195   reactor.suspend_handlers ();
 196   reactor.run_reactor_event_loop (tv);
 197
 198   // only the timer should have fired
 199   if (handler.dispatch_order_ != 2)
 200     {
 201       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Incorrect number fired %d\n"),
 202                   handler.dispatch_order_));
 203       ok_to_go = false;
 204     }
 205
 206   // Reset the dispatch_order_ count and schedule another timer
 207   handler.dispatch_order_ = 1;
 208   if (-1 == reactor.schedule_timer (&handler,
 209                                     0,
 210                                     ACE_Time_Value (0)))
 211     {
 212       ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer")));
 213       ok_to_go = false;
 214     }
 215
 216   // Resume the handlers - things should work now
 217   reactor.resume_handlers ();
 218
 219   if (ok_to_go)
 220     {
 221       reactor.run_reactor_event_loop (tv);
 222     }
 223
 224   if (0 != reactor.remove_handler (handler.pipe_.read_handle (),
 225                                    ACE_Event_Handler::ALL_EVENTS_MASK |
 226                                    ACE_Event_Handler::DONT_CALL))
 227     ACE_ERROR ((LM_ERROR,
 228                 ACE_TEXT ("%p\n"),
 229                 ACE_TEXT ("remover_handler pipe")));
 230
 231   if (handler.dispatch_order_ != 4)
 232     {
 233       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Incorrect number fired %d\n"),
 234                   handler.dispatch_order_));
 235       ok_to_go = false;
 236     }
 237
 238   return ok_to_go;
 239 }
 240
 241 int
 242 run_main (int, ACE_TCHAR *[])
 243 {
 244   ACE_START_TEST (ACE_TEXT ("Refcounted_Event_Handler_Test_DevPoll"));
 245   int result = 0;
 246
 247   ACE_Dev_Poll_Reactor dev_poll_reactor_impl;
 248   ACE_Reactor dev_poll_reactor (&dev_poll_reactor_impl);
 249   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing Dev Poll Reactor\n")));
 250   if (!test_reactor_dispatch_order (dev_poll_reactor))
 251     ++result;
 252
 253   ACE_END_TEST;
 254   return result;
 255 }
 256 #else
 257 int
 258 run_main (int, ACE_TCHAR *[])
 259 {
 260   ACE_START_TEST (ACE_TEXT ("Refcounted_Event_Handler_Test_DevPoll"));
 261   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Dev_Poll_Reactor is UNSUPPORTED on this platform\n")));
 262   ACE_END_TEST;
 263   return 0;
 264 }
 265 #endif /* ACE_HAS_DEV_POLL || ACE_HAS_EVENT_POLL */