ACE/tests/Timer_Cancellation_Test.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    Timer_Cancellation_Test.cpp
   4  *
   5  *  A test to ensure the timer cancellation works correctly.
   6  *
   7  *  @author Irfan Pyarali <irfan@oomworks.com>
   8  */
   9 //=============================================================================
  10
  11 #include "test_config.h"
  12 #include "ace/OS_NS_unistd.h"
  13 #include "ace/Reactor.h"
  14 #include "ace/TP_Reactor.h"
  15 #include "ace/Task.h"
  16
  17 #if defined (ACE_HAS_THREADS)
  18
  19 class Deadlock : public ACE_Task_Base
  20 {
  21 public:
  22
  23   int svc (void);
  24
  25   int handle_timeout (const ACE_Time_Value &current_time,
  26                       const void *act);
  27 };
  28
  29 int
  30 Deadlock::svc (void)
  31 {
  32   ACE_DEBUG ((LM_DEBUG,
  33               ACE_TEXT ("Deadlock starts accessing Reactor and Timer Queue....\n")));
  34
  35   this->reactor ()->schedule_timer (this,
  36                                     0,
  37                                     ACE_Time_Value (1));
  38
  39   ACE_DEBUG ((LM_DEBUG,
  40               ACE_TEXT ("Deadlock completes accessing Reactor and Timer Queue....\n")));
  41
  42   return 0;
  43 }
  44
  45 int
  46 Deadlock::handle_timeout (const ACE_Time_Value &,
  47                           const void *)
  48 {
  49   ACE_DEBUG ((LM_DEBUG,
  50               ACE_TEXT ("Deadlock timeout\n")));
  51
  52   return 0;
  53 }
  54
  55 class Event_Handler : public ACE_Event_Handler
  56 {
  57 public:
  58
  59   Event_Handler (Deadlock &deadlock);
  60
  61   int handle_timeout (const ACE_Time_Value &current_time,
  62                       const void *act);
  63
  64   int handle_close (ACE_HANDLE handle,
  65                     ACE_Reactor_Mask close_mask);
  66
  67   Deadlock &deadlock_;
  68 };
  69
  70 Event_Handler::Event_Handler (Deadlock &deadlock)
  71   : deadlock_ (deadlock)
  72 {
  73 }
  74
  75 int
  76 Event_Handler::handle_timeout (const ACE_Time_Value &,
  77                                const void *)
  78 {
  79   ACE_DEBUG ((LM_DEBUG,
  80               ACE_TEXT ("Event_Handler timeout\n")));
  81
  82   return -1;
  83 }
  84
  85 int
  86 Event_Handler::handle_close (ACE_HANDLE,
  87                              ACE_Reactor_Mask)
  88 {
  89   ACE_DEBUG ((LM_DEBUG,
  90               ACE_TEXT ("Event_Handler closed\n")));
  91
  92   // Activate Deadlock.
  93   this->deadlock_.activate ();
  94
  95   // Give Deadlock a chance to deadlock... ;-)
  96   ACE_OS::sleep (1);
  97
  98   ACE_DEBUG ((LM_DEBUG,
  99               ACE_TEXT ("Event Handler starts accessing Reactor....\n")));
 100
 101   // This is a superfluous call to the Reactor to acquire its lock.
 102   this->reactor ()->max_notify_iterations ();
 103
 104   ACE_DEBUG ((LM_DEBUG,
 105               ACE_TEXT ("Event Handler completes accessing Reactor....\n")));
 106
 107   return 0;
 108 }
 109
 110 int
 111 run_main (int, ACE_TCHAR *[])
 112 {
 113   ACE_START_TEST (ACE_TEXT ("Timer_Cancellation_Test"));
 114
 115   ACE_Reactor reactor (new ACE_TP_Reactor, true);
 116
 117   Deadlock deadlock;
 118   deadlock.reactor (&reactor);
 119
 120   Event_Handler handler (deadlock);
 121
 122   // Scheduler a timer to kick things off.
 123   reactor.schedule_timer (&handler,
 124                           0,
 125                           ACE_Time_Value (1));
 126
 127   // Run the event loop for a while.
 128   ACE_Time_Value timeout (4);
 129   reactor.run_reactor_event_loop (timeout);
 130
 131   ACE_END_TEST;
 132
 133   return 0;
 134 }
 135
 136 #else /* ACE_HAS_THREADS */
 137
 138 int
 139 run_main (int, ACE_TCHAR *[])
 140 {
 141   ACE_START_TEST (ACE_TEXT ("Timer_Cancellation_Test"));
 142
 143   ACE_ERROR ((LM_INFO,
 144               ACE_TEXT ("threads not supported on this platform\n")));
 145
 146   ACE_END_TEST;
 147
 148   return 0;
 149 }
 150
 151 #endif /* ACE_HAS_THREADS */