(tests): написал тесты для класса CallbackTimer. Переименовал его

include/CallBackTimer.h → include/CallbackTimer.h

@@ -21,8 +21,8 @@
  *  \author Pavel Vainerman
 */
 //----------------------------------------------------------------------------
-# ifndef CallBackTimer_H_
-# define CallBackTimer_H_
+# ifndef CallbackTimer_H_
+# define CallbackTimer_H_
 //----------------------------------------------------------------------------
 #include <list>
 #include "Exceptions.h"
@@ -45,7 +45,7 @@ namespace UniSetTypes
             /*! Конструктор позволяющий вывести в сообщении об ошибке дополнительную информацию err */
             LimitTimers(const std::string& err):Exception(err){ printException(); }
     };
-};
+}
 //@}
 // end of UniSetException group
 //----------------------------------------------------------------------------------------
@@ -54,9 +54,9 @@ namespace UniSetTypes
  * \brief Таймер 
  * \author Pavel Vainerman
  * \par
- * Создает поток, в котором происходит отсчет тактов (10ms). Позволяет заказывать до CallBackTimer::MAXCallBackTimer таймеров.
+ * Создает поток, в котором происходит отсчет тактов (10ms). Позволяет заказывать до CallbackTimer::MAXCallbackTimer таймеров.
  * При срабатывании будет вызвана указанная функция с указанием \b Id таймера, который сработал. 
- * Функция обратного вызова должна удовлетворять шаблону CallBackTimer::Action.
+ * Функция обратного вызова должна удовлетворять шаблону CallbackTimer::Action.
  * Пример создания таймера:
  *
     \code
@@ -68,29 +68,29 @@ namespace UniSetTypes
 
         MyClass* rec = new MyClass();
          ...
-         CallBackTimer<MyClass> *timer1 = new CallBackTimer<MyClass>(rec);
+         CallbackTimer<MyClass> *timer1 = new CallbackTimer<MyClass>(rec);
         timer1->add(1, &MyClass::Time, 1000);
         timer1->add(5, &MyClass::Time, 1200);
         timer1->run();
     \endcode
  *
- * \note Каждый экземпляр класса CallBackTimer создает поток, поэтому \b желательно не создавать больше одного экземпляра,
+ * \note Каждый экземпляр класса CallbackTimer создает поток, поэтому \b желательно не создавать больше одного экземпляра,
  * для одного процесса (чтобы не порождать много потоков).
 */ 
 template <class Caller>
-class CallBackTimer
+class CallbackTimer
 //    public PassiveTimer
 { 
     public:
 
         /*! Максимальное количество таймеров */
-        static const int MAXCallBackTimer = 20;
+        static const int MAXCallbackTimer = 20;
 
         /*! прототип функции вызова */
         typedef void(Caller::* Action)( int id );
 
-        CallBackTimer(Caller* r, Action a);
-        ~CallBackTimer();
+        CallbackTimer(Caller* r, Action a);
+        ~CallbackTimer();
 
         // Управление таймером
         void run();        /*!< запуск таймера */
@@ -108,7 +108,7 @@ class CallBackTimer
 
     protected:
 
-        CallBackTimer();
+        CallbackTimer();
         void work();
 
         void startTimers();
@@ -116,7 +116,7 @@ class CallBackTimer
 
     private:
 
-        typedef CallBackTimer<Caller> CBT;
+        typedef CallbackTimer<Caller> CBT;
         friend class ThreadCreator<CBT>;
         Caller* cal;
         Action act;
@@ -137,7 +137,7 @@ class CallBackTimer
         TimersList lst;
 
         // функция-объект для поиска по id
-        struct FindId_eq: public unary_function<TimerInfo, bool>
+        struct FindId_eq: public std::unary_function<TimerInfo, bool>
         {
             FindId_eq(const int id):id(id){}
             inline bool operator()(const TimerInfo& ti) const{return ti.id==id;}
@@ -145,5 +145,5 @@ class CallBackTimer
         };
 };
 
-#include "CallBackTimer.tcc"
-# endif //CallBackTimer_H_
+#include "CallbackTimer.tcc"
+# endif //CallbackTimer_H_

include/CallBackTimer.tcc → include/CallbackTimer.tcc

@@ -21,41 +21,41 @@
  *  \author Pavel Vainerman
 */
 // -------------------------------------------------------------------------- 
-# ifndef CallBackTimer_TCC_H_
-# define CallBackTimer_TCC_H_
+# ifndef CallbackTimer_TCC_H_
+# define CallbackTimer_TCC_H_
 // -------------------------------------------------------------------------- 
 #include <unistd.h>
 #include <sstream>
