mirror of
https://github.com/pocoproject/poco.git
synced 2025-10-28 19:51:58 +01:00
removing old trunk files
This commit is contained in:
Aleksandar Fabijanic
@@ -1,521 +0,0 @@
|
||||
//
|
||||
// TaskManagerTest.cpp
|
||||
//
|
||||
// $Id: //poco/svn/Foundation/testsuite/src/TaskManagerTest.cpp#3 $
|
||||
//
|
||||
// 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/Exception.h"
|
||||
#include "Poco/TaskManager.h"
|
||||
#include "Poco/Task.h"
|
||||
#include "Poco/TaskNotification.h"
|
||||
#include "Poco/NotificationCenter.h"
|
||||
#include "Poco/Thread.h"
|
||||
#include "Poco/ThreadPool.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::ThreadPool;
|
||||
using Poco::Event;
|
||||
using Poco::Observer;
|
||||
using Poco::Exception;
|
||||
using Poco::NoThreadAvailableException;
|
||||
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::testCustomThreadPool()
|
||||
{
|
||||
ThreadPool tp(2, 5, 120);
|
||||
TaskManager tm(tp);
|
||||
|
||||
// fill up the thread pool
|
||||
for (int i=0; i < tp.capacity(); ++i)
|
||||
{
|
||||
tm.start(new SimpleTask);
|
||||
}
|
||||
assert (tp.allocated() == tp.capacity());
|
||||
assert (tm.count() == tp.allocated());
|
||||
|
||||
// the next one should fail
|
||||
try
|
||||
{
|
||||
tm.start(new SimpleTask);
|
||||
failmsg("thread pool exhausted - must throw exception");
|
||||
}
|
||||
catch (NoThreadAvailableException const&)
|
||||
{
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
failmsg("wrong exception thrown");
|
||||
}
|
||||
|
||||
assert (tm.count() == tp.allocated());
|
||||
|
||||
tp.joinAll();
|
||||
}
|
||||
|
||||
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);
|
||||
CppUnit_addTest(pSuite, TaskManagerTest, testCustomThreadPool);
|
||||
|
||||
return pSuite;
|
||||
}
|
||||
Reference in New Issue
Block a user