Logo Search packages:      
Sourcecode: poco version File versions  Download package

TaskManagerTest.cpp

//
// TaskManagerTest.cpp
//
// $Id: //poco/1.2/Foundation/testsuite/src/TaskManagerTest.cpp#1 $
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
// 
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//


#include "TaskManagerTest.h"
#include "CppUnit/TestCaller.h"
#include "CppUnit/TestSuite.h"
#include "Poco/TaskManager.h"
#include "Poco/Task.h"
#include "Poco/TaskNotification.h"
#include "Poco/NotificationCenter.h"
#include "Poco/Thread.h"
#include "Poco/Event.h"
#include "Poco/Observer.h"
#include "Poco/Exception.h"
#include "Poco/AutoPtr.h"


using Poco::TaskManager;
using Poco::Task;
using Poco::NotificationCenter;
using Poco::TaskStartedNotification;
using Poco::TaskCancelledNotification;
using Poco::TaskFinishedNotification;
using Poco::TaskFailedNotification;
using Poco::TaskProgressNotification;
using Poco::TaskCustomNotification;
using Poco::Thread;
using Poco::Event;
using Poco::Observer;
using Poco::Exception;
using Poco::SystemException;
using Poco::NullPointerException;
using Poco::AutoPtr;


namespace
{
      class TestTask: public Task
      {
      public:
            TestTask(): 
                  Task("TestTask"),
                  _fail(false)
            {
            }
            
            void runTask()
            {
                  _event.wait();
                  setProgress(0.5);
                  _event.wait();
                  if (isCancelled())
                        return;
                  if (_fail)
                        throw SystemException("warp core breach detected");
                  setProgress(1.0);
                  _event.wait();
            }
            
            void fail()
            {
                  _fail = true;
            }
            
            void cont()
            {
                  _event.set();
            }

      private:
            Event _event;
            bool  _fail;
      };
      
      class SimpleTask: public Task
      {
      public:
            SimpleTask(): Task("SimpleTask")
            {
            }
            
            void runTask()
            {
                  sleep(10000);
            }
      };
      
      class TaskObserver
      {
      public:
            TaskObserver():
                  _started(false),
                  _cancelled(false),
                  _finished(false),
                  _pException(0),
                  _progress(0.0)
            {
            }
            
            ~TaskObserver()
            {
                  delete _pException;
            }
            
            void taskStarted(TaskStartedNotification* pNf)
            {
                  _started = true;
                  pNf->release();
            }
            
            void taskCancelled(TaskCancelledNotification* pNf)
            {
                  _cancelled = true;
                  pNf->release();
            }
            
            void taskFinished(TaskFinishedNotification* pNf)
            {
                  _finished = true;
                  pNf->release();
            }
            
            void taskFailed(TaskFailedNotification* pNf)
            {
                  _pException = pNf->reason().clone();
                  pNf->release();
            }
            
            void taskProgress(TaskProgressNotification* pNf)
            {
                  _progress = pNf->progress();
                  pNf->release();
            }
            
            bool started() const
            {
                  return _started;
            }
            
            bool cancelled() const
            {
                  return _cancelled;
            }
            
            bool finished() const
            {
                  return _finished;
            }
            
            float progress() const
            {
                  return _progress;
            }
            
            Exception* error() const
            {
                  return _pException;
            }
            
      private:
            bool       _started;
            bool       _cancelled;
            bool       _finished;
            Exception* _pException;
            float      _progress;
      };


      template<typename T>
      class CustomNotificationTask: public Task
      {
      public:
            CustomNotificationTask(const T& t): 
                  Task("CustomNotificationTask"),
                  _custom(t)
            {
            }
            
            void runTask()
            {
                  sleep(10000);
            }
            
            void setCustom(const T& custom)
            {
                  _custom = custom;
                  postNotification(new TaskCustomNotification<T>(this, _custom));
            }
            
      private:
            T _custom;
      };
      

      template <class C>
      class CustomTaskObserver
      {
      public:
            CustomTaskObserver(const C& custom): _custom(custom)
            {
            }
            
            ~CustomTaskObserver()
            {
            }
            
            void taskCustom(TaskCustomNotification<C>* pNf)
            {
                  _custom = pNf->custom();
                  pNf->release();
            }

