TAO/tests/Sequence_Unit_Tests/testing_counters.hpp

   1 #ifndef guard_testing_counters_hpp
   2 #define guard_testing_counters_hpp
   3 /**
   4  * @file
   5  *
   6  * @brief Some unit tests need to count how many times a function is
   7  * called.   Here we implement some simple helper classes for that
   8  * purpose.
   9  *
  10  * @author Carlos O'Ryan
  11  */
  12
  13 #include "testing_exception.hpp"
  14 #include "ace/Copy_Disabled.h"
  15
  16 #include <iostream>
  17
  18 /**
  19  * @brief Used to count how many times a function gets called.  The
  20  *        unit test should create one instance per function.
  21  */
  22 class call_counter
  23 {
  24 public:
  25   inline call_counter()
  26     : count_(0)
  27     , failure_countdown_(0)
  28   {}
  29
  30   inline long current_count() const
  31   {
  32     return count_;
  33   }
  34
  35   inline void failure_countdown(long countdown)
  36   {
  37     failure_countdown_ = countdown;
  38   }
  39
  40   inline void operator()()
  41   {
  42     ++count_;
  43     if (--failure_countdown_ == 0)
  44     {
  45       throw testing_exception();
  46     }
  47   }
  48
  49 private:
  50   long count_;
  51   long failure_countdown_;
  52 };
  53
  54 /**
  55  * @brief Used to detect if a testing_counter is "called" the right
  56  *        number of times.
  57  */
  58 class expected_calls
  59   : private ACE_Copy_Disabled
  60 {
  61 public:
  62   inline expected_calls(call_counter const & counter)
  63     : current_count_(counter.current_count())
  64     , previous_count_(counter.current_count())
  65     , counter_(counter)
  66   { }
  67
  68   inline bool expect(long n)
  69   {
  70     reset();
  71     return (previous_count_ + n == current_count_);
  72   }
  73
  74   inline void reset()
  75   {
  76     previous_count_ = current_count_;
  77     current_count_ = counter_.current_count();
  78   }
  79
  80   inline long current_count() const
  81   {
  82     return current_count_;
  83   }
  84
  85   inline long previous_count() const
  86   {
  87     return previous_count_;
  88   }
  89
  90 private:
  91   long current_count_;
  92   long previous_count_;
  93   call_counter const & counter_;
  94 };
  95
  96 inline std::ostream & operator<<(std::ostream & os, expected_calls const & x)
  97 {
  98   return os << "current=" << x.current_count()
  99             << ",previous=" << x.previous_count();
 100 }
 101
 102 #endif // guard_testing_counters_hpp