ACE/tests/Bug_1890_Regression_Test.cpp

   1 /**
   2  * @file Bug_1890_Regression_Test.cpp
   3  *
   4  * Reproduces the problems reported in bug 1890
   5  *   http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=1890
   6  *
   7  * @author Carlos O'Ryan <coryan@atdesk.com>
   8  * Based on a test provided by "Vadim" (no further details available)
   9  */
  10
  11 #include "test_config.h"
  12
  13 #include "ace/Pipe.h"
  14 #include "ace/Event_Handler.h"
  15 #include "ace/Reactor.h"
  16 #include "ace/Select_Reactor.h"
  17 #include <memory>
  18
  19 int const nhandlers = 3;
  20
  21 /**
  22  * This class is used to create real I/O in the test.  To keep the I/O under
  23  * control and keep the test to a single process we use ACE_Pipe.  This class
  24  * is known to work with the Reactor, in fact, that is its main function.
  25  *
  26  * Handler counts how many calls to handle_input() has the reactor performed.
  27  * When bug 1890 is triggered the Reactor continues to call the timers, but it
  28  * stops calling select() and the handle_input() functions.
  29  */
  30 class Handler : public ACE_Event_Handler
  31 {
  32 public:
  33     Handler();
  34
  35     //FUZZ: disable check_for_lack_ACE_OS
  36     /// Initialize the pipe and register with the reactor
  37     int open(ACE_Reactor * reactor);
  38     //FUZZ: enable check_for_lack_ACE_OS
  39
  40     /// Return the current count
  41     size_t handle_input_count() const;
  42
  43     /// Write some data
  44     void send_dummy_data();
  45
  46     /// Reactor callback
  47     ACE_HANDLE get_handle() const override;
  48     int handle_input(ACE_HANDLE) override;
  49
  50 private:
  51     size_t handle_input_count_;
  52
  53     ACE_Pipe the_pipe_;
  54
  55     ACE_HANDLE handles_[2];
  56 };
  57
  58 /**
  59  * This is the main driver for the test.  This timer is called by the reactor
  60  * in a repeating interval.  On the first @c initial_iterations the Timer
  61  * writes data through all of its handlers.  On iteration @c initial_iteration
  62  * it triggers bug 1890 by removing all the handlers from the reactor, and
  63  * then re-adding one handler.
  64  */
  65 class Timer : public ACE_Event_Handler
  66 {
  67 public:
  68     Timer();
  69
  70     //FUZZ: disable check_for_lack_ACE_OS
  71     int open(ACE_Reactor * reactor);
  72     void close();
  73     //FUZZ: enable check_for_lack_ACE_OS
  74
  75     bool check_expected_results() const;
  76
  77     int handle_timeout(ACE_Time_Value const &, void const*) override;
  78
  79 private:
  80     void send_data_through_handlers();
  81     void remove_some_handlers();
  82
  83     Handler & special_handler();
  84     Handler const & special_handler() const;
  85
  86 private:
  87     Handler handler_[nhandlers];
  88     int iteration_;
  89
  90     size_t recorded_count_;
  91 };
  92
  93 int
  94 run_main (int, ACE_TCHAR *[])
  95 {
  96   ACE_START_TEST (ACE_TEXT ("Bug_1890_Regression_Test"));
  97
  98   bool success = true;
  99
 100   // Bug 1890 is all about ACE_Select_Reactor, so run it on that reactor
 101   // regardless of platform.
 102   ACE_Select_Reactor *impl_ptr = 0;
 103   ACE_NEW_RETURN (impl_ptr, ACE_Select_Reactor, -1);
 104   std::unique_ptr<ACE_Select_Reactor> auto_impl (impl_ptr);
 105
 106   ACE_Reactor reactor (impl_ptr);
 107
 108   // Create the timer, this is the main driver for the test
 109   Timer * timer = new Timer;
 110
 111   // Initialize the timer and register with the reactor
 112   if (-1 == timer->open (&reactor))
 113     {
 114       ACE_ERROR_RETURN ((LM_ERROR,
 115                          ACE_TEXT ("%p\n"),
 116                          ACE_TEXT ("Cannot initialize timer")),
 117                         -1);
 118     }
 119
 120   reactor.run_reactor_event_loop ();
 121
 122   // Verify that the results are what we expect
 123   if (!(success = timer->check_expected_results ()))
 124     ACE_ERROR ((LM_ERROR, ACE_TEXT ("Test failed\n")));
 125
 126   // Cleanup
 127   timer->close ();
 128   delete timer;
 129
 130   ACE_END_TEST;
 131
 132   return success ? 0 : -1;
 133 }
 134
 135 Handler::Handler()
 136     : handle_input_count_(0)
 137     , the_pipe_()
 138 {
 139 }
 140
 141 int
 142 Handler::open (ACE_Reactor * r)
 143 {
 144   if (-1 == the_pipe_.open (handles_))
 145     {
 146       return -1;
 147     }
 148   if (-1 == r->register_handler (this, ACE_Event_Handler::READ_MASK))
 149     {
 150       return -1;
 151     }
 152   return 0;
 153 }
 154
 155 size_t
 156 Handler::handle_input_count() const
 157 {
 158   return handle_input_count_;
 159 }
 160
 161 void
 162 Handler::send_dummy_data()
 163 {
 164   char buf[] = "dummy";
 165   (void) the_pipe_.send (buf, sizeof (buf));
 166 }
 167
 168 ACE_HANDLE
 169 Handler::get_handle() const
 170 {
 171   return the_pipe_.read_handle ();
 172 }
 173
 174 int
 175 Handler::handle_input(ACE_HANDLE)
 176 {
 177   ++handle_input_count_;
 178   // ACE_DEBUG((LM_DEBUG, "Handler::handle_input called for %d\n", h));
 179   return 0;
 180 }
 181
 182 int const initial_iterations = 5;
 183 int const total_iterations = 10;
 184
 185 int const special_handler_index = nhandlers - 1;
 186
 187 Timer::Timer()
 188     : iteration_(0)
 189     , recorded_count_(0)
 190 {
 191 }
 192
 193 int
 194 Timer::open (ACE_Reactor * r)
 195 {
 196   this->reactor (r);
 197
 198   // Initialize both handles and register them with the reactor for reading.
 199   for (int i = 0; i != nhandlers; ++i)
 200     {
 201       if (-1 == handler_[i].open (r))
 202         {
 203           ACE_ERROR_RETURN ((LM_ERROR,
 204                              ACE_TEXT ("Could not open dummy handler %d %p\n"),
 205                              i,
 206                              ACE_TEXT ("")),
 207                             -1);
 208         }
 209     }
 210
 211   ACE_Time_Value const interval(0, ACE_ONE_SECOND_IN_USECS / 10);
 212   ACE_Time_Value const startup (0, ACE_ONE_SECOND_IN_USECS / 20);
 213
 214   if (-1 == r->schedule_timer (this, 0, startup, interval))
 215     {
 216       ACE_ERROR_RETURN ((LM_ERROR,
 217                          ACE_TEXT ("%p\n"),
 218                          ACE_TEXT ("Could not schedule timer")),
 219                         -1);
 220     }
 221
 222   return 0;
 223 }
 224
 225 void
 226 Timer::close()
 227 {
 228   for (int i = 0; i != nhandlers; ++i)
 229     {
 230       this->reactor ()->remove_handler (&handler_[i],
 231                                         ACE_Event_Handler::ALL_EVENTS_MASK |
 232                                         ACE_Event_Handler::DONT_CALL);
 233     }
 234   this->reactor ()->cancel_timer (this);
 235 }
 236
 237 bool
 238 Timer::check_expected_results() const
 239 {
 240   if (this->recorded_count_ < this->special_handler ().handle_input_count ())
 241     {
 242       return true;
 243     }
 244   ACE_ERROR ((LM_ERROR,
 245               ACE_TEXT ("recorded_count %B, special_handler count %B\n"),
 246               this->recorded_count_,
 247               this->special_handler ().handle_input_count ()));
 248   return false;
 249 }
 250
 251 int
 252 Timer::handle_timeout(ACE_Time_Value const &, void const *)
 253 {
 254   if (iteration_ == 0)
 255     {
 256       send_data_through_handlers();
 257     }
 258
 259   ++iteration_;
 260   if (iteration_ < initial_iterations)
 261     {
 262       return 0;
 263     }
 264
 265   if (iteration_ == initial_iterations)
 266     {
 267       remove_some_handlers();
 268       recorded_count_  = special_handler().handle_input_count();
 269       return 0;
 270     }
 271
 272   if (iteration_ < total_iterations)
 273     {
 274       return 0;
 275     }
 276
 277   reactor()->end_reactor_event_loop();
 278
 279   return 0;
 280 }
 281
 282 void
 283 Timer::send_data_through_handlers()
 284 {
 285   for (int i = 0; i != nhandlers; ++i)
 286     {
 287       handler_[i].send_dummy_data();
 288     }
 289 }
 290
 291 void
 292 Timer::remove_some_handlers()
 293 {
 294   // The reactor may not get around to callbacks on deletion until the test
 295   // is over.
 296   ACE_Reactor_Mask mask =
 297     ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL;
 298   for (int i = 0; i != nhandlers; ++i)
 299     {
 300       if (-1 == reactor()->remove_handler(&handler_[i], mask))
 301         {
 302           ACE_ERROR ((LM_ERROR,
 303                       ACE_TEXT ("Cannot remove handler %d in %p\n"),
 304                       i,
 305                       ACE_TEXT ("timeout")));
 306         }
 307     }
 308
 309   if (-1 == reactor()->register_handler(&special_handler(),
 310                                         ACE_Event_Handler::ALL_EVENTS_MASK))
 311     {
 312       ACE_ERROR ((LM_ERROR,
 313                   ACE_TEXT ("Cannot add back special handler in %p\n"),
 314                   ACE_TEXT ("timeout")));
 315     }
 316 }
 317
 318 Handler & Timer::special_handler()
 319 {
 320   return handler_[special_handler_index];
 321 }
 322
 323 Handler const & Timer::special_handler() const
 324 {
 325   return handler_[special_handler_index];
 326 }