forked from qt-creator/qt-creator
82bc4870b3
Rename BarrierAdapter into BarrierTaskAdapter. Task-number: QTCREATORBUG-29102 Change-Id: I003b09fd71af1bde870f761d365a8cea1858862a Reviewed-by: hjk <hjk@qt.io>
1592 lines
53 KiB
C++
1592 lines
53 KiB
C++
// Copyright (C) 2022 The Qt Company Ltd.
|
|
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
|
|
|
|
#include <utils/asynctask.h>
|
|
#include <utils/barrier.h>
|
|
|
|
#include <QtTest>
|
|
|
|
#include <QDeadlineTimer>
|
|
|
|
using namespace std::literals::chrono_literals;
|
|
|
|
using namespace Utils;
|
|
using namespace Utils::Tasking;
|
|
|
|
using TestTask = Async<void>;
|
|
using Test = AsyncTask<void>;
|
|
|
|
enum class Handler {
|
|
Setup,
|
|
Done,
|
|
Error,
|
|
GroupSetup,
|
|
GroupDone,
|
|
GroupError,
|
|
Sync,
|
|
BarrierAdvance,
|
|
};
|
|
|
|
using Log = QList<QPair<int, Handler>>;
|
|
|
|
struct CustomStorage
|
|
{
|
|
CustomStorage() { ++s_count; }
|
|
~CustomStorage() { --s_count; }
|
|
Log m_log;
|
|
static int instanceCount() { return s_count; }
|
|
private:
|
|
static int s_count;
|
|
};
|
|
|
|
int CustomStorage::s_count = 0;
|
|
static const char s_taskIdProperty[] = "__taskId";
|
|
|
|
static FutureSynchronizer *s_futureSynchronizer = nullptr;
|
|
|
|
enum class OnStart { Running, NotRunning };
|
|
enum class OnDone { Success, Failure };
|
|
|
|
struct TestData {
|
|
TreeStorage<CustomStorage> storage;
|
|
Group root;
|
|
Log expectedLog;
|
|
int taskCount = 0;
|
|
OnStart onStart = OnStart::Running;
|
|
OnDone onDone = OnDone::Success;
|
|
};
|
|
|
|
class tst_TaskTree : public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
private slots:
|
|
void initTestCase();
|
|
|
|
void validConstructs(); // compile test
|
|
void testTree_data();
|
|
void testTree();
|
|
void storageOperators();
|
|
void storageDestructor();
|
|
|
|
void cleanupTestCase();
|
|
};
|
|
|
|
void tst_TaskTree::initTestCase()
|
|
{
|
|
s_futureSynchronizer = new FutureSynchronizer;
|
|
}
|
|
|
|
void tst_TaskTree::cleanupTestCase()
|
|
{
|
|
delete s_futureSynchronizer;
|
|
s_futureSynchronizer = nullptr;
|
|
}
|
|
|
|
void tst_TaskTree::validConstructs()
|
|
{
|
|
const Group task {
|
|
parallel,
|
|
Test([](TestTask &) {}, [](const TestTask &) {}),
|
|
Test([](TestTask &) {}, [](const TestTask &) {}),
|
|
Test([](TestTask &) {}, [](const TestTask &) {})
|
|
};
|
|
|
|
const Group group1 {
|
|
task
|
|
};
|
|
|
|
const Group group2 {
|
|
parallel,
|
|
Group {
|
|
parallel,
|
|
Test([](TestTask &) {}, [](const TestTask &) {}),
|
|
Group {
|
|
parallel,
|
|
Test([](TestTask &) {}, [](const TestTask &) {}),
|
|
Group {
|
|
parallel,
|
|
Test([](TestTask &) {}, [](const TestTask &) {})
|
|
}
|
|
},
|
|
Group {
|
|
parallel,
|
|
Test([](TestTask &) {}, [](const TestTask &) {}),
|
|
OnGroupDone([] {})
|
|
}
|
|
},
|
|
task,
|
|
OnGroupDone([] {}),
|
|
OnGroupError([] {})
|
|
};
|
|
|
|
const auto setupHandler = [](TestTask &) {};
|
|
const auto doneHandler = [](const TestTask &) {};
|
|
const auto errorHandler = [](const TestTask &) {};
|
|
|
|
// Not fluent interface
|
|
|
|
const Group task2 {
|
|
parallel,
|
|
Test(setupHandler),
|
|
Test(setupHandler, doneHandler),
|
|
Test(setupHandler, doneHandler, errorHandler),
|
|
// need to explicitly pass empty handler for done
|
|
Test(setupHandler, {}, errorHandler)
|
|
};
|
|
|
|
// Fluent interface
|
|
|
|
const Group fluent {
|
|
parallel,
|
|
Test().onSetup(setupHandler),
|
|
Test().onSetup(setupHandler).onDone(doneHandler),
|
|
Test().onSetup(setupHandler).onDone(doneHandler).onError(errorHandler),
|
|
// possible to skip the empty done
|
|
Test().onSetup(setupHandler).onError(errorHandler),
|
|
// possible to set handlers in a different order
|
|
Test().onError(errorHandler).onDone(doneHandler).onSetup(setupHandler),
|
|
};
|
|
|
|
|
|
// When turning each of below blocks on, you should see the specific compiler error message.
|
|
|
|
#if 0
|
|
{
|
|
// "Sync element: The synchronous function has to return void or bool."
|
|
const auto setupSync = [] { return 3; };
|
|
const Sync sync(setupSync);
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
{
|
|
// "Sync element: The synchronous function can't take any arguments."
|
|
const auto setupSync = [](int) { };
|
|
const Sync sync(setupSync);
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
{
|
|
// "Sync element: The synchronous function can't take any arguments."
|
|
const auto setupSync = [](int) { return true; };
|
|
const Sync sync(setupSync);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void runTask(QPromise<void> &promise, bool success, std::chrono::milliseconds sleep)
|
|
{
|
|
QDeadlineTimer deadline(sleep);
|
|
while (!deadline.hasExpired()) {
|
|
QThread::msleep(1);
|
|
if (promise.isCanceled())
|
|
return;
|
|
}
|
|
if (!success)
|
|
promise.future().cancel();
|
|
}
|
|
|
|
static void reportAndSleep(QPromise<bool> &promise)
|
|
{
|
|
promise.addResult(false);
|
|
QThread::msleep(5);
|
|
};
|
|
|
|
template <typename SharedBarrierType>
|
|
auto setupBarrierAdvance(const TreeStorage<CustomStorage> &storage,
|
|
const SharedBarrierType &barrier, int taskId)
|
|
{
|
|
return [storage, barrier, taskId](Async<bool> &async) {
|
|
async.setFutureSynchronizer(s_futureSynchronizer);
|
|
async.setConcurrentCallData(reportAndSleep);
|
|
async.setProperty(s_taskIdProperty, taskId);
|
|
storage->m_log.append({taskId, Handler::Setup});
|
|
|
|
CustomStorage *currentStorage = storage.activeStorage();
|
|
Barrier *sharedBarrier = barrier->barrier();
|
|
QObject::connect(&async, &TestTask::resultReadyAt, sharedBarrier,
|
|
[currentStorage, sharedBarrier, taskId](int index) {
|
|
Q_UNUSED(index)
|
|
currentStorage->m_log.append({taskId, Handler::BarrierAdvance});
|
|
sharedBarrier->advance();
|
|
});
|
|
};
|
|
}
|
|
|
|
void tst_TaskTree::testTree_data()
|
|
{
|
|
QTest::addColumn<TestData>("testData");
|
|
|
|
TreeStorage<CustomStorage> storage;
|
|
|
|
const auto setupTaskHelper = [storage](TestTask &task, int taskId, bool success = true,
|
|
std::chrono::milliseconds sleep = 0ms) {
|
|
task.setFutureSynchronizer(s_futureSynchronizer);
|
|
task.setConcurrentCallData(runTask, success, sleep);
|
|
task.setProperty(s_taskIdProperty, taskId);
|
|
storage->m_log.append({taskId, Handler::Setup});
|
|
};
|
|
const auto setupTask = [setupTaskHelper](int taskId) {
|
|
return [=](TestTask &task) { setupTaskHelper(task, taskId); };
|
|
};
|
|
const auto setupFailingTask = [setupTaskHelper](int taskId) {
|
|
return [=](TestTask &task) { setupTaskHelper(task, taskId, false); };
|
|
};
|
|
const auto setupSleepingTask = [setupTaskHelper](int taskId, std::chrono::milliseconds sleep) {
|
|
return [=](TestTask &task) { setupTaskHelper(task, taskId, true, sleep); };
|
|
};
|
|
const auto setupDynamicTask = [setupTaskHelper](int taskId, TaskAction action) {
|
|
return [=](TestTask &task) {
|
|
setupTaskHelper(task, taskId);
|
|
return action;
|
|
};
|
|
};
|
|
const auto logDone = [storage](const TestTask &task) {
|
|
storage->m_log.append({task.property(s_taskIdProperty).toInt(), Handler::Done});
|
|
};
|
|
const auto logError = [storage](const TestTask &task) {
|
|
storage->m_log.append({task.property(s_taskIdProperty).toInt(), Handler::Error});
|
|
};
|
|
const auto groupSetup = [storage](int taskId) {
|
|
return [=] { storage->m_log.append({taskId, Handler::GroupSetup}); };
|
|
};
|
|
const auto groupDone = [storage](int taskId) {
|
|
return [=] { storage->m_log.append({taskId, Handler::GroupDone}); };
|
|
};
|
|
const auto groupError = [storage](int taskId) {
|
|
return [=] { storage->m_log.append({taskId, Handler::GroupError}); };
|
|
};
|
|
const auto setupSync = [storage](int taskId) {
|
|
return [=] { storage->m_log.append({taskId, Handler::Sync}); };
|
|
};
|
|
const auto setupSyncWithReturn = [storage](int taskId, bool success) {
|
|
return [=] { storage->m_log.append({taskId, Handler::Sync}); return success; };
|
|
};
|
|
|
|
const auto constructSimpleSequence = [=](const Workflow &policy) {
|
|
return Group {
|
|
Storage(storage),
|
|
policy,
|
|
Test(setupTask(1), logDone),
|
|
Test(setupFailingTask(2), logDone, logError),
|
|
Test(setupTask(3), logDone),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
};
|
|
const auto constructDynamicHierarchy = [=](TaskAction taskAction) {
|
|
return Group {
|
|
Storage(storage),
|
|
Group {
|
|
Test(setupTask(1), logDone)
|
|
},
|
|
Group {
|
|
OnGroupSetup([=] { return taskAction; }),
|
|
Test(setupTask(2), logDone),
|
|
Test(setupTask(3), logDone),
|
|
Test(setupTask(4), logDone)
|
|
},
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
};
|
|
|
|
{
|
|
const Group root1 {
|
|
Storage(storage),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Group root2 {
|
|
Storage(storage),
|
|
OnGroupSetup([] { return TaskAction::Continue; }),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Group root3 {
|
|
Storage(storage),
|
|
OnGroupSetup([] { return TaskAction::StopWithDone; }),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Group root4 {
|
|
Storage(storage),
|
|
OnGroupSetup([] { return TaskAction::StopWithError; }),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Log logDone {{0, Handler::GroupDone}};
|
|
const Log logError {{0, Handler::GroupError}};
|
|
QTest::newRow("Empty")
|
|
<< TestData{storage, root1, logDone, 0, OnStart::NotRunning, OnDone::Success};
|
|
QTest::newRow("EmptyContinue")
|
|
<< TestData{storage, root2, logDone, 0, OnStart::NotRunning, OnDone::Success};
|
|
QTest::newRow("EmptyDone")
|
|
<< TestData{storage, root3, logDone, 0, OnStart::NotRunning, OnDone::Success};
|
|
QTest::newRow("EmptyError")
|
|
<< TestData{storage, root4, logError, 0, OnStart::NotRunning, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Test(setupDynamicTask(1, TaskAction::StopWithDone), logDone, logError),
|
|
Test(setupDynamicTask(2, TaskAction::StopWithDone), logDone, logError)
|
|
};
|
|
const Log log {{1, Handler::Setup}, {2, Handler::Setup}};
|
|
QTest::newRow("DynamicTaskDone")
|
|
<< TestData{storage, root, log, 2, OnStart::NotRunning, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Test(setupDynamicTask(1, TaskAction::StopWithError), logDone, logError),
|
|
Test(setupDynamicTask(2, TaskAction::StopWithError), logDone, logError)
|
|
};
|
|
const Log log {{1, Handler::Setup}};
|
|
QTest::newRow("DynamicTaskError")
|
|
<< TestData{storage, root, log, 2, OnStart::NotRunning, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Test(setupDynamicTask(1, TaskAction::Continue), logDone, logError),
|
|
Test(setupDynamicTask(2, TaskAction::Continue), logDone, logError),
|
|
Test(setupDynamicTask(3, TaskAction::StopWithError), logDone, logError),
|
|
Test(setupDynamicTask(4, TaskAction::Continue), logDone, logError)
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Done},
|
|
{3, Handler::Setup}
|
|
};
|
|
QTest::newRow("DynamicMixed")
|
|
<< TestData{storage, root, log, 4, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
parallel,
|
|
Storage(storage),
|
|
Test(setupDynamicTask(1, TaskAction::Continue), logDone, logError),
|
|
Test(setupDynamicTask(2, TaskAction::Continue), logDone, logError),
|
|
Test(setupDynamicTask(3, TaskAction::StopWithError), logDone, logError),
|
|
Test(setupDynamicTask(4, TaskAction::Continue), logDone, logError)
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup},
|
|
{1, Handler::Error},
|
|
{2, Handler::Error}
|
|
};
|
|
QTest::newRow("DynamicParallel")
|
|
<< TestData{storage, root, log, 4, OnStart::NotRunning, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
parallel,
|
|
Storage(storage),
|
|
Test(setupDynamicTask(1, TaskAction::Continue), logDone, logError),
|
|
Test(setupDynamicTask(2, TaskAction::Continue), logDone, logError),
|
|
Group {
|
|
Test(setupDynamicTask(3, TaskAction::StopWithError), logDone, logError)
|
|
},
|
|
Test(setupDynamicTask(4, TaskAction::Continue), logDone, logError)
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup},
|
|
{1, Handler::Error},
|
|
{2, Handler::Error}
|
|
};
|
|
QTest::newRow("DynamicParallelGroup")
|
|
<< TestData{storage, root, log, 4, OnStart::NotRunning, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
parallel,
|
|
Storage(storage),
|
|
Test(setupDynamicTask(1, TaskAction::Continue), logDone, logError),
|
|
Test(setupDynamicTask(2, TaskAction::Continue), logDone, logError),
|
|
Group {
|
|
OnGroupSetup([storage] {
|
|
storage->m_log.append({0, Handler::GroupSetup});
|
|
return TaskAction::StopWithError;
|
|
}),
|
|
Test(setupDynamicTask(3, TaskAction::Continue), logDone, logError)
|
|
},
|
|
Test(setupDynamicTask(4, TaskAction::Continue), logDone, logError)
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{2, Handler::Setup},
|
|
{0, Handler::GroupSetup},
|
|
{1, Handler::Error},
|
|
{2, Handler::Error}
|
|
};
|
|
QTest::newRow("DynamicParallelGroupSetup")
|
|
<< TestData{storage, root, log, 4, OnStart::NotRunning, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Group {
|
|
Group {
|
|
Group {
|
|
Group {
|
|
Group {
|
|
Test(setupTask(5), logDone, logError),
|
|
OnGroupSetup(groupSetup(5)),
|
|
OnGroupDone(groupDone(5))
|
|
},
|
|
OnGroupSetup(groupSetup(4)),
|
|
OnGroupDone(groupDone(4))
|
|
},
|
|
OnGroupSetup(groupSetup(3)),
|
|
OnGroupDone(groupDone(3))
|
|
},
|
|
OnGroupSetup(groupSetup(2)),
|
|
OnGroupDone(groupDone(2))
|
|
},
|
|
OnGroupSetup(groupSetup(1)),
|
|
OnGroupDone(groupDone(1))
|
|
},
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::GroupSetup},
|
|
{2, Handler::GroupSetup},
|
|
{3, Handler::GroupSetup},
|
|
{4, Handler::GroupSetup},
|
|
{5, Handler::GroupSetup},
|
|
{5, Handler::Setup},
|
|
{5, Handler::Done},
|
|
{5, Handler::GroupDone},
|
|
{4, Handler::GroupDone},
|
|
{3, Handler::GroupDone},
|
|
{2, Handler::GroupDone},
|
|
{1, Handler::GroupDone},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("Nested")
|
|
<< TestData{storage, root, log, 1, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const auto logDoneAnonymously = [=](const TestTask &) {
|
|
storage->m_log.append({0, Handler::Done});
|
|
};
|
|
const Group root {
|
|
Storage(storage),
|
|
parallel,
|
|
Test(setupTask(1), logDoneAnonymously),
|
|
Test(setupTask(2), logDoneAnonymously),
|
|
Test(setupTask(3), logDoneAnonymously),
|
|
Test(setupTask(4), logDoneAnonymously),
|
|
Test(setupTask(5), logDoneAnonymously),
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup}, // Setup order is determined in parallel mode
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup},
|
|
{4, Handler::Setup},
|
|
{5, Handler::Setup},
|
|
{0, Handler::Done}, // Done order isn't determined in parallel mode
|
|
{0, Handler::Done},
|
|
{0, Handler::Done},
|
|
{0, Handler::Done},
|
|
{0, Handler::Done},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("Parallel")
|
|
<< TestData{storage, root, log, 5, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
auto setupSubTree = [=](TaskTree &taskTree) {
|
|
const Group nestedRoot {
|
|
Storage(storage),
|
|
Test(setupTask(2), logDone),
|
|
Test(setupTask(3), logDone),
|
|
Test(setupTask(4), logDone)
|
|
};
|
|
taskTree.setupRoot(nestedRoot);
|
|
CustomStorage *activeStorage = storage.activeStorage();
|
|
auto collectSubLog = [activeStorage](CustomStorage *subTreeStorage){
|
|
activeStorage->m_log += subTreeStorage->m_log;
|
|
};
|
|
taskTree.onStorageDone(storage, collectSubLog);
|
|
};
|
|
const Group root1 {
|
|
Storage(storage),
|
|
Test(setupTask(1), logDone),
|
|
Test(setupTask(2), logDone),
|
|
Test(setupTask(3), logDone),
|
|
Test(setupTask(4), logDone),
|
|
Test(setupTask(5), logDone),
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Group root2 {
|
|
Storage(storage),
|
|
Group { Test(setupTask(1), logDone) },
|
|
Group { Test(setupTask(2), logDone) },
|
|
Group { Test(setupTask(3), logDone) },
|
|
Group { Test(setupTask(4), logDone) },
|
|
Group { Test(setupTask(5), logDone) },
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Group root3 {
|
|
Storage(storage),
|
|
Test(setupTask(1), logDone),
|
|
Tree(setupSubTree),
|
|
Test(setupTask(5), logDone),
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Done},
|
|
{3, Handler::Setup},
|
|
{3, Handler::Done},
|
|
{4, Handler::Setup},
|
|
{4, Handler::Done},
|
|
{5, Handler::Setup},
|
|
{5, Handler::Done},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("Sequential")
|
|
<< TestData{storage, root1, log, 5, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("SequentialEncapsulated")
|
|
<< TestData{storage, root2, log, 5, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("SequentialSubTree") // We don't inspect subtrees, so taskCount is 3, not 5.
|
|
<< TestData{storage, root3, log, 3, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Group {
|
|
Test(setupTask(1), logDone),
|
|
Group {
|
|
Test(setupTask(2), logDone),
|
|
Group {
|
|
Test(setupTask(3), logDone),
|
|
Group {
|
|
Test(setupTask(4), logDone),
|
|
Group {
|
|
Test(setupTask(5), logDone),
|
|
OnGroupDone(groupDone(5))
|
|
},
|
|
OnGroupDone(groupDone(4))
|
|
},
|
|
OnGroupDone(groupDone(3))
|
|
},
|
|
OnGroupDone(groupDone(2))
|
|
},
|
|
OnGroupDone(groupDone(1))
|
|
},
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Done},
|
|
{3, Handler::Setup},
|
|
{3, Handler::Done},
|
|
{4, Handler::Setup},
|
|
{4, Handler::Done},
|
|
{5, Handler::Setup},
|
|
{5, Handler::Done},
|
|
{5, Handler::GroupDone},
|
|
{4, Handler::GroupDone},
|
|
{3, Handler::GroupDone},
|
|
{2, Handler::GroupDone},
|
|
{1, Handler::GroupDone},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("SequentialNested")
|
|
<< TestData{storage, root, log, 5, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Test(setupTask(1), logDone),
|
|
Test(setupTask(2), logDone),
|
|
Test(setupFailingTask(3), logDone, logError),
|
|
Test(setupTask(4), logDone),
|
|
Test(setupTask(5), logDone),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Done},
|
|
{3, Handler::Setup},
|
|
{3, Handler::Error},
|
|
{0, Handler::GroupError}
|
|
};
|
|
QTest::newRow("SequentialError")
|
|
<< TestData{storage, root, log, 5, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root = constructSimpleSequence(stopOnError);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Error},
|
|
{0, Handler::GroupError}
|
|
};
|
|
QTest::newRow("StopOnError")
|
|
<< TestData{storage, root, log, 3, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root = constructSimpleSequence(continueOnError);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Error},
|
|
{3, Handler::Setup},
|
|
{3, Handler::Done},
|
|
{0, Handler::GroupError}
|
|
};
|
|
QTest::newRow("ContinueOnError")
|
|
<< TestData{storage, root, log, 3, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root = constructSimpleSequence(stopOnDone);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("StopOnDone")
|
|
<< TestData{storage, root, log, 3, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root = constructSimpleSequence(continueOnDone);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Error},
|
|
{3, Handler::Setup},
|
|
{3, Handler::Done},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("ContinueOnDone")
|
|
<< TestData{storage, root, log, 3, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
optional,
|
|
Test(setupFailingTask(1), logDone, logError),
|
|
Test(setupFailingTask(2), logDone, logError),
|
|
OnGroupDone(groupDone(0)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Error},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Error},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("Optional")
|
|
<< TestData{storage, root, log, 2, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root = constructDynamicHierarchy(TaskAction::StopWithDone);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("DynamicSetupDone")
|
|
<< TestData{storage, root, log, 4, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root = constructDynamicHierarchy(TaskAction::StopWithError);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{0, Handler::GroupError}
|
|
};
|
|
QTest::newRow("DynamicSetupError")
|
|
<< TestData{storage, root, log, 4, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root = constructDynamicHierarchy(TaskAction::Continue);
|
|
const Log log {
|
|
{1, Handler::Setup},
|
|
{1, Handler::Done},
|
|
{2, Handler::Setup},
|
|
{2, Handler::Done},
|
|
{3, Handler::Setup},
|
|
{3, Handler::Done},
|
|
{4, Handler::Setup},
|
|
{4, Handler::Done},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("DynamicSetupContinue")
|
|
<< TestData{storage, root, log, 4, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
OnGroupSetup(groupSetup(1)),
|
|
Test(setupTask(1))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
Test(setupTask(2))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
Test(setupTask(3))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(4)),
|
|
Test(setupTask(4))
|
|
}
|
|
};
|
|
const Log log {
|
|
{1, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::GroupSetup},
|
|
{3, Handler::Setup},
|
|
{4, Handler::GroupSetup},
|
|
{4, Handler::Setup}
|
|
};
|
|
QTest::newRow("NestedParallel")
|
|
<< TestData{storage, root, log, 4, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
OnGroupSetup(groupSetup(1)),
|
|
Test(setupTask(1))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
Test(setupTask(2))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
Test(setupDynamicTask(3, TaskAction::StopWithDone))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(4)),
|
|
Test(setupTask(4))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(5)),
|
|
Test(setupTask(5))
|
|
}
|
|
};
|
|
const Log log {
|
|
{1, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::GroupSetup},
|
|
{3, Handler::Setup},
|
|
{4, Handler::GroupSetup},
|
|
{4, Handler::Setup},
|
|
{5, Handler::GroupSetup},
|
|
{5, Handler::Setup}
|
|
};
|
|
QTest::newRow("NestedParallelDone")
|
|
<< TestData{storage, root, log, 5, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root1 {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
OnGroupSetup(groupSetup(1)),
|
|
Test(setupTask(1))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
Test(setupTask(2))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
Test(setupDynamicTask(3, TaskAction::StopWithError))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(4)),
|
|
Test(setupTask(4))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(5)),
|
|
Test(setupTask(5))
|
|
}
|
|
};
|
|
|
|
// Inside this test the task 2 should finish first, then synchonously:
|
|
// - task 3 should exit setup with error
|
|
// - task 1 should be stopped as a consequence of error inside the group
|
|
// - tasks 4 and 5 should be skipped
|
|
const Group root2 {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
OnGroupSetup(groupSetup(1)),
|
|
Test(setupSleepingTask(1, 10ms))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
Test(setupTask(2))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
Test(setupDynamicTask(3, TaskAction::StopWithError))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(4)),
|
|
Test(setupTask(4))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(5)),
|
|
Test(setupTask(5))
|
|
}
|
|
};
|
|
|
|
// This test ensures that the task 1 doesn't invoke its done handler,
|
|
// being ready while sleeping in the task's 2 done handler.
|
|
// Inside this test the task 2 should finish first, then synchonously:
|
|
// - task 3 should exit setup with error
|
|
// - task 1 should be stopped as a consequence of error inside the group
|
|
// - task 4 should be skipped
|
|
// - the first child group of root should finish with error
|
|
// - task 5 should be started (because of root's continueOnError policy)
|
|
const Group root3 {
|
|
continueOnError,
|
|
Storage(storage),
|
|
Group {
|
|
ParallelLimit(2),
|
|
Group {
|
|
OnGroupSetup(groupSetup(1)),
|
|
Test(setupSleepingTask(1, 20ms))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
Test(setupTask(2), [](const TestTask &) { QThread::msleep(10); })
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
Test(setupDynamicTask(3, TaskAction::StopWithError))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(4)),
|
|
Test(setupTask(4))
|
|
}
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(5)),
|
|
Test(setupTask(5))
|
|
}
|
|
};
|
|
const Log shortLog {
|
|
{1, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::GroupSetup},
|
|
{3, Handler::Setup}
|
|
};
|
|
const Log longLog = shortLog + Log {{5, Handler::GroupSetup}, {5, Handler::Setup}};
|
|
QTest::newRow("NestedParallelError1")
|
|
<< TestData{storage, root1, shortLog, 5, OnStart::Running, OnDone::Failure};
|
|
QTest::newRow("NestedParallelError2")
|
|
<< TestData{storage, root2, shortLog, 5, OnStart::Running, OnDone::Failure};
|
|
QTest::newRow("NestedParallelError3")
|
|
<< TestData{storage, root3, longLog, 5, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(1)),
|
|
Group {
|
|
parallel,
|
|
Test(setupTask(1))
|
|
}
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(2)),
|
|
Group {
|
|
parallel,
|
|
Test(setupTask(2))
|
|
}
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(3)),
|
|
Group {
|
|
parallel,
|
|
Test(setupTask(3))
|
|
}
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(4)),
|
|
Group {
|
|
parallel,
|
|
Test(setupTask(4))
|
|
}
|
|
}
|
|
};
|
|
const Log log {
|
|
{1, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::GroupSetup},
|
|
{3, Handler::Setup},
|
|
{4, Handler::GroupSetup},
|
|
{4, Handler::Setup}
|
|
};
|
|
QTest::newRow("DeeplyNestedParallel")
|
|
<< TestData{storage, root, log, 4, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(1)),
|
|
Group { Test(setupTask(1)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(2)),
|
|
Group { Test(setupTask(2)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(3)),
|
|
Group { Test(setupDynamicTask(3, TaskAction::StopWithDone)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(4)),
|
|
Group { Test(setupTask(4)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(5)),
|
|
Group { Test(setupTask(5)) }
|
|
}
|
|
};
|
|
const Log log {
|
|
{1, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::GroupSetup},
|
|
{3, Handler::Setup},
|
|
{4, Handler::GroupSetup},
|
|
{4, Handler::Setup},
|
|
{5, Handler::GroupSetup},
|
|
{5, Handler::Setup}
|
|
};
|
|
QTest::newRow("DeeplyNestedParallelDone")
|
|
<< TestData{storage, root, log, 5, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
ParallelLimit(2),
|
|
Storage(storage),
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(1)),
|
|
Group { Test(setupTask(1)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(2)),
|
|
Group { Test(setupTask(2)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(3)),
|
|
Group { Test(setupDynamicTask(3, TaskAction::StopWithError)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(4)),
|
|
Group { Test(setupTask(4)) }
|
|
},
|
|
Group {
|
|
Storage(TreeStorage<CustomStorage>()),
|
|
OnGroupSetup(groupSetup(5)),
|
|
Group { Test(setupTask(5)) }
|
|
}
|
|
};
|
|
const Log log {
|
|
{1, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::GroupSetup},
|
|
{3, Handler::Setup}
|
|
};
|
|
QTest::newRow("DeeplyNestedParallelError")
|
|
<< TestData{storage, root, log, 5, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Sync(setupSync(1)),
|
|
Sync(setupSync(2)),
|
|
Sync(setupSync(3)),
|
|
Sync(setupSync(4)),
|
|
Sync(setupSync(5))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Sync},
|
|
{2, Handler::Sync},
|
|
{3, Handler::Sync},
|
|
{4, Handler::Sync},
|
|
{5, Handler::Sync}
|
|
};
|
|
QTest::newRow("SyncSequential")
|
|
<< TestData{storage, root, log, 0, OnStart::NotRunning, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Sync(setupSyncWithReturn(1, true)),
|
|
Sync(setupSyncWithReturn(2, true)),
|
|
Sync(setupSyncWithReturn(3, true)),
|
|
Sync(setupSyncWithReturn(4, true)),
|
|
Sync(setupSyncWithReturn(5, true))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Sync},
|
|
{2, Handler::Sync},
|
|
{3, Handler::Sync},
|
|
{4, Handler::Sync},
|
|
{5, Handler::Sync}
|
|
};
|
|
QTest::newRow("SyncWithReturn")
|
|
<< TestData{storage, root, log, 0, OnStart::NotRunning, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
parallel,
|
|
Sync(setupSync(1)),
|
|
Sync(setupSync(2)),
|
|
Sync(setupSync(3)),
|
|
Sync(setupSync(4)),
|
|
Sync(setupSync(5))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Sync},
|
|
{2, Handler::Sync},
|
|
{3, Handler::Sync},
|
|
{4, Handler::Sync},
|
|
{5, Handler::Sync}
|
|
};
|
|
QTest::newRow("SyncParallel")
|
|
<< TestData{storage, root, log, 0, OnStart::NotRunning, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
parallel,
|
|
Sync(setupSync(1)),
|
|
Sync(setupSync(2)),
|
|
Sync(setupSyncWithReturn(3, false)),
|
|
Sync(setupSync(4)),
|
|
Sync(setupSync(5))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Sync},
|
|
{2, Handler::Sync},
|
|
{3, Handler::Sync}
|
|
};
|
|
QTest::newRow("SyncError")
|
|
<< TestData{storage, root, log, 0, OnStart::NotRunning, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Sync(setupSync(1)),
|
|
Test(setupTask(2)),
|
|
Sync(setupSync(3)),
|
|
Test(setupTask(4)),
|
|
Sync(setupSync(5)),
|
|
OnGroupDone(groupDone(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Sync},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Sync},
|
|
{4, Handler::Setup},
|
|
{5, Handler::Sync},
|
|
{0, Handler::GroupDone}
|
|
};
|
|
QTest::newRow("SyncAndAsync")
|
|
<< TestData{storage, root, log, 2, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
const Group root {
|
|
Storage(storage),
|
|
Sync(setupSync(1)),
|
|
Test(setupTask(2)),
|
|
Sync(setupSyncWithReturn(3, false)),
|
|
Test(setupTask(4)),
|
|
Sync(setupSync(5)),
|
|
OnGroupError(groupError(0))
|
|
};
|
|
const Log log {
|
|
{1, Handler::Sync},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Sync},
|
|
{0, Handler::GroupError}
|
|
};
|
|
QTest::newRow("SyncAndAsyncError")
|
|
<< TestData{storage, root, log, 2, OnStart::Running, OnDone::Failure};
|
|
}
|
|
|
|
{
|
|
SingleBarrier barrier;
|
|
|
|
// Test that barrier advance, triggered from inside the task described by
|
|
// setupBarrierAdvance, placed BEFORE the group containing the waitFor() element
|
|
// in the tree order, works OK in SEQUENTIAL mode.
|
|
const Group root1 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
sequential,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 1)),
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(2)),
|
|
Test(setupTask(3))
|
|
}
|
|
};
|
|
const Log log1 {
|
|
{1, Handler::Setup},
|
|
{1, Handler::BarrierAdvance},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup}
|
|
};
|
|
|
|
// Test that barrier advance, triggered from inside the task described by
|
|
// setupTaskWithCondition, placed BEFORE the group containing the waitFor() element
|
|
// in the tree order, works OK in PARALLEL mode.
|
|
const Group root2 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
parallel,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 1)),
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(2)),
|
|
Test(setupTask(3))
|
|
}
|
|
};
|
|
const Log log2 {
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{1, Handler::BarrierAdvance},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup}
|
|
};
|
|
|
|
// Test that barrier advance, triggered from inside the task described by
|
|
// setupTaskWithCondition, placed AFTER the group containing the waitFor() element
|
|
// in the tree order, works OK in PARALLEL mode.
|
|
//
|
|
// Notice: This won't work in SEQUENTIAL mode, since the advancing barrier, placed after the
|
|
// group containing the WaitFor element, has no chance to be started in SEQUENTIAL mode,
|
|
// as in SEQUENTIAL mode the next task may only be started after the previous one finished.
|
|
// In this case, the previous task (Group element) awaits for the barrier's advance to
|
|
// come from the not yet started next task, causing a deadlock.
|
|
// The minimal requirement for this scenario to succeed is to set ParallelLimit(2) or more.
|
|
const Group root3 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
parallel,
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(2)),
|
|
Test(setupTask(3))
|
|
},
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 1))
|
|
};
|
|
const Log log3 {
|
|
{2, Handler::GroupSetup},
|
|
{1, Handler::Setup},
|
|
{1, Handler::BarrierAdvance},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup}
|
|
};
|
|
|
|
// Test that barrier advance, triggered from inside the task described by
|
|
// setupBarrierAdvance, placed BEFORE the groups containing the waitFor() element
|
|
// in the tree order, wakes both waitFor tasks.
|
|
const Group root4 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
parallel,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 1)),
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(4))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(5))
|
|
}
|
|
};
|
|
const Log log4 {
|
|
{1, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{3, Handler::GroupSetup},
|
|
{1, Handler::BarrierAdvance},
|
|
{4, Handler::Setup},
|
|
{5, Handler::Setup}
|
|
};
|
|
|
|
// Test two separate single barriers.
|
|
|
|
SingleBarrier barrier2;
|
|
|
|
const Group root5 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
Storage(barrier2),
|
|
parallel,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0)),
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier2, 0)),
|
|
Group {
|
|
Group {
|
|
parallel,
|
|
OnGroupSetup(groupSetup(1)),
|
|
WaitForBarrierTask(barrier),
|
|
WaitForBarrierTask(barrier2)
|
|
},
|
|
Test(setupTask(2))
|
|
},
|
|
};
|
|
const Log log5 {
|
|
{0, Handler::Setup},
|
|
{0, Handler::Setup},
|
|
{1, Handler::GroupSetup},
|
|
{0, Handler::BarrierAdvance},
|
|
{0, Handler::BarrierAdvance},
|
|
{2, Handler::Setup}
|
|
};
|
|
|
|
// Notice the different log order for each scenario.
|
|
QTest::newRow("BarrierSequential")
|
|
<< TestData{storage, root1, log1, 4, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("BarrierParallelAdvanceFirst")
|
|
<< TestData{storage, root2, log2, 4, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("BarrierParallelWaitForFirst")
|
|
<< TestData{storage, root3, log3, 4, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("BarrierParallelMultiWaitFor")
|
|
<< TestData{storage, root4, log4, 5, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("BarrierParallelTwoSingleBarriers")
|
|
<< TestData{storage, root5, log5, 5, OnStart::Running, OnDone::Success};
|
|
}
|
|
|
|
{
|
|
MultiBarrier<2> barrier;
|
|
|
|
// Test that multi barrier advance, triggered from inside the tasks described by
|
|
// setupBarrierAdvance, placed BEFORE the group containing the waitFor() element
|
|
// in the tree order, works OK in SEQUENTIAL mode.
|
|
const Group root1 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
sequential,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 1)),
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 2)),
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(2)),
|
|
Test(setupTask(3))
|
|
}
|
|
};
|
|
const Log log1 {
|
|
{1, Handler::Setup},
|
|
{1, Handler::BarrierAdvance},
|
|
{2, Handler::Setup},
|
|
{2, Handler::BarrierAdvance},
|
|
{2, Handler::GroupSetup},
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup}
|
|
};
|
|
|
|
// Test that multi barrier advance, triggered from inside the tasks described by
|
|
// setupBarrierAdvance, placed BEFORE the group containing the waitFor() element
|
|
// in the tree order, works OK in PARALLEL mode.
|
|
const Group root2 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
parallel,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0)),
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0)),
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(2)),
|
|
Test(setupTask(3))
|
|
}
|
|
};
|
|
const Log log2 {
|
|
{0, Handler::Setup},
|
|
{0, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{0, Handler::BarrierAdvance}, // Barrier advances may come in different order in
|
|
{0, Handler::BarrierAdvance}, // parallel mode, that's why id = 0 (same for both).
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup}
|
|
};
|
|
|
|
// Test that multi barrier advance, triggered from inside the tasks described by
|
|
// setupBarrierAdvance, placed AFTER the group containing the waitFor() element
|
|
// in the tree order, works OK in PARALLEL mode.
|
|
//
|
|
// Notice: This won't work in SEQUENTIAL mode, since the advancing barriers, placed after
|
|
// the group containing the WaitFor element, has no chance to be started in SEQUENTIAL mode,
|
|
// as in SEQUENTIAL mode the next task may only be started after the previous one finished.
|
|
// In this case, the previous task (Group element) awaits for the barrier's advance to
|
|
// come from the not yet started next task, causing a deadlock.
|
|
// The minimal requirement for this scenario to succeed is to set ParallelLimit(2) or more.
|
|
const Group root3 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
parallel,
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(2)),
|
|
Test(setupTask(3))
|
|
},
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0)),
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0))
|
|
};
|
|
const Log log3 {
|
|
{2, Handler::GroupSetup},
|
|
{0, Handler::Setup},
|
|
{0, Handler::Setup},
|
|
{0, Handler::BarrierAdvance}, // Barrier advances may come in different order in
|
|
{0, Handler::BarrierAdvance}, // parallel mode, that's why id = 0 (same for both).
|
|
{2, Handler::Setup},
|
|
{3, Handler::Setup}
|
|
};
|
|
|
|
// Test that multi barrier advance, triggered from inside the task described by
|
|
// setupBarrierAdvance, placed BEFORE the groups containing the waitFor() element
|
|
// in the tree order, wakes both waitFor tasks.
|
|
const Group root4 {
|
|
Storage(storage),
|
|
Storage(barrier),
|
|
parallel,
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0)),
|
|
AsyncTask<bool>(setupBarrierAdvance(storage, barrier, 0)),
|
|
Group {
|
|
OnGroupSetup(groupSetup(2)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(4))
|
|
},
|
|
Group {
|
|
OnGroupSetup(groupSetup(3)),
|
|
WaitForBarrierTask(barrier),
|
|
Test(setupTask(5))
|
|
}
|
|
};
|
|
const Log log4 {
|
|
{0, Handler::Setup},
|
|
{0, Handler::Setup},
|
|
{2, Handler::GroupSetup},
|
|
{3, Handler::GroupSetup},
|
|
{0, Handler::BarrierAdvance},
|
|
{0, Handler::BarrierAdvance},
|
|
{4, Handler::Setup},
|
|
{5, Handler::Setup}
|
|
};
|
|
|
|
// Notice the different log order for each scenario.
|
|
QTest::newRow("MultiBarrierSequential")
|
|
<< TestData{storage, root1, log1, 5, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("MultiBarrierParallelAdvanceFirst")
|
|
<< TestData{storage, root2, log2, 5, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("MultiBarrierParallelWaitForFirst")
|
|
<< TestData{storage, root3, log3, 5, OnStart::Running, OnDone::Success};
|
|
QTest::newRow("MultiBarrierParallelMultiWaitFor")
|
|
<< TestData{storage, root4, log4, 6, OnStart::Running, OnDone::Success};
|
|
}
|
|
}
|
|
|
|
void tst_TaskTree::testTree()
|
|
{
|
|
QFETCH(TestData, testData);
|
|
|
|
QEventLoop eventLoop;
|
|
TaskTree taskTree(testData.root);
|
|
QCOMPARE(taskTree.taskCount(), testData.taskCount);
|
|
int doneCount = 0;
|
|
int errorCount = 0;
|
|
connect(&taskTree, &TaskTree::done, this, [&doneCount, &eventLoop] {
|
|
++doneCount;
|
|
eventLoop.quit();
|
|
});
|
|
connect(&taskTree, &TaskTree::errorOccurred, this, [&errorCount, &eventLoop] {
|
|
++errorCount;
|
|
eventLoop.quit();
|
|
});
|
|
Log actualLog;
|
|
auto collectLog = [&actualLog](CustomStorage *storage){
|
|
actualLog = storage->m_log;
|
|
};
|
|
taskTree.onStorageDone(testData.storage, collectLog);
|
|
taskTree.start();
|
|
const bool expectRunning = testData.onStart == OnStart::Running;
|
|
QCOMPARE(taskTree.isRunning(), expectRunning);
|
|
|
|
if (expectRunning) {
|
|
QTimer timer;
|
|
bool timedOut = false;
|
|
connect(&timer, &QTimer::timeout, &eventLoop, [&eventLoop, &timedOut] {
|
|
timedOut = true;
|
|
eventLoop.quit();
|
|
});
|
|
timer.setInterval(2000);
|
|
timer.setSingleShot(true);
|
|
timer.start();
|
|
eventLoop.exec();
|
|
QCOMPARE(timedOut, false);
|
|
QCOMPARE(taskTree.isRunning(), false);
|
|
}
|
|
|
|
QCOMPARE(taskTree.progressValue(), testData.taskCount);
|
|
QCOMPARE(actualLog, testData.expectedLog);
|
|
QCOMPARE(CustomStorage::instanceCount(), 0);
|
|
|
|
const bool expectSuccess = testData.onDone == OnDone::Success;
|
|
const int expectedDoneCount = expectSuccess ? 1 : 0;
|
|
const int expectedErrorCount = expectSuccess ? 0 : 1;
|
|
QCOMPARE(doneCount, expectedDoneCount);
|
|
QCOMPARE(errorCount, expectedErrorCount);
|
|
}
|
|
|
|
void tst_TaskTree::storageOperators()
|
|
{
|
|
TreeStorageBase storage1 = TreeStorage<CustomStorage>();
|
|
TreeStorageBase storage2 = TreeStorage<CustomStorage>();
|
|
TreeStorageBase storage3 = storage1;
|
|
|
|
QVERIFY(storage1 == storage3);
|
|
QVERIFY(storage1 != storage2);
|
|
QVERIFY(storage2 != storage3);
|
|
}
|
|
|
|
// This test checks whether a running task tree may be safely destructed.
|
|
// It also checks whether the destructor of a task tree deletes properly the storage created
|
|
// while starting the task tree. When running task tree is destructed, the storage done
|
|
// handler shouldn't be invoked.
|
|
void tst_TaskTree::storageDestructor()
|
|
{
|
|
bool setupCalled = false;
|
|
const auto setupHandler = [&setupCalled](CustomStorage *) {
|
|
setupCalled = true;
|
|
};
|
|
bool doneCalled = false;
|
|
const auto doneHandler = [&doneCalled](CustomStorage *) {
|
|
doneCalled = true;
|
|
};
|
|
QCOMPARE(CustomStorage::instanceCount(), 0);
|
|
{
|
|
TreeStorage<CustomStorage> storage;
|
|
const auto setupSleepingTask = [](TestTask &task) {
|
|
task.setFutureSynchronizer(s_futureSynchronizer);
|
|
task.setConcurrentCallData(runTask, true, 1000ms);
|
|
};
|
|
const Group root {
|
|
Storage(storage),
|
|
Test(setupSleepingTask)
|
|
};
|
|
|
|
TaskTree taskTree(root);
|
|
QCOMPARE(CustomStorage::instanceCount(), 0);
|
|
taskTree.onStorageSetup(storage, setupHandler);
|
|
taskTree.onStorageDone(storage, doneHandler);
|
|
taskTree.start();
|
|
QCOMPARE(CustomStorage::instanceCount(), 1);
|
|
QThread::msleep(5); // Give the sleeping task a change to start
|
|
}
|
|
QCOMPARE(CustomStorage::instanceCount(), 0);
|
|
QVERIFY(setupCalled);
|
|
QVERIFY(!doneCalled);
|
|
}
|
|
|
|
QTEST_GUILESS_MAIN(tst_TaskTree)
|
|
|
|
#include "tst_tasktree.moc"
|