Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package qt6-tasktree for openSUSE:Factory checked in at 2026-08-21 16:53:06 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/qt6-tasktree (Old) and /work/SRC/openSUSE:Factory/.qt6-tasktree.new.1258 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "qt6-tasktree" Fri Aug 21 16:53:06 2026 rev:3 rq:1372265 version:6.11.2 Changes: -------- --- /work/SRC/openSUSE:Factory/qt6-tasktree/qt6-tasktree.changes 2026-05-28 17:27:39.293496546 +0200 +++ /work/SRC/openSUSE:Factory/.qt6-tasktree.new.1258/qt6-tasktree.changes 2026-08-21 16:54:18.848064940 +0200 @@ -1,0 +2,6 @@ +Tue Aug 18 11:49:27 UTC 2026 - Christophe Marin <[email protected]> + +- Update to 6.11.2 + https://www.qt.io/blog/qt-6.11.2-released + +------------------------------------------------------------------- Old: ---- qttasktree-everywhere-src-6.11.1.tar.xz New: ---- qttasktree-everywhere-src-6.11.2.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ qt6-tasktree.spec ++++++ --- /var/tmp/diff_new_pack.lHnfMA/_old 2026-08-21 16:54:19.783098142 +0200 +++ /var/tmp/diff_new_pack.lHnfMA/_new 2026-08-21 16:54:19.785098213 +0200 @@ -16,7 +16,7 @@ # -%define real_version 6.11.1 +%define real_version 6.11.2 %define short_version 6.11 %define tar_name qttasktree-everywhere-src %define tar_suffix %{nil} @@ -27,7 +27,7 @@ %endif # Name: qt6-tasktree%{?pkg_suffix} -Version: 6.11.1 +Version: 6.11.2 Release: 0 Summary: Generic framework for automatic management of asynchronous tasks License: GPL-2.0-only OR LGPL-3.0-only OR GPL-3.0-only ++++++ qttasktree-everywhere-src-6.11.1.tar.xz -> qttasktree-everywhere-src-6.11.2.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/.cmake.conf new/qttasktree-everywhere-src-6.11.2/.cmake.conf --- old/qttasktree-everywhere-src-6.11.1/.cmake.conf 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/.cmake.conf 2026-08-11 19:38:16.000000000 +0200 @@ -1,4 +1,4 @@ -set(QT_REPO_MODULE_VERSION "6.11.1") +set(QT_REPO_MODULE_VERSION "6.11.2") set(QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT "alpha1") set(QT_REPO_PUBLIC_NAMESPACE_REGEX "^::QtTaskTree.*") set(QT_EXTRA_INTERNAL_TARGET_DEFINES diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/.tag new/qttasktree-everywhere-src-6.11.2/.tag --- old/qttasktree-everywhere-src-6.11.1/.tag 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/.tag 2026-08-11 19:38:16.000000000 +0200 @@ -1 +1 @@ -96d0478128c9deee145d8d8100b84a54754e5e9e +0944a965a99ccc5dc494c71441e9333f1a9a17d6 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/dependencies.yaml new/qttasktree-everywhere-src-6.11.2/dependencies.yaml --- old/qttasktree-everywhere-src-6.11.1/dependencies.yaml 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/dependencies.yaml 2026-08-11 19:38:16.000000000 +0200 @@ -1,4 +1,4 @@ dependencies: ../qtbase: - ref: 59c81a3c2247b821b9b84b4eb8d939b77e07e276 + ref: ef55f427f2c8b410d34f8a7681020a3000cf6866 required: true diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/src/tasktree/qtasktree.cpp new/qttasktree-everywhere-src-6.11.2/src/tasktree/qtasktree.cpp --- old/qttasktree-everywhere-src-6.11.1/src/tasktree/qtasktree.cpp 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/src/tasktree/qtasktree.cpp 2026-08-11 19:38:16.000000000 +0200 @@ -1249,7 +1249,7 @@ The limit is equal to the ideal number of threads excluding the calling thread. - This is a shortcut to: + This is equivalent to: \code ParallelLimit(qMax(QThread::idealThreadCount() - 1, 1)) \endcode @@ -2612,8 +2612,8 @@ addChildren(children); } -GroupItem::GroupItem(const Iterator &loop) - : GroupItem(GroupData{{}, {}, {}, loop}) +GroupItem::GroupItem(const Iterator &iterator) + : GroupItem(GroupData{{}, {}, {}, iterator}) {} GroupItem::GroupItem() @@ -2687,7 +2687,7 @@ } if (child.d->m_groupData.m_iterator) { QT_TASKTREE_ASSERT(!d->m_groupData.m_iterator, - qWarning("Group loop redefinition, overriding...")); + qWarning("Group iterator redefinition, overriding...")); d->m_groupData.m_iterator = child.d->m_groupData.m_iterator; } break; @@ -2698,7 +2698,7 @@ break; case Type::Storage: // Check for duplicates, as can't have the same storage twice on the same level. - for (const StorageBase &storage : child.d->m_storageList) { + for (const StorageBase &storage : std::as_const(child.d->m_storageList)) { if (d->m_storageList.contains(storage)) { QT_TASKTREE_ASSERT(false, qWarning("Can't add the same storage into one Group twice, " "skipping...")); @@ -2868,6 +2868,8 @@ }; } +// AXIVION DISABLE Style Qt-Generic-NoOverloadedOperators: Works in short-circuiting fashion when the recipe is executed + /*! \fn Group ExecutableItem::operator&&(const ExecutableItem &first, const ExecutableItem &second) @@ -2968,6 +2970,8 @@ return { result == DoneResult::Error ? stopOnError : finishAllAndSuccess, item }; } +// AXIVION ENABLE Style Qt-Generic-NoOverloadedOperators + /*! \fn template <typename ObjectSignalGetter> Group ExecutableItem::withCancel(ObjectSignalGetter &&getter, std::initializer_list<GroupItem> postCancelRecipe = {}) const @@ -3410,10 +3414,10 @@ void ExecutionContextActivator::activateContext(RuntimeIteration *iteration) { - std::optional<Iterator> loop = iteration->iterator(); - if (loop) { - loop->d->threadData().pushIteration(iteration->m_iterationIndex); - m_activeIterators.append(*loop); + const std::optional<Iterator> it = iteration->iterator(); + if (it) { + it->d->threadData().pushIteration(iteration->m_iterationIndex); + m_activeIterators.append(*it); } activateContext(iteration->m_container); } @@ -3725,11 +3729,11 @@ bool QTaskTreePrivate::invokeIteratorHandler(RuntimeContainer *container) { if (container->m_shouldIterate) { - const IteratorPrivate *loopData = container->m_containerNode.m_iterator->d.get(); - if (loopData->m_loopCount) { - container->m_shouldIterate = container->m_iterationCount < loopData->m_loopCount; - } else if (loopData->m_condition) { - container->m_shouldIterate = invokeHandler(container, loopData->m_condition, + const IteratorPrivate *p = container->m_containerNode.m_iterator->d.get(); + if (p->m_loopCount) { + container->m_shouldIterate = container->m_iterationCount < p->m_loopCount; + } else if (p->m_condition) { + container->m_shouldIterate = invokeHandler(container, p->m_condition, container->m_iterationCount); } } @@ -4158,6 +4162,15 @@ Q_EMIT done(result, QPrivateSignal()); } +/*! + \fn void QTaskInterface::done(QtTaskTree::DoneResult result) + + This signal is emitted when reportDone() is called, passing the \a result + of the task execution. + + \sa reportDone() +*/ + /*! \reimp */ bool QTaskInterface::event(QEvent *event) { @@ -4382,6 +4395,7 @@ { DoneWith doneWith = DoneWith::Cancel; QEventLoop loop; + // AXIVION Next Line Qt-LambdaInConnect: It's guaranteed &doneWith is still alive when the context object &loop is alive connect(this, &QTaskTree::done, &loop, [&loop, &doneWith](DoneWith result) { doneWith = result; // Otherwise, the tasks from inside the running tree that were deleteLater() @@ -4409,6 +4423,7 @@ DoneWith doneWith = DoneWith::Cancel; QEventLoop loop; + // AXIVION Next Line Qt-LambdaInConnect: It's guaranteed &doneWith is still alive when the context object &loop is alive connect(this, &QTaskTree::done, &loop, [&loop, &doneWith](DoneWith result) { doneWith = result; // Otherwise, the tasks from inside the running tree that were deleteLater() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/src/tasktree/qtasktree.h new/qttasktree-everywhere-src-6.11.2/src/tasktree/qtasktree.h --- old/qttasktree-everywhere-src-6.11.1/src/tasktree/qtasktree.h 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/src/tasktree/qtasktree.h 2026-08-11 19:38:16.000000000 +0200 @@ -140,9 +140,9 @@ Q_TASKTREE_EXPORT qsizetype iteration() const; private: - Q_TASKTREE_EXPORT Iterator(); // LoopForever - Q_TASKTREE_EXPORT Iterator(qsizetype count, const ValueGetter &valueGetter = {}); // LoopRepeat, LoopList - Q_TASKTREE_EXPORT Iterator(const Condition &condition); // LoopUntil + Q_TASKTREE_EXPORT Iterator(); // ForeverIterator + Q_TASKTREE_EXPORT Iterator(qsizetype count, const ValueGetter &valueGetter = {}); // RepeatIterator, ListIterator + Q_TASKTREE_EXPORT Iterator(const Condition &condition); // UntilIterator Q_TASKTREE_EXPORT const void *valuePtr() const; @@ -356,12 +356,14 @@ private: Q_TASKTREE_EXPORT friend Group operator!(const ExecutableItem &item); + // AXIVION DISABLE Style Qt-Generic-NoOverloadedOperators: Works in short-circuiting fashion when the recipe is executed Q_TASKTREE_EXPORT friend Group operator&&(const ExecutableItem &first, const ExecutableItem &second); Q_TASKTREE_EXPORT friend Group operator||(const ExecutableItem &first, const ExecutableItem &second); Q_TASKTREE_EXPORT friend Group operator&&(const ExecutableItem &item, DoneResult result); Q_TASKTREE_EXPORT friend Group operator||(const ExecutableItem &item, DoneResult result); + // AXIVION ENABLE Style Qt-Generic-NoOverloadedOperators using ConnectWrapper = std::function<void(QObject *, const std::function<void()> &)>; @@ -405,8 +407,8 @@ { return [handler = std::forward<Handler>(handler)] { // R, V stands for: Setup[R]esult, [V]oid - constexpr bool isR = isInvocable<SetupResult, Handler>(); - constexpr bool isV = isInvocable<void, Handler>(); + constexpr bool isR = QtTaskTree::isInvocable<SetupResult, Handler>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler>(); static_assert(isR || isV, "Group setup handler needs to take no arguments and has to return void or SetupResult. " "The passed handler doesn't fulfill these requirements."); @@ -422,12 +424,12 @@ return [handler = std::forward<Handler>(handler)](DoneWith result) { constexpr bool isDoneResultType = std::is_same_v<std::decay_t<Handler>, DoneResult>; // R, B, V, D stands for: Done[R]esult, [B]ool, [V]oid, [D]oneWith - constexpr bool isRD = isInvocable<DoneResult, Handler, DoneWith>(); - constexpr bool isR = isInvocable<DoneResult, Handler>(); - constexpr bool isBD = isInvocable<bool, Handler, DoneWith>(); - constexpr bool isB = isInvocable<bool, Handler>(); - constexpr bool isVD = isInvocable<void, Handler, DoneWith>(); - constexpr bool isV = isInvocable<void, Handler>(); + constexpr bool isRD = QtTaskTree::isInvocable<DoneResult, Handler, DoneWith>(); + constexpr bool isR = QtTaskTree::isInvocable<DoneResult, Handler>(); + constexpr bool isBD = QtTaskTree::isInvocable<bool, Handler, DoneWith>(); + constexpr bool isB = QtTaskTree::isInvocable<bool, Handler>(); + constexpr bool isVD = QtTaskTree::isInvocable<void, Handler, DoneWith>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler>(); static_assert(isDoneResultType || isRD || isR || isBD || isB || isVD || isV, "Group done handler should be a function taking (DoneWith) or (void) as an argument " "and returning void, bool or DoneResult. " @@ -565,9 +567,9 @@ template <typename Handler> static auto wrapHandler(Handler &&handler) { // R, B, V stands for: Done[R]esult, [B]ool, [V]oid - constexpr bool isR = isInvocable<DoneResult, Handler>(); - constexpr bool isB = isInvocable<bool, Handler>(); - constexpr bool isV = isInvocable<void, Handler>(); + constexpr bool isR = QtTaskTree::isInvocable<DoneResult, Handler>(); + constexpr bool isB = QtTaskTree::isInvocable<bool, Handler>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler>(); static_assert(isR || isB || isV, "QSyncTask handler needs to take no arguments and has to return void, bool or DoneResult. " "The passed handler doesn't fulfill these requirements."); @@ -698,8 +700,8 @@ } return [handler = std::forward<Handler>(handler)](TaskAdapterPtr voidAdapter) { // R, V stands for: Setup[R]esult, [V]oid - constexpr bool isR = isInvocable<SetupResult, Handler, Task &>(); - constexpr bool isV = isInvocable<void, Handler, Task &>(); + constexpr bool isR = QtTaskTree::isInvocable<SetupResult, Handler, Task &>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler, Task &>(); static_assert(isR || isV, "Task setup handler needs to take (Task &) as an argument and has to return void or " "SetupResult. The passed handler doesn't fulfill these requirements."); @@ -721,18 +723,18 @@ DoneWith result) { constexpr bool isDoneResultType = std::is_same_v<std::decay_t<Handler>, DoneResult>; // R, B, V, T, D stands for: Done[R]esult, [B]ool, [V]oid, [T]ask, [D]oneWith - constexpr bool isRTD = isInvocable<DoneResult, Handler, const Task &, DoneWith>(); - constexpr bool isRT = isInvocable<DoneResult, Handler, const Task &>(); - constexpr bool isRD = isInvocable<DoneResult, Handler, DoneWith>(); - constexpr bool isR = isInvocable<DoneResult, Handler>(); - constexpr bool isBTD = isInvocable<bool, Handler, const Task &, DoneWith>(); - constexpr bool isBT = isInvocable<bool, Handler, const Task &>(); - constexpr bool isBD = isInvocable<bool, Handler, DoneWith>(); - constexpr bool isB = isInvocable<bool, Handler>(); - constexpr bool isVTD = isInvocable<void, Handler, const Task &, DoneWith>(); - constexpr bool isVT = isInvocable<void, Handler, const Task &>(); - constexpr bool isVD = isInvocable<void, Handler, DoneWith>(); - constexpr bool isV = isInvocable<void, Handler>(); + constexpr bool isRTD = QtTaskTree::isInvocable<DoneResult, Handler, const Task &, DoneWith>(); + constexpr bool isRT = QtTaskTree::isInvocable<DoneResult, Handler, const Task &>(); + constexpr bool isRD = QtTaskTree::isInvocable<DoneResult, Handler, DoneWith>(); + constexpr bool isR = QtTaskTree::isInvocable<DoneResult, Handler>(); + constexpr bool isBTD = QtTaskTree::isInvocable<bool, Handler, const Task &, DoneWith>(); + constexpr bool isBT = QtTaskTree::isInvocable<bool, Handler, const Task &>(); + constexpr bool isBD = QtTaskTree::isInvocable<bool, Handler, DoneWith>(); + constexpr bool isB = QtTaskTree::isInvocable<bool, Handler>(); + constexpr bool isVTD = QtTaskTree::isInvocable<void, Handler, const Task &, DoneWith>(); + constexpr bool isVT = QtTaskTree::isInvocable<void, Handler, const Task &>(); + constexpr bool isVD = QtTaskTree::isInvocable<void, Handler, DoneWith>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler>(); static_assert(isDoneResultType || isRTD || isRT || isRD || isR || isBTD || isBT || isBD || isB || isVTD || isVT || isVD || isV, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/src/tasktree/qtasktreerunner.h new/qttasktree-everywhere-src-6.11.2/src/tasktree/qtasktreerunner.h --- old/qttasktree-everywhere-src-6.11.1/src/tasktree/qtasktreerunner.h 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/src/tasktree/qtasktreerunner.h 2026-08-11 19:38:16.000000000 +0200 @@ -34,8 +34,8 @@ } return [handler = std::forward<Handler>(handler)](QTaskTree &taskTree) { // V, T stands for: [V]oid, [T]askTree - constexpr bool isVT = isInvocable<void, Handler, QTaskTree &>(); - constexpr bool isV = isInvocable<void, Handler>(); + constexpr bool isVT = QtTaskTree::isInvocable<void, Handler, QTaskTree &>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler>(); static_assert(isVT || isV, "Tree setup handler needs to take (TaskTree &) or (void) as an argument and has to " "return void. The passed handler doesn't fulfill these requirements."); @@ -54,10 +54,10 @@ } return [handler = std::forward<Handler>(handler)](const QTaskTree &taskTree, DoneWith result) { // V, T, D stands for: [V]oid, [T]askTree, [D]oneWith - constexpr bool isVTD = isInvocable<void, Handler, const QTaskTree &, DoneWith>(); - constexpr bool isVT = isInvocable<void, Handler, const QTaskTree &>(); - constexpr bool isVD = isInvocable<void, Handler, DoneWith>(); - constexpr bool isV = isInvocable<void, Handler>(); + constexpr bool isVTD = QtTaskTree::isInvocable<void, Handler, const QTaskTree &, DoneWith>(); + constexpr bool isVT = QtTaskTree::isInvocable<void, Handler, const QTaskTree &>(); + constexpr bool isVD = QtTaskTree::isInvocable<void, Handler, DoneWith>(); + constexpr bool isV = QtTaskTree::isInvocable<void, Handler>(); static_assert(isVTD || isVT || isVD || isV, "Task done handler needs to take (const TaskTree &, DoneWith), (const Task &), " "(DoneWith) or (void) as arguments and has to return void. " diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/qttasktree-everywhere-src-6.11.1/tests/auto/tasktree/tst_qttasktree.cpp new/qttasktree-everywhere-src-6.11.2/tests/auto/tasktree/tst_qttasktree.cpp --- old/qttasktree-everywhere-src-6.11.1/tests/auto/tasktree/tst_qttasktree.cpp 2026-05-07 21:59:22.000000000 +0200 +++ new/qttasktree-everywhere-src-6.11.2/tests/auto/tasktree/tst_qttasktree.cpp 2026-08-11 19:38:16.000000000 +0200 @@ -3147,28 +3147,28 @@ } { - const UntilIterator loop([](int index) { return index < 3; }); + const UntilIterator iterator([](int index) { return index < 3; }); - const auto onSetupContinue = [storage, loop](int taskId) { - return [storage, loop, taskId](TaskObject &) { - storage->m_log.append({loop.iteration() * 10 + taskId, Handler::Setup}); + const auto onSetupContinue = [storage, iterator](int taskId) { + return [storage, iterator, taskId](TaskObject &) { + storage->m_log.append({iterator.iteration() * 10 + taskId, Handler::Setup}); }; }; - const auto onSetupStop = [storage, loop](int taskId) { - return [storage, loop, taskId](TaskObject &) { - storage->m_log.append({loop.iteration() * 10 + taskId, Handler::Setup}); - if (loop.iteration() == 2) + const auto onSetupStop = [storage, iterator](int taskId) { + return [storage, iterator, taskId](TaskObject &) { + storage->m_log.append({iterator.iteration() * 10 + taskId, Handler::Setup}); + if (iterator.iteration() == 2) return SetupResult::StopWithSuccess; return SetupResult::Continue; }; }; - const auto onDone = [storage, loop](int taskId) { - return [storage, loop, taskId](DoneWith doneWith) { + const auto onDone = [storage, iterator](int taskId) { + return [storage, iterator, taskId](DoneWith doneWith) { const Handler handler = doneWith == DoneWith::Cancel ? Handler::Canceled : doneWith == DoneWith::Success ? Handler::Success : Handler::Error; - storage->m_log.append({loop.iteration() * 10 + taskId, handler}); + storage->m_log.append({iterator.iteration() * 10 + taskId, handler}); }; }; @@ -3178,7 +3178,7 @@ TestTask(onSetupStop(2), onDone(2)) }; - const Group rootSequential = For(loop) >> Do { + const Group rootSequential = For(iterator) >> Do { sequential, items }; @@ -3196,7 +3196,7 @@ {22, Handler::Setup} }; - const Group rootParallel = For(loop) >> Do { + const Group rootParallel = For(iterator) >> Do { parallel, items }; @@ -3214,7 +3214,7 @@ {21, Handler::Success} }; - const Group rootParallelLimit = For(loop) >> Do { + const Group rootParallelLimit = For(iterator) >> Do { ParallelLimit(2), items }; @@ -3232,11 +3232,11 @@ {21, Handler::Success} }; - QTest::newRow("LoopSequential") + QTest::newRow("UntilIteratorSequential") << TestData{storage, rootSequential, logSequential, 2, DoneWith::Success, 5}; - QTest::newRow("LoopParallel") + QTest::newRow("UntilIteratorParallel") << TestData{storage, rootParallel, logParallel, 2, DoneWith::Success, 5}; - QTest::newRow("LoopParallelLimit") + QTest::newRow("UntilIteratorParallelLimit") << TestData{storage, rootParallelLimit, logParallelLimit, 2, DoneWith::Success, 5}; } @@ -3246,7 +3246,7 @@ storage, createSuccessTask(1) }; - QTest::newRow("ProgressWithLoopUntilFalse") + QTest::newRow("ProgressWithUntilIteratorFalse") << TestData{storage, root, {}, 1, DoneWith::Success, 0}; } @@ -3258,12 +3258,12 @@ createSuccessTask(1) } }; - QTest::newRow("ProgressWithNestedLoopUntilFalse") + QTest::newRow("ProgressWithNestedUntilIteratorFalse") << TestData{storage, root, {}, 1, DoneWith::Success, 0}; } { - // Check if UntilIterator is executed with empty loop body. + // Check if UntilIterator's condition is executed with empty loop body. const UntilIterator iterator([storage](int iteration) { storage->m_log.append({iteration, Handler::Iteration}); return iteration < 3; @@ -3278,8 +3278,37 @@ {3, Handler::Iteration} // The last iteration returns false }; - QTest::newRow("EmptyLoopUntil") + QTest::newRow("EmptyUntilIterator") << TestData{storage, root, log, 0, DoneWith::Success, 0}; + + // Check if UntilIterator's condition isn't executed beetween tasks in the body. + const Group root2 = For(iterator) >> Do { + storage, + createSuccessTask(5), + createSuccessTask(6), + }; + + const Log log2 { + {0, Handler::Iteration}, + {5, Handler::Setup}, + {5, Handler::Success}, + {6, Handler::Setup}, + {6, Handler::Success}, + {1, Handler::Iteration}, + {5, Handler::Setup}, + {5, Handler::Success}, + {6, Handler::Setup}, + {6, Handler::Success}, + {2, Handler::Iteration}, + {5, Handler::Setup}, + {5, Handler::Success}, + {6, Handler::Setup}, + {6, Handler::Success}, + {3, Handler::Iteration} // The last iteration returns false + }; + + QTest::newRow("NonEmptyUntilIterator") + << TestData{storage, root2, log2, 2, DoneWith::Success, 6}; } {
