TAO/tests/Sequence_Iterators/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
  15 #include <boost/utility.hpp>
  16
  17 #include <iostream>
  18
  19 /**
  20  * @brief Used to count how many times a function gets called.  The
  21  *        unit test should create one instance per function.
  22  */
  23 class call_counter
  24 {
  25 public:
  26   inline call_counter()
  27     : count_(0)
  28     , failure_countdown_(0)
  29   {}
  30
  31   inline long current_count() const
  32   {
  33     return count_;
  34   }
  35
  36   inline void failure_countdown(long countdown)
  37   {
  38     failure_countdown_ = countdown;
  39   }
  40
  41   inline void operator()()
  42   {
  43     ++count_;
  44     if (--failure_countdown_ == 0)
  45     {
  46       throw testing_exception();
  47     }
  48   }
  49
  50 private:
  51   long count_;
  52   long failure_countdown_;
  53 };
  54
  55 /**
  56  * @brief Used to detect if a testing_counter is "called" the right
  57  *        number of times.
  58  */
  59 class expected_calls
  60   : private boost::noncopyable
  61 {
  62 public:
  63   inline expected_calls(call_counter const & counter)
  64     : current_count_(counter.current_count())
  65     , previous_count_(counter.current_count())
  66     , counter_(counter)
  67   { }
  68
  69   inline bool expect(long n)
  70   {
  71     reset();
  72     return (previous_count_ + n == current_count_);
  73   }
  74
  75   inline void reset()
  76   {
  77     previous_count_ = current_count_;
  78     current_count_ = counter_.current_count();
  79   }
  80
  81   inline long current_count() const
  82   {
  83     return current_count_;
  84   }
  85
  86   inline long previous_count() const
  87   {
  88     return previous_count_;
  89   }
  90
  91 private:
  92   long current_count_;
  93   long previous_count_;
  94   call_counter const & counter_;
  95 };
  96
  97 inline std::ostream & operator<<(std::ostream & os, expected_calls const & x)
  98 {
  99   return os << "current=" << x.current_count()
 100             << ",previous=" << x.previous_count();
 101
 102 }
 103
 104 #endif // guard_testing_counters_hpp