ACE/examples/Reactor/WFMO_Reactor/Suspended_Removals.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    Suspended_Removals.cpp
   4  *
   5  *  Tests the Reactor's ability to handle removal of suspended
   6  *  handles.
   7  *
   8  *  @author Irfan Pyarali
   9  */
  10 //=============================================================================
  11
  12
  13 #include "ace/OS_main.h"
  14
  15 #if defined (ACE_WIN32)
  16
  17 #include "ace/Reactor.h"
  18 #include "ace/WFMO_Reactor.h"
  19
  20 class Event_Handler : public ACE_Event_Handler
  21 {
  22 public:
  23   ACE_HANDLE get_handle () const
  24   {
  25     return this->event_.handle ();
  26   }
  27
  28   ACE_Event event_;
  29 };
  30
  31 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  32
  33 class ACE_WFMO_Reactor_Test
  34 {
  35 public:
  36   static void check_for_valid_state (ACE_WFMO_Reactor &wfmo_reactor,
  37                                      size_t handles_to_be_added,
  38                                      size_t handles_to_be_suspended,
  39                                      size_t handles_to_be_resumed,
  40                                      size_t handles_to_be_deleted)
  41   {
  42     ACE_TEST_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_added_ == handles_to_be_added);
  43     ACE_TEST_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_suspended_ == handles_to_be_suspended);
  44     ACE_TEST_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_resumed_ == handles_to_be_resumed);
  45     ACE_TEST_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_deleted_ == handles_to_be_deleted);
  46   }
  47 };
  48
  49 ACE_END_VERSIONED_NAMESPACE_DECL
  50
  51 int
  52 ACE_TMAIN (int, ACE_TCHAR *[])
  53 {
  54   Event_Handler handler;
  55   ACE_WFMO_Reactor reactor;
  56   ACE_Reactor base_reactor (&reactor);
  57
  58   ACE_Time_Value sleep_time (1);
  59
  60   int result =
  61     reactor.register_handler (&handler);
  62   ACE_TEST_ASSERT (result == 0);
  63
  64   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
  65                                                 1, 0, 0, 0);
  66
  67   result =
  68     reactor.remove_handler (&handler,
  69                             ACE_Event_Handler::DONT_CALL |
  70                             ACE_Event_Handler::ALL_EVENTS_MASK);
  71   ACE_TEST_ASSERT (result == 0);
  72
  73   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
  74                                                 1, 0, 0, 1);
  75
  76   result = base_reactor.run_reactor_event_loop (sleep_time);
  77   ACE_TEST_ASSERT (result != -1);
  78
  79   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
  80                                                 0, 0, 0, 0);
  81
  82   result =
  83     reactor.register_handler (&handler);
  84   ACE_TEST_ASSERT (result == 0);
  85
  86   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
  87                                                 1, 0, 0, 0);
  88
  89   result = base_reactor.run_reactor_event_loop (sleep_time);
  90   ACE_TEST_ASSERT (result != -1);
  91
  92   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
  93                                                 0, 0, 0, 0);
  94
  95   result =
  96     reactor.suspend_handler (&handler);
  97   ACE_TEST_ASSERT (result == 0);
  98
  99   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 100                                                 0, 1, 0, 0);
 101
 102   result =
 103     reactor.remove_handler (&handler,
 104                             ACE_Event_Handler::DONT_CALL |
 105                             ACE_Event_Handler::ALL_EVENTS_MASK);
 106   ACE_TEST_ASSERT (result == 0);
 107
 108   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 109                                                 0, 0, 0, 1);
 110
 111   result = base_reactor.run_reactor_event_loop (sleep_time);
 112   ACE_TEST_ASSERT (result != -1);
 113
 114   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 115                                                 0, 0, 0, 0);
 116
 117   result =
 118     reactor.register_handler (&handler);
 119   ACE_TEST_ASSERT (result == 0);
 120
 121   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 122                                                 1, 0, 0, 0);
 123
 124   result =
 125     reactor.suspend_handler (&handler);
 126   ACE_TEST_ASSERT (result == 0);
 127
 128   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 129                                                 1, 1, 0, 0);
 130
 131   result = base_reactor.run_reactor_event_loop (sleep_time);
 132   ACE_TEST_ASSERT (result != -1);
 133
 134   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 135                                                 0, 0, 0, 0);
 136
 137   result =
 138     reactor.resume_handler (&handler);
 139   ACE_TEST_ASSERT (result == 0);
 140
 141   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 142                                                 0, 0, 1, 0);
 143
 144   result =
 145     reactor.remove_handler (&handler,
 146                             ACE_Event_Handler::DONT_CALL |
 147                             ACE_Event_Handler::ALL_EVENTS_MASK);
 148   ACE_TEST_ASSERT (result == 0);
 149
 150   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 151                                                 0, 0, 0, 1);
 152
 153   result = base_reactor.run_reactor_event_loop (sleep_time);
 154   ACE_TEST_ASSERT (result != -1);
 155
 156   ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
 157                                                 0, 0, 0, 0);
 158
 159   return 0;
 160 }
 161 #else /* !ACE_WIN32 */
 162 int
 163 ACE_TMAIN (int , ACE_TCHAR *[])
 164 {
 165   return 0;
 166 }
 167 #endif /* ACE_WIN32 */