            const C& custom() const
            {
                  return _custom;
            }

      private:
            C _custom;
      };
}


TaskManagerTest::TaskManagerTest(const std::string& name): CppUnit::TestCase(name)
{
}


TaskManagerTest::~TaskManagerTest()
{
}


void TaskManagerTest::testFinish()
{
      TaskManager tm;
      TaskObserver to;
      tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
      tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
      tm.addObserver(Observer<TaskObserver, TaskFailedNotification>(to, &TaskObserver::taskFailed));
      tm.addObserver(Observer<TaskObserver, TaskFinishedNotification>(to, &TaskObserver::taskFinished));
      tm.addObserver(Observer<TaskObserver, TaskProgressNotification>(to, &TaskObserver::taskProgress));
      AutoPtr<TestTask> pTT = new TestTask;
      tm.start(pTT.duplicate());
      assert (pTT->progress() == 0);
      Thread::sleep(200);
      pTT->cont();
      while (pTT->progress() != 0.5) Thread::sleep(50);
      assert (to.progress() == 0.5);
      assert (to.started());
      assert (pTT->state() == Task::TASK_RUNNING);
      TaskManager::TaskList list = tm.taskList();
      assert (list.size() == 1);
      assert (tm.count() == 1);
      pTT->cont();
      while (pTT->progress() != 1.0) Thread::sleep(50);
      pTT->cont();
      while (pTT->state() != Task::TASK_FINISHED) Thread::sleep(50);
      assert (pTT->state() == Task::TASK_FINISHED);
      assert (to.finished());
      while (tm.count() == 1) Thread::sleep(50);
      list = tm.taskList();
      assert (list.empty());
      assert (!to.error());
}


void TaskManagerTest::testCancel()
{
      TaskManager tm;
      TaskObserver to;
      tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
      tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
      tm.addObserver(Observer<TaskObserver, TaskFailedNotification>(to, &TaskObserver::taskFailed));
      tm.addObserver(Observer<TaskObserver, TaskFinishedNotification>(to, &TaskObserver::taskFinished));
      tm.addObserver(Observer<TaskObserver, TaskProgressNotification>(to, &TaskObserver::taskProgress));
      AutoPtr<TestTask> pTT = new TestTask;
      tm.start(pTT.duplicate());
      assert (pTT->progress() == 0);
      Thread::sleep(200);
      pTT->cont();
      while (pTT->progress() != 0.5) Thread::sleep(50);
      assert (to.progress() == 0.5);
      assert (to.started());
      assert (pTT->state() == Task::TASK_RUNNING);
      TaskManager::TaskList list = tm.taskList();
      assert (list.size() == 1);
      assert (tm.count() == 1);
      tm.cancelAll();
      assert (to.cancelled());
      pTT->cont();
      while (pTT->state() != Task::TASK_FINISHED) Thread::sleep(50);
      assert (pTT->state() == Task::TASK_FINISHED);
      assert (to.finished());
      while (tm.count() == 1) Thread::sleep(50);
      list = tm.taskList();
      assert (list.empty());
      assert (!to.error());
}


void TaskManagerTest::testError()
{
      TaskManager tm;
      TaskObserver to;
      tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
      tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
      tm.addObserver(Observer<TaskObserver, TaskFailedNotification>(to, &TaskObserver::taskFailed));
      tm.addObserver(Observer<TaskObserver, TaskFinishedNotification>(to, &TaskObserver::taskFinished));
      tm.addObserver(Observer<TaskObserver, TaskProgressNotification>(to, &TaskObserver::taskProgress));
      AutoPtr<TestTask> pTT = new TestTask;
      tm.start(pTT.duplicate());
      assert (pTT->progress() == 0);
      Thread::sleep(200);
      pTT->cont();
      while (pTT->progress() != 0.5) Thread::sleep(50);
      assert (to.progress() == 0.5);
      assert (to.started());
      assert (pTT->state() == Task::TASK_RUNNING);
      TaskManager::TaskList list = tm.taskList();
      assert (list.size() == 1);
      assert (tm.count() == 1);
      pTT->fail();
      pTT->cont();
      while (pTT->state() != Task::TASK_FINISHED) Thread::sleep(50);
      assert (pTT->state() == Task::TASK_FINISHED);
      assert (to.finished());
      assert (to.error() != 0);
      while (tm.count() == 1) Thread::sleep(50);
      list = tm.taskList();
      assert (list.empty());
}


