feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

TaskTree test: Use storage for getting the result from task tree

Browse Source 
Remove storage() test case, as Storage functionality is fully
tested in processTree().

Change-Id: I05c199cf4cfa2a77493ce54df267b8ed1c2804bc
Reviewed-by: hjk <hjk@qt.io>
This commit is contained in:
Jarek Kobus
2022-12-05 18:08:48 +01:00
parent 7fc9933969
commit 4ff34cf47f
1 changed files with 103 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
tests/auto/utils/tasktree/tst_tasktree.cpp
View File

@@ -16,17 +16,6 @@
using namespace Utils; using namespace Utils;
using namespace Utils::Tasking; using namespace Utils::Tasking;
enum class Handler {
Setup,
Done,
Error,
GroupSetup,
GroupDone,
GroupError
};
using Log = QList<QPair<int, Handler>>;
class tst_TaskTree : public QObject class tst_TaskTree : public QObject
{ {
Q_OBJECT Q_OBJECT
@@ -37,15 +26,12 @@ private slots:
void validConstructs(); // compile test void validConstructs(); // compile test
void processTree_data(); void processTree_data();
void processTree(); void processTree();
void storage_data();
void storage();
void storageOperators(); void storageOperators();
void storageDestructor(); void storageDestructor();
void cleanupTestCase(); void cleanupTestCase();
private: private:
Log m_log;
FilePath m_testAppPath; FilePath m_testAppPath;
}; };
@@ -105,61 +91,88 @@ void tst_TaskTree::validConstructs()
static const char s_processIdProperty[] = "__processId"; static const char s_processIdProperty[] = "__processId";
enum class Handler {
Setup,
Done,
Error,
GroupSetup,
GroupDone,
GroupError
};
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;
void tst_TaskTree::processTree_data() void tst_TaskTree::processTree_data()
{ {
using namespace std::placeholders; using namespace std::placeholders;
QTest::addColumn<Group>("root"); QTest::addColumn<Group>("root");
QTest::addColumn<TreeStorage<CustomStorage>>("storage");
QTest::addColumn<Log>("expectedLog"); QTest::addColumn<Log>("expectedLog");
QTest::addColumn<bool>("runningAfterStart"); QTest::addColumn<bool>("runningAfterStart");
QTest::addColumn<bool>("success"); QTest::addColumn<bool>("success");
QTest::addColumn<int>("taskCount"); QTest::addColumn<int>("taskCount");
const auto setupProcessHelper = [this](QtcProcess &process, const QStringList &args, int processId) { TreeStorage<CustomStorage> storage;
process.setCommand(CommandLine(m_testAppPath, args));
const auto setupProcessHelper = [storage, testAppPath = m_testAppPath]
(QtcProcess &process, const QStringList &args, int processId) {
process.setCommand(CommandLine(testAppPath, args));
process.setProperty(s_processIdProperty, processId); process.setProperty(s_processIdProperty, processId);
m_log.append({processId, Handler::Setup}); storage->m_log.append({processId, Handler::Setup});
}; };
const auto setupProcess = [setupProcessHelper](QtcProcess &process, int processId) { const auto setupProcess = [setupProcessHelper](QtcProcess &process, int processId) {
setupProcessHelper(process, {"-return", "0"}, processId); setupProcessHelper(process, {"-return", "0"}, processId);
}; };
// const auto setupErrorProcess = [setupProcessHelper](QtcProcess &process, int processId) {
// setupProcessHelper(process, {"-return", "1"}, processId);
// };
const auto setupCrashProcess = [setupProcessHelper](QtcProcess &process, int processId) { const auto setupCrashProcess = [setupProcessHelper](QtcProcess &process, int processId) {
setupProcessHelper(process, {"-crash"}, processId); setupProcessHelper(process, {"-crash"}, processId);
}; };
const auto readResultAnonymous = [this](const QtcProcess &) { const auto readResultAnonymous = [storage](const QtcProcess &) {
m_log.append({-1, Handler::Done}); storage->m_log.append({-1, Handler::Done});
}; };
const auto readResult = [this](const QtcProcess &process) { const auto readResult = [storage](const QtcProcess &process) {
const int processId = process.property(s_processIdProperty).toInt(); const int processId = process.property(s_processIdProperty).toInt();
m_log.append({processId, Handler::Done}); storage->m_log.append({processId, Handler::Done});
}; };
const auto readError = [this](const QtcProcess &process) { const auto readError = [storage](const QtcProcess &process) {
const int processId = process.property(s_processIdProperty).toInt(); const int processId = process.property(s_processIdProperty).toInt();
m_log.append({processId, Handler::Error}); storage->m_log.append({processId, Handler::Error});
}; };
const auto groupSetup = [this](int processId) { const auto groupSetup = [storage](int processId) {
m_log.append({processId, Handler::GroupSetup}); storage->m_log.append({processId, Handler::GroupSetup});
}; };
const auto groupDone = [this](int processId) { const auto groupDone = [storage](int processId) {
m_log.append({processId, Handler::GroupDone}); storage->m_log.append({processId, Handler::GroupDone});
}; };
const auto rootDone = [this] { const auto rootDone = [storage] {
m_log.append({-1, Handler::GroupDone}); storage->m_log.append({-1, Handler::GroupDone});
}; };
const auto rootError = [this] { const auto rootError = [storage] {
m_log.append({-1, Handler::GroupError}); storage->m_log.append({-1, Handler::GroupError});
}; };
const Group emptyRoot { const Group emptyRoot {
Storage(storage),
OnGroupDone(rootDone) OnGroupDone(rootDone)
}; };
const Log emptyLog{{-1, Handler::GroupDone}}; const Log emptyLog{{-1, Handler::GroupDone}};
QTest::newRow("Empty") << emptyRoot << emptyLog << false << true << 0; QTest::newRow("Empty") << emptyRoot << storage << emptyLog << false << true << 0;
const Group nestedRoot { const Group nestedRoot {
Storage(storage),
Group { Group {
Group { Group {
Group { Group {
@@ -196,9 +209,10 @@ void tst_TaskTree::processTree_data()
{2, Handler::GroupDone}, {2, Handler::GroupDone},
{1, Handler::GroupDone}, {1, Handler::GroupDone},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("Nested") << nestedRoot << nestedLog << true << true << 1; QTest::newRow("Nested") << nestedRoot << storage << nestedLog << true << true << 1;
const Group parallelRoot { const Group parallelRoot {
Storage(storage),
parallel, parallel,
Process(std::bind(setupProcess, _1, 1), readResultAnonymous), Process(std::bind(setupProcess, _1, 1), readResultAnonymous),
Process(std::bind(setupProcess, _1, 2), readResultAnonymous), Process(std::bind(setupProcess, _1, 2), readResultAnonymous),
@@ -218,9 +232,10 @@ void tst_TaskTree::processTree_data()
{-1, Handler::Done}, {-1, Handler::Done},
{-1, Handler::Done}, {-1, Handler::Done},
{-1, Handler::GroupDone}}; // Done handlers may come in different order {-1, Handler::GroupDone}}; // Done handlers may come in different order
QTest::newRow("Parallel") << parallelRoot << parallelLog << true << true << 5; QTest::newRow("Parallel") << parallelRoot << storage << parallelLog << true << true << 5;
const Group sequentialRoot { const Group sequentialRoot {
Storage(storage),
Process(std::bind(setupProcess, _1, 1), readResult), Process(std::bind(setupProcess, _1, 1), readResult),
Process(std::bind(setupProcess, _1, 2), readResult), Process(std::bind(setupProcess, _1, 2), readResult),
Process(std::bind(setupProcess, _1, 3), readResult), Process(std::bind(setupProcess, _1, 3), readResult),
@@ -229,6 +244,7 @@ void tst_TaskTree::processTree_data()
OnGroupDone(rootDone) OnGroupDone(rootDone)
}; };
const Group sequentialEncapsulatedRoot { const Group sequentialEncapsulatedRoot {
Storage(storage),
Group { Group {
Process(std::bind(setupProcess, _1, 1), readResult) Process(std::bind(setupProcess, _1, 1), readResult)
}, },
@@ -248,13 +264,20 @@ void tst_TaskTree::processTree_data()
}; };
auto setupSubTree = [=](TaskTree &taskTree) { auto setupSubTree = [=](TaskTree &taskTree) {
const Group nestedRoot { const Group nestedRoot {
Storage(storage),
Process(std::bind(setupProcess, _1, 2), readResult), Process(std::bind(setupProcess, _1, 2), readResult),
Process(std::bind(setupProcess, _1, 3), readResult), Process(std::bind(setupProcess, _1, 3), readResult),
Process(std::bind(setupProcess, _1, 4), readResult), Process(std::bind(setupProcess, _1, 4), readResult),
}; };
taskTree.setupRoot(nestedRoot); taskTree.setupRoot(nestedRoot);
CustomStorage *activeStorage = storage.activeStorage();
auto collectSubLog = [activeStorage](CustomStorage *subTreeStorage){
activeStorage->m_log += subTreeStorage->m_log;
};
taskTree.onStorageDone(storage, collectSubLog);
}; };
const Group sequentialSubTreeRoot { const Group sequentialSubTreeRoot {
Storage(storage),
Process(std::bind(setupProcess, _1, 1), readResult), Process(std::bind(setupProcess, _1, 1), readResult),
Tree(setupSubTree), Tree(setupSubTree),
Process(std::bind(setupProcess, _1, 5), readResult), Process(std::bind(setupProcess, _1, 5), readResult),
@@ -271,13 +294,14 @@ void tst_TaskTree::processTree_data()
{5, Handler::Setup}, {5, Handler::Setup},
{5, Handler::Done}, {5, Handler::Done},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("Sequential") << sequentialRoot << sequentialLog << true << true << 5; QTest::newRow("Sequential") << sequentialRoot << storage << sequentialLog << true << true << 5;
QTest::newRow("SequentialEncapsulated") << sequentialEncapsulatedRoot << sequentialLog QTest::newRow("SequentialEncapsulated") << sequentialEncapsulatedRoot << storage
<< true << true << 5; << sequentialLog << true << true << 5;
QTest::newRow("SequentialSubTree") << sequentialSubTreeRoot << sequentialLog QTest::newRow("SequentialSubTree") << sequentialSubTreeRoot << storage << sequentialLog
<< true << true << 3; // We don't inspect subtrees << true << true << 3; // We don't inspect subtrees
const Group sequentialNestedRoot { const Group sequentialNestedRoot {
Storage(storage),
Group { Group {
Process(std::bind(setupProcess, _1, 1), readResult), Process(std::bind(setupProcess, _1, 1), readResult),
Group { Group {
@@ -316,10 +340,11 @@ void tst_TaskTree::processTree_data()
{2, Handler::GroupDone}, {2, Handler::GroupDone},
{1, Handler::GroupDone}, {1, Handler::GroupDone},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("SequentialNested") << sequentialNestedRoot << sequentialNestedLog QTest::newRow("SequentialNested") << sequentialNestedRoot << storage << sequentialNestedLog
<< true << true << 5; << true << true << 5;
const Group sequentialErrorRoot { const Group sequentialErrorRoot {
Storage(storage),
Process(std::bind(setupProcess, _1, 1), readResult), Process(std::bind(setupProcess, _1, 1), readResult),
Process(std::bind(setupProcess, _1, 2), readResult), Process(std::bind(setupProcess, _1, 2), readResult),
Process(std::bind(setupCrashProcess, _1, 3), readResult, readError), Process(std::bind(setupCrashProcess, _1, 3), readResult, readError),
@@ -335,11 +360,12 @@ void tst_TaskTree::processTree_data()
{3, Handler::Setup}, {3, Handler::Setup},
{3, Handler::Error}, {3, Handler::Error},
{-1, Handler::GroupError}}; {-1, Handler::GroupError}};
QTest::newRow("SequentialError") << sequentialErrorRoot << sequentialErrorLog QTest::newRow("SequentialError") << sequentialErrorRoot << storage << sequentialErrorLog
<< true << false << 5; << true << false << 5;
const auto constructSimpleSequence = [=](const Workflow &policy) { const auto constructSimpleSequence = [=](const Workflow &policy) {
return Group { return Group {
Storage(storage),
policy, policy,
Process(std::bind(setupProcess, _1, 1), readResult), Process(std::bind(setupProcess, _1, 1), readResult),
Process(std::bind(setupCrashProcess, _1, 2), readResult, readError), Process(std::bind(setupCrashProcess, _1, 2), readResult, readError),
@@ -355,7 +381,7 @@ void tst_TaskTree::processTree_data()
{2, Handler::Setup}, {2, Handler::Setup},
{2, Handler::Error}, {2, Handler::Error},
{-1, Handler::GroupError}}; {-1, Handler::GroupError}};
QTest::newRow("StopOnError") << stopOnErrorRoot << stopOnErrorLog << true << false << 3; QTest::newRow("StopOnError") << stopOnErrorRoot << storage << stopOnErrorLog << true << false << 3;
const Group continueOnErrorRoot = constructSimpleSequence(continueOnError); const Group continueOnErrorRoot = constructSimpleSequence(continueOnError);
const Log continueOnErrorLog{{1, Handler::Setup}, const Log continueOnErrorLog{{1, Handler::Setup},
@@ -365,14 +391,14 @@ void tst_TaskTree::processTree_data()
{3, Handler::Setup}, {3, Handler::Setup},
{3, Handler::Done}, {3, Handler::Done},
{-1, Handler::GroupError}}; {-1, Handler::GroupError}};
QTest::newRow("ContinueOnError") << continueOnErrorRoot << continueOnErrorLog QTest::newRow("ContinueOnError") << continueOnErrorRoot << storage << continueOnErrorLog
<< true << false << 3; << true << false << 3;
const Group stopOnDoneRoot = constructSimpleSequence(stopOnDone); const Group stopOnDoneRoot = constructSimpleSequence(stopOnDone);
const Log stopOnDoneLog{{1, Handler::Setup}, const Log stopOnDoneLog{{1, Handler::Setup},
{1, Handler::Done}, {1, Handler::Done},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("StopOnDone") << stopOnDoneRoot << stopOnDoneLog QTest::newRow("StopOnDone") << stopOnDoneRoot << storage << stopOnDoneLog
<< true << true << 3; << true << true << 3;
const Group continueOnDoneRoot = constructSimpleSequence(continueOnDone); const Group continueOnDoneRoot = constructSimpleSequence(continueOnDone);
@@ -383,9 +409,11 @@ void tst_TaskTree::processTree_data()
{3, Handler::Setup}, {3, Handler::Setup},
{3, Handler::Done}, {3, Handler::Done},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("ContinueOnDone") << continueOnDoneRoot << continueOnDoneLog << true << true << 3; QTest::newRow("ContinueOnDone") << continueOnDoneRoot << storage << continueOnDoneLog
<< true << true << 3;
const Group optionalRoot { const Group optionalRoot {
Storage(storage),
optional, optional,
Process(std::bind(setupCrashProcess, _1, 1), readResult, readError), Process(std::bind(setupCrashProcess, _1, 1), readResult, readError),
Process(std::bind(setupCrashProcess, _1, 2), readResult, readError), Process(std::bind(setupCrashProcess, _1, 2), readResult, readError),
@@ -397,7 +425,7 @@ void tst_TaskTree::processTree_data()
{2, Handler::Setup}, {2, Handler::Setup},
{2, Handler::Error}, {2, Handler::Error},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("Optional") << optionalRoot << optionalLog << true << true << 2; QTest::newRow("Optional") << optionalRoot << storage << optionalLog << true << true << 2;
const auto stopWithDoneSetup = [] { return GroupConfig{GroupAction::StopWithDone}; }; const auto stopWithDoneSetup = [] { return GroupConfig{GroupAction::StopWithDone}; };
const auto stopWithErrorSetup = [] { return GroupConfig{GroupAction::StopWithError}; }; const auto stopWithErrorSetup = [] { return GroupConfig{GroupAction::StopWithError}; };
@@ -405,6 +433,7 @@ void tst_TaskTree::processTree_data()
const auto continueSelSetup = [] { return GroupConfig{GroupAction::ContinueSelected, {0, 2}}; }; const auto continueSelSetup = [] { return GroupConfig{GroupAction::ContinueSelected, {0, 2}}; };
const auto constructDynamicSetup = [=](const DynamicSetup &dynamicSetup) { const auto constructDynamicSetup = [=](const DynamicSetup &dynamicSetup) {
return Group { return Group {
Storage(storage),
Group { Group {
Process(std::bind(setupProcess, _1, 1), readResult) Process(std::bind(setupProcess, _1, 1), readResult)
}, },
@@ -422,14 +451,14 @@ void tst_TaskTree::processTree_data()
const Log dynamicSetupDoneLog{{1, Handler::Setup}, const Log dynamicSetupDoneLog{{1, Handler::Setup},
{1, Handler::Done}, {1, Handler::Done},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("DynamicSetupDone") << dynamicSetupDoneRoot << dynamicSetupDoneLog QTest::newRow("DynamicSetupDone") << dynamicSetupDoneRoot << storage << dynamicSetupDoneLog
<< true << true << 4; << true << true << 4;
const Group dynamicSetupErrorRoot = constructDynamicSetup({stopWithErrorSetup}); const Group dynamicSetupErrorRoot = constructDynamicSetup({stopWithErrorSetup});
const Log dynamicSetupErrorLog{{1, Handler::Setup}, const Log dynamicSetupErrorLog{{1, Handler::Setup},
{1, Handler::Done}, {1, Handler::Done},
{-1, Handler::GroupError}}; {-1, Handler::GroupError}};
QTest::newRow("DynamicSetupError") << dynamicSetupErrorRoot << dynamicSetupErrorLog QTest::newRow("DynamicSetupError") << dynamicSetupErrorRoot << storage << dynamicSetupErrorLog
<< true << false << 4; << true << false << 4;
const Group dynamicSetupAllRoot = constructDynamicSetup({continueAllSetup}); const Group dynamicSetupAllRoot = constructDynamicSetup({continueAllSetup});
@@ -442,7 +471,7 @@ void tst_TaskTree::processTree_data()
{4, Handler::Setup}, {4, Handler::Setup},
{4, Handler::Done}, {4, Handler::Done},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("DynamicSetupAll") << dynamicSetupAllRoot << dynamicSetupAllLog QTest::newRow("DynamicSetupAll") << dynamicSetupAllRoot << storage << dynamicSetupAllLog
<< true << true << 4; << true << true << 4;
const Group dynamicSetupSelRoot = constructDynamicSetup({continueSelSetup}); const Group dynamicSetupSelRoot = constructDynamicSetup({continueSelSetup});
@@ -453,30 +482,40 @@ void tst_TaskTree::processTree_data()
{4, Handler::Setup}, {4, Handler::Setup},
{4, Handler::Done}, {4, Handler::Done},
{-1, Handler::GroupDone}}; {-1, Handler::GroupDone}};
QTest::newRow("DynamicSetupSelected") << dynamicSetupSelRoot << dynamicSetupSelLog QTest::newRow("DynamicSetupSelected") << dynamicSetupSelRoot << storage << dynamicSetupSelLog
<< true << true << 4; << true << true << 4;
} }
void tst_TaskTree::processTree() void tst_TaskTree::processTree()
{ {
m_log = {};
QFETCH(Group, root); QFETCH(Group, root);
QFETCH(TreeStorage<CustomStorage>, storage);
QFETCH(Log, expectedLog); QFETCH(Log, expectedLog);
QFETCH(bool, runningAfterStart); QFETCH(bool, runningAfterStart);
QFETCH(bool, success); QFETCH(bool, success);
QFETCH(int, taskCount); QFETCH(int, taskCount);
QEventLoop eventLoop; QEventLoop eventLoop;
TaskTree processTree(root); TaskTree taskTree(root);
QCOMPARE(processTree.taskCount(), taskCount); QCOMPARE(taskTree.taskCount(), taskCount);
int doneCount = 0; int doneCount = 0;
int errorCount = 0; int errorCount = 0;
connect(&processTree, &TaskTree::done, this, [&doneCount, &eventLoop] { ++doneCount; eventLoop.quit(); }); connect(&taskTree, &TaskTree::done, this, [&doneCount, &eventLoop] {
connect(&processTree, &TaskTree::errorOccurred, this, [&errorCount, &eventLoop] { ++errorCount; eventLoop.quit(); }); ++doneCount;
processTree.start(); eventLoop.quit();
QCOMPARE(processTree.isRunning(), runningAfterStart); });
connect(&taskTree, &TaskTree::errorOccurred, this, [&errorCount, &eventLoop] {
++errorCount;
eventLoop.quit();
});
Log actualLog;
auto collectLog = [&actualLog](CustomStorage *storage){
actualLog = storage->m_log;
};
taskTree.onStorageDone(storage, collectLog);
taskTree.start();
QCOMPARE(taskTree.isRunning(), runningAfterStart);
if (runningAfterStart) { if (runningAfterStart) {
QTimer timer; QTimer timer;
@@ -490,142 +529,10 @@ void tst_TaskTree::processTree()
timer.start(); timer.start();
eventLoop.exec(); eventLoop.exec();
QCOMPARE(timedOut, false); QCOMPARE(timedOut, false);
QCOMPARE(processTree.isRunning(), false); QCOMPARE(taskTree.isRunning(), false);
} }
QCOMPARE(processTree.progressValue(), taskCount); QCOMPARE(taskTree.progressValue(), taskCount);
QCOMPARE(m_log, expectedLog);
const int expectedDoneCount = success ? 1 : 0;
const int expectedErrorCount = success ? 0 : 1;
QCOMPARE(doneCount, expectedDoneCount);
QCOMPARE(errorCount, expectedErrorCount);
}
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;
void tst_TaskTree::storage_data()
{
using namespace std::placeholders;
QTest::addColumn<Group>("root");
QTest::addColumn<TreeStorage<CustomStorage>>("storage");
QTest::addColumn<Log>("expectedLog");
QTest::addColumn<bool>("runningAfterStart");
QTest::addColumn<bool>("success");
TreeStorage<CustomStorage> storageLog;
const auto setupProcessHelper = [storageLog, testAppPath = m_testAppPath]
(QtcProcess &process, const QStringList &args, int processId) {
process.setCommand(CommandLine(testAppPath, args));
process.setProperty(s_processIdProperty, processId);
storageLog->m_log.append({processId, Handler::Setup});
};
const auto setupProcess = [setupProcessHelper](QtcProcess &process, int processId) {
setupProcessHelper(process, {"-return", "0"}, processId);
};
const auto readResult = [storageLog](const QtcProcess &process) {
const int processId = process.property(s_processIdProperty).toInt();
storageLog->m_log.append({processId, Handler::Done});
};
const auto groupSetup = [storageLog](int processId) {
storageLog->m_log.append({processId, Handler::GroupSetup});
};
const auto groupDone = [storageLog](int processId) {
storageLog->m_log.append({processId, Handler::GroupDone});
};
const auto rootDone = [storageLog] {
storageLog->m_log.append({-1, Handler::GroupDone});
};
const Log expectedLog{{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},
{-1, Handler::GroupDone}};
const Group root {
Storage(storageLog),
Group {
Group {
Group {
Group {
Group {
Process(std::bind(setupProcess, _1, 5), readResult),
OnGroupSetup(std::bind(groupSetup, 5)),
OnGroupDone(std::bind(groupDone, 5))
},
OnGroupSetup(std::bind(groupSetup, 4)),
OnGroupDone(std::bind(groupDone, 4))
},
OnGroupSetup(std::bind(groupSetup, 3)),
OnGroupDone(std::bind(groupDone, 3))
},
OnGroupSetup(std::bind(groupSetup, 2)),
OnGroupDone(std::bind(groupDone, 2))
},
OnGroupSetup(std::bind(groupSetup, 1)),
OnGroupDone(std::bind(groupDone, 1))
},
OnGroupDone(rootDone)
};
QTest::newRow("Storage") << root << storageLog << expectedLog << true << true;
}
void tst_TaskTree::storage()
{
QFETCH(Group, root);
QFETCH(TreeStorage<CustomStorage>, storage);
QFETCH(Log, expectedLog);
QFETCH(bool, runningAfterStart);
QFETCH(bool, success);
QVERIFY(storage.isValid());
QCOMPARE(CustomStorage::instanceCount(), 0);
Log actualLog;
QEventLoop eventLoop;
TaskTree processTree(root);
auto collectLog = [&actualLog](CustomStorage *storage){
actualLog = storage->m_log;
};
processTree.onStorageDone(storage, collectLog);
int doneCount = 0;
int errorCount = 0;
connect(&processTree, &TaskTree::done, this, [&doneCount, &eventLoop] { ++doneCount; eventLoop.quit(); });
connect(&processTree, &TaskTree::errorOccurred, this, [&errorCount, &eventLoop] { ++errorCount; eventLoop.quit(); });
processTree.start();
QCOMPARE(CustomStorage::instanceCount(), 1);
QCOMPARE(processTree.isRunning(), runningAfterStart);
QTimer timer;
connect(&timer, &QTimer::timeout, &eventLoop, &QEventLoop::quit);
timer.setInterval(2000);
timer.setSingleShot(true);
timer.start();
eventLoop.exec();
QVERIFY(!processTree.isRunning());
QCOMPARE(actualLog, expectedLog); QCOMPARE(actualLog, expectedLog);
QCOMPARE(CustomStorage::instanceCount(), 0); QCOMPARE(CustomStorage::instanceCount(), 0);
@@ -650,8 +557,8 @@ void tst_TaskTree::storageDestructor()
{ {
QCOMPARE(CustomStorage::instanceCount(), 0); QCOMPARE(CustomStorage::instanceCount(), 0);
{ {
const auto setupProcess = [this](QtcProcess &process) { const auto setupProcess = [testAppPath = m_testAppPath](QtcProcess &process) {
process.setCommand(CommandLine(m_testAppPath, {"-sleep", "1"})); process.setCommand(CommandLine(testAppPath, {"-sleep", "1"}));
}; };
const Group root { const Group root {
Storage(TreeStorage<CustomStorage>()), Storage(TreeStorage<CustomStorage>()),