-#include "CallBackTimer.h"
+#include "CallbackTimer.h"
 
 // ------------------------------------------------------------------------------------------
-template <class Caller> class CallBackTimer;
+template <class Caller> class CallbackTimer;
 
 // ------------------------------------------------------------------------------------------
 /*! Создание таймера
 	\param r - указатель на заказчика
 */
 template <class Caller>
-CallBackTimer<Caller>::CallBackTimer( Caller* r, Action a ):
+CallbackTimer<Caller>::CallbackTimer( Caller* r, Action a ):
 	cal(r),
 	act(a),
 	terminated(false)
 {
-	thr = new ThreadCreator<CallBackTimer>(this, &CallBackTimer<Caller>::work);
+	thr = new ThreadCreator<CallbackTimer>(this, &CallbackTimer<Caller>::work);
 }
 
 // ------------------------------------------------------------------------------------------
 
 template <class Caller>
-CallBackTimer<Caller>::CallBackTimer():
-	cal(null),
+CallbackTimer<Caller>::CallbackTimer():
+	cal(nullptr),
 	terminated(false)
 {
-	thr = new ThreadCreator<CallBackTimer>(this, &CallBackTimer<Caller>::work);
+	thr = new ThreadCreator<CallbackTimer>(this, &CallbackTimer<Caller>::work);
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-CallBackTimer<Caller>::~CallBackTimer()
+CallbackTimer<Caller>::~CallbackTimer()
 {
 	terminate();
 	clearTimers();
@@ -64,12 +64,12 @@ CallBackTimer<Caller>::~CallBackTimer()
 
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::work()
+void CallbackTimer<Caller>::work()
 {
 	terminated = false;
 	while( !terminated )
 	{
-		usleep(UniSetTimer::MIN_QUANTITY_TIME_MKS); 
+		usleep(UniSetTimer::MinQuantityTime);
 
 		for( typename TimersList::iterator li=lst.begin(); li!=lst.end(); ++li )
 		{
@@ -84,7 +84,7 @@ void CallBackTimer<Caller>::work()
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::run()
+void CallbackTimer<Caller>::run()
 {
 	if( !terminated )
 		terminate();
@@ -95,7 +95,7 @@ void CallBackTimer<Caller>::run()
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::terminate()
+void CallbackTimer<Caller>::terminate()
 {
 //	timeAct = 0;
 	terminated = true;
@@ -104,12 +104,12 @@ void CallBackTimer<Caller>::terminate()
 // ------------------------------------------------------------------------------------------
 
 template <class Caller>
-void CallBackTimer<Caller>::add( int id, int timeMS )throw(UniSetTypes::LimitTimers)
+void CallbackTimer<Caller>::add( int id, int timeMS )throw(UniSetTypes::LimitTimers)
 {
-	if( lst.size() >= MAXCallBackTimer )
+	if( lst.size() >= MAXCallbackTimer )
 	{
-		ostringstream err;
-		err << "CallBackTimers: превышено максимальное количество таймеров" << MAXCallBackTimer;
+		std::ostringstream err;
+		err << "CallbackTimers: exceeded the maximum number of timers (" << MAXCallbackTimer << ")";
 		throw UniSetTypes::LimitTimers(err.str()); 
 	}
 	
@@ -121,7 +121,7 @@ void CallBackTimer<Caller>::add( int id, int timeMS )throw(UniSetTypes::LimitTim
 // ------------------------------------------------------------------------------------------
 
 template <class Caller>
-void CallBackTimer<Caller>::remove( int id )
+void CallbackTimer<Caller>::remove( int id )
 {
 	// STL - способ поиска
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));	
@@ -130,7 +130,7 @@ void CallBackTimer<Caller>::remove( int id )
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::startTimers()
+void CallbackTimer<Caller>::startTimers()
 {
 	for( typename TimersList::iterator li=lst.begin(); li!=lst.end(); ++li)
 	{
@@ -139,13 +139,13 @@ void CallBackTimer<Caller>::startTimers()
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::clearTimers()
+void CallbackTimer<Caller>::clearTimers()
 {
 	lst.clear();
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::reset( int id )
+void CallbackTimer<Caller>::reset( int id )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));	
 	if( li!=lst.end() )
@@ -153,7 +153,7 @@ void CallBackTimer<Caller>::reset( int id )
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallBackTimer<Caller>::setTiming( int id, int timeMS )
+void CallbackTimer<Caller>::setTiming( int id, int timeMS )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));		
 	if( li!=lst.end() )
@@ -161,7 +161,7 @@ void CallBackTimer<Caller>::setTiming( int id, int timeMS )
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-int CallBackTimer<Caller>::getInterval( int id )
+int CallbackTimer<Caller>::getInterval( int id )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));		
 	if( li!=lst.end() )
@@ -170,7 +170,7 @@ int CallBackTimer<Caller>::getInterval( int id )
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-int CallBackTimer<Caller>::getCurrent( int id )
+int CallbackTimer<Caller>::getCurrent( int id )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));			
 	if( li!=lst.end() )
@@ -180,4 +180,4 @@ int CallBackTimer<Caller>::getCurrent( int id )
 }
 // ------------------------------------------------------------------------------------------
 
-# endif //CallBackTimer_TCC_H_
+# endif //CallbackTimer_TCC_H_

tests/Makefile.am

@@ -5,9 +5,10 @@
 check_PROGRAMS = tests tests_with_conf
 
 #umutex threadtst dlog
-tests_SOURCES = tests.cc passivetimer.cc hourglass.cc delaytimer.cc unixml.cc sscanf_hex.cc
-tests_LDADD 	= $(top_builddir)/lib/libUniSet2.la
-tests_CPPFLAGS	= -I$(top_builddir)/include -I$(includedir)/Catch
+tests_SOURCES = tests.cc passivetimer.cc hourglass.cc delaytimer.cc unixml.cc sscanf_hex.cc \
+	callbacktimer.cc
+tests_LDADD 	= $(top_builddir)/lib/libUniSet2.la $(SIGC_LIBS) $(COMCPP_LIBS)
+tests_CPPFLAGS	= -I$(top_builddir)/include -I$(includedir)/Catch $(SIGC_CFLAGS) $(COMCPP_CFLAGS)
 
 tests_with_conf_SOURCES = tests_with_conf.cc conftest.cc ui.cc
 tests_with_conf_LDADD   = $(top_builddir)/lib/libUniSet2.la

tests/callbacktimer.cc

+#include <catch.hpp>
+
+#include "CallbackTimer.h"
+#include "UniSetTypes.h"
+using namespace std;
+
+class MyTestClass
+{
+	public:
+		MyTestClass():num1(0),num2(0),num3(0){}
+		~MyTestClass(){}
+
+		void Time( int id )
+		{
+			if( id == 1 )
+				num1++;
+			else if( id == 2 )
+				num2++; 
+			else if( id == 3 )
+				num3++;
+		}
+	
+		inline int getNum1(){ return num1; }
+		inline int getNum2(){ return num2; }
+		inline int getNum3(){ return num3; }
+	
+	private:
+		int num1;
+		int num2;
+		int num3;
+};
+
+TEST_CASE("CallbackTimer", "[CallbackTimer]" ) 
+{
+	SECTION("Basic tests")
+	{
+		MyTestClass tc;
+		CallbackTimer<MyTestClass> tmr(&tc,&MyTestClass::Time);
+		
+		tmr.add(1, 50 );
+		tmr.add(2, 150 );
+		tmr.add(3, 300 );
+		tmr.run();
+	
+		msleep(60);
+		REQUIRE( tc.getNum1() == 1 );
+		REQUIRE( tc.getNum2() == 0 );
+		REQUIRE( tc.getNum3() == 0 );
+	
+		msleep(110);
+		REQUIRE( tc.getNum1() == 3 );
+		REQUIRE( tc.getNum2() == 1 );
+		REQUIRE( tc.getNum3() == 0 );
+		
+		msleep(210);
+		REQUIRE( tc.getNum1() == 7 );
+		REQUIRE( tc.getNum2() == 2 );
+		REQUIRE( tc.getNum3() == 1 );
+	
+		tmr.remove(1);
+		msleep(60);
+		REQUIRE( tc.getNum1() == 7 );
+	
+		tmr.terminate();
+		REQUIRE( tc.getNum2() == 2 );
+		REQUIRE( tc.getNum3() == 1 );
+	}
+
+	SECTION("other tests")
+	{
+		MyTestClass tc;
+		CallbackTimer<MyTestClass> tmr(&tc,&MyTestClass::Time);
+		int i=0;
+		for( ;i<tmr.MAXCallbackTimer; i++ )
+			tmr.add(i,100 );
+
+		REQUIRE_THROWS_AS( tmr.add(++i,100), UniSetTypes::LimitTimers );
+	}
+}