void TaskManagerTest::testCustom()
{
      TaskManager tm;
      
      CustomTaskObserver<int> ti(0);
      tm.addObserver(
            Observer<CustomTaskObserver<int>, TaskCustomNotification<int> >
                  (ti, &CustomTaskObserver<int>::taskCustom));
      
      AutoPtr<CustomNotificationTask<int> > pCNT1 = new CustomNotificationTask<int>(0);
      tm.start(pCNT1.duplicate());
      assert (ti.custom() == 0);
      
      for (int i = 1; i < 10; ++i)
      {
            pCNT1->setCustom(i);
            assert (ti.custom() == i);
      }

      CustomTaskObserver<std::string> ts("");
      tm.addObserver(
            Observer<CustomTaskObserver<std::string>, TaskCustomNotification<std::string> >
                  (ts, &CustomTaskObserver<std::string>::taskCustom));
      
      AutoPtr<CustomNotificationTask<std::string> > pCNT2 = new CustomNotificationTask<std::string>("");
      tm.start(pCNT2.duplicate());
      assert (tm.taskList().size() == 2);
      assert (ts.custom() == "");
      std::string str("notify me");
      pCNT2->setCustom(str);
      assert (ts.custom() == str);
      
      S s;
      s.i = 0;
      s.str = "";

      CustomTaskObserver<S*> ptst(&s);
      
      tm.addObserver(
            Observer<CustomTaskObserver<S*>, TaskCustomNotification<S*> >
                  (ptst, &CustomTaskObserver<S*>::taskCustom));
      
      AutoPtr<CustomNotificationTask<S*> > pCNT3 = new CustomNotificationTask<S*>(&s);
      tm.start(pCNT3.duplicate());
      assert (tm.taskList().size() == 3);
      assert (ptst.custom()->i == 0);
      assert (ptst.custom()->str == "");
      s.i = 123;
      s.str = "123";
      pCNT3->setCustom(&s);
      assert (ptst.custom()->i == 123);
      assert (ptst.custom()->str == "123");

      s.i = 0;
      s.str = "";

      CustomTaskObserver<S> tst(s);
      
      tm.addObserver(
            Observer<CustomTaskObserver<S>, TaskCustomNotification<S> >
                  (tst, &CustomTaskObserver<S>::taskCustom));
      
      AutoPtr<CustomNotificationTask<S> > pCNT4 = new CustomNotificationTask<S>(s);
      tm.start(pCNT4.duplicate());
      assert (tm.taskList().size() == 4);
      assert (tst.custom().i == 0);
      assert (tst.custom().str == "");
      s.i = 123;
      s.str = "123";
      pCNT4->setCustom(s);
      assert (tst.custom().i == 123);
      assert (tst.custom().str == "123");
      
      AutoPtr<SimpleTask> pST = new SimpleTask;
      tm.start(pST.duplicate());
      assert (tm.taskList().size() == 5);

      tm.cancelAll();
      while (tm.count() > 0) Thread::sleep(50);
      assert (tm.count() == 0);
}


void TaskManagerTest::testMultiTasks()
{
      TaskManager tm;
      tm.start(new SimpleTask);
      tm.start(new SimpleTask);
      tm.start(new SimpleTask);
      
      TaskManager::TaskList list = tm.taskList();
      assert (list.size() == 3);
      
      tm.cancelAll();
      while (tm.count() > 0) Thread::sleep(100);
      assert (tm.count() == 0);
}


void TaskManagerTest::setUp()
{
}


void TaskManagerTest::tearDown()
{
}


CppUnit::Test* TaskManagerTest::suite()
{
      CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("TaskManagerTest");

      CppUnit_addTest(pSuite, TaskManagerTest, testFinish);
      CppUnit_addTest(pSuite, TaskManagerTest, testCancel);
      CppUnit_addTest(pSuite, TaskManagerTest, testError);
      CppUnit_addTest(pSuite, TaskManagerTest, testMultiTasks);
      CppUnit_addTest(pSuite, TaskManagerTest, testCustom);

      return pSuite;
}

Generated by  Doxygen 1.6.0   Back to index