tst_qtconcurrentfilter.cpp

/tests/auto/qtconcurrentfilter/tst_qtconcurrentfilter.cpp

https://bitbucket.org/ultra_iter/qt-vtl · C++ · 1546 lines · 1371 code · 102 blank · 73 comment · 21 complexity · b62fb8afbae2b193c4c7952f4583ce8f MD5 · raw file
Large files are truncated click here to view the full file

/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qtconcurrentfilter.h>
#include <QCoreApplication>
#include <QList>
#include <QLinkedList>
#include <QtTest/QtTest>

#include "../qtconcurrentmap/functions.h"
#include "../qfuture/versioncheck.h"

class tst_QtConcurrentFilter : public QObject
{
    Q_OBJECT

private slots:
    void filter();
    void filtered();
    void filteredReduced();
    void resultAt();
    void incrementalResults();
    void noDetatch();
    void stlContainers();
};

#if !defined (QT_NO_CONCURRENT_TEST) && !defined(QT_NO_CONCURRENT_FILTER)

void tst_QtConcurrentFilter::filter()
{
    // functor
    {
        QList<int> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::filter(list, KeepEvenIntegers()).waitForFinished();
        QCOMPARE(list, QList<int>() << 2 << 4);
    }
    {
        QList<int> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(list, KeepEvenIntegers());
        QCOMPARE(list, QList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::filter(linkedList, KeepEvenIntegers()).waitForFinished();
        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(linkedList, KeepEvenIntegers());
        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
    }
    {
        QVector<int> vector;
        vector << 1 << 2 << 3 << 4;
        QtConcurrent::filter(vector, KeepEvenIntegers()).waitForFinished();
        QCOMPARE(vector, QVector<int>() << 2 << 4);
    }
    {
        QVector<int> vector;
        vector << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(vector, KeepEvenIntegers());
        QCOMPARE(vector, QVector<int>() << 2 << 4);
    }


    // function
    {
        QList<int> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::filter(list, keepEvenIntegers).waitForFinished();
        QCOMPARE(list, QList<int>() << 2 << 4);
    }
    {
        QList<int> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(list, keepEvenIntegers);
        QCOMPARE(list, QList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::filter(linkedList, keepEvenIntegers).waitForFinished();
        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(linkedList, keepEvenIntegers);
        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
    }

    // bound function
    {
        QList<int> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::filter(list, keepEvenIntegers).waitForFinished();
        QCOMPARE(list, QList<int>() << 2 << 4);
    }
    {
        QList<int> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(list, keepEvenIntegers);
        QCOMPARE(list, QList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::filter(linkedList, keepEvenIntegers).waitForFinished();
        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(linkedList, keepEvenIntegers);
        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
    }

    // member
    {
        QList<Number> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::filter(list, &Number::isEven).waitForFinished();
        QCOMPARE(list, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> list;
        list << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(list, &Number::isEven);
        QCOMPARE(list, QList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::filter(linkedList, &Number::isEven).waitForFinished();
        QCOMPARE(linkedList, QLinkedList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QtConcurrent::blockingFilter(linkedList, &Number::isEven);
        QCOMPARE(linkedList, QLinkedList<Number>() << 2 << 4);
    }
}

void tst_QtConcurrentFilter::filtered()
{
    QList<int> list;
    list << 1 << 2 << 3 << 4;

    // functor
    {
        QFuture<int> f = QtConcurrent::filtered(list, KeepEvenIntegers());
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(list.begin(), list.end(), KeepEvenIntegers());
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(list.constBegin(),
                                                list.constEnd(),
                                                KeepEvenIntegers());
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered(list, KeepEvenIntegers());
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered<QList<int> >(list.begin(),
                                                                       list.end(),
                                                                       KeepEvenIntegers());
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered<QList<int> >(list.constBegin(),
                                                                       list.constEnd(),
                                                                       KeepEvenIntegers());
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }

    {
        QVector<int> vector;
        vector << 1 << 2 << 3 << 4;
        QVector<int> vector2 = QtConcurrent::blockingFiltered(vector, KeepEvenIntegers());
        QCOMPARE(vector2, QVector<int>() << 2 << 4);
    }
    {
        QVector<int> vector;
        vector << 1 << 2 << 3 << 4;
        QFuture<int> f = QtConcurrent::filtered(vector, KeepEvenIntegers());
        QCOMPARE(f.results(), QList<int>() << 2 << 4);
    }

    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, KeepEvenIntegers());
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList;
        linkedList << 1 << 2 << 3 << 4;
        QFuture<int> f = QtConcurrent::filtered(linkedList, KeepEvenIntegers());
        QCOMPARE(f.results(), QList<int>() << 2 << 4);
    }

    // function
    {
        QFuture<int> f = QtConcurrent::filtered(list, keepEvenIntegers);
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(list.begin(), list.end(), keepEvenIntegers);
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(list.constBegin(),
                                                list.constEnd(),
                                                keepEvenIntegers);
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered(list, keepEvenIntegers);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered<QList<int> >(list.begin(),
                                                                       list.end(),
                                                                       keepEvenIntegers);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered<QList<int> >(list.constBegin(),
                                                                       list.constEnd(),
                                                                       keepEvenIntegers);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }

    // bound function
    {
        QFuture<int> f = QtConcurrent::filtered(list, keepEvenIntegers);
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(list.begin(), list.end(), keepEvenIntegers);
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(list.constBegin(),
                                                list.constEnd(),
                                                keepEvenIntegers);
        QList<int> list2 = f.results();
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered(list, keepEvenIntegers);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered<QList<int> >(list.begin(),
                                                                       list.end(),
                                                                       keepEvenIntegers);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFiltered<QList<int> >(list.constBegin(),
                                                                       list.constEnd(),
                                                                       keepEvenIntegers);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }

    // const member function
    {
        QList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QFuture<Number> f = QtConcurrent::filtered(integers, &Number::isEven);
        QList<Number> list2 = f.results();
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QFuture<Number> f = QtConcurrent::filtered(integers.begin(),
                                                   integers.end(),
                                                   &Number::isEven);
        QList<Number> list2 = f.results();
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QFuture<Number> f = QtConcurrent::filtered(integers.constBegin(),
                                                   integers.constEnd(),
                                                   &Number::isEven);
        QList<Number> list2 = f.results();
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::blockingFiltered(integers, &Number::isEven);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::blockingFiltered<QList<Number> >(integers.begin(),
                                                                             integers.end(),
                                                                             &Number::isEven);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QList<Number> list2 =
            QtConcurrent::blockingFiltered<QList<Number> >(integers.constBegin(),
                                                           integers.constEnd(),
                                                           &Number::isEven);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }

    // same thing on linked lists

    QLinkedList<int> linkedList;
    linkedList << 1 << 2 << 3 << 4;

    // functor
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList, KeepEvenIntegers());
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList.begin(),
                                                linkedList.end(),
                                                KeepEvenIntegers());
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(),
                                                linkedList.constEnd(),
                                                KeepEvenIntegers());
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, KeepEvenIntegers());
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(),
                                                                                         linkedList.end(),
                                                                                         KeepEvenIntegers());
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(),
                                                                                         linkedList.constEnd(),
                                                                                         KeepEvenIntegers());
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }

    // function
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList, keepEvenIntegers);
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList.begin(),
                                                linkedList.end(),
                                                keepEvenIntegers);
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(),
                                                linkedList.constEnd(),
                                                keepEvenIntegers);
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, keepEvenIntegers);
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(),
                                                                                         linkedList.end(),
                                                                                         keepEvenIntegers);
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(),
                                                                                         linkedList.constEnd(),
                                                                                         keepEvenIntegers);
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }

    // bound function
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList, keepEvenIntegers);
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList.begin(),
                                                linkedList.end(),
                                                keepEvenIntegers);
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(),
                                                linkedList.constEnd(),
                                                keepEvenIntegers);
        QList<int> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, keepEvenIntegers);
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(),
                                                                                         linkedList.end(),
                                                                                         keepEvenIntegers);
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }
    {
        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(),
                                                                                         linkedList.constEnd(),
                                                                                         keepEvenIntegers);
        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
    }

    // const member function
    {
        QLinkedList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QFuture<Number> f = QtConcurrent::filtered(integers, &Number::isEven);
        QList<Number> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QFuture<Number> f = QtConcurrent::filtered(integers.begin(),
                                                   integers.end(),
                                                   &Number::isEven);
        QList<Number> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QFuture<Number> f = QtConcurrent::filtered(integers.constBegin(),
                                                   integers.constEnd(),
                                                   &Number::isEven);
        QList<Number> linkedList2 = f.results();
        QCOMPARE(linkedList2, QList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFiltered(integers, &Number::isEven);
        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<Number> >(integers.begin(),
                                                                                               integers.end(),
                                                                                               &Number::isEven);
        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
    }
    {
        QLinkedList<Number> integers;
        integers << 1 << 2 << 3 << 4;
        QLinkedList<Number> linkedList2 =
            QtConcurrent::blockingFiltered<QLinkedList<Number> >(integers.constBegin(),
                                                                 integers.constEnd(),
                                                                 &Number::isEven);
        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
    }
}

void tst_QtConcurrentFilter::filteredReduced()
{
    QList<int> list;
    list << 1 << 2 << 3 << 4;
    QList<Number> numberList;
    numberList << 1 << 2 << 3 << 4;

    // functor-functor
    {
        int sum = QtConcurrent::filteredReduced<int>(list, KeepEvenIntegers(), IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(list, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        QVector<int> vector;
        vector << 1 << 2 << 3 << 4;
        int sum = QtConcurrent::filteredReduced<int>(vector, KeepEvenIntegers(), IntSumReduce());
        QCOMPARE(sum, 6);
    }

    {
        int sum = QtConcurrent::filteredReduced<int>(list.begin(),
                                                     list.end(),
                                                     KeepEvenIntegers(),
                                                     IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(list.begin(),
                                                      list.end(),
                                                      keepEvenIntegers,
                                                      intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(list.constBegin(),
                                                     list.constEnd(),
                                                     KeepEvenIntegers(),
                                                     IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(list.constBegin(),
                                                      list.constEnd(),
                                                      keepEvenIntegers,
                                                      intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(list, KeepEvenIntegers(), IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(list, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(list.begin(),
                                                             list.end(),
                                                             KeepEvenIntegers(),
                                                             IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(list.begin(),
                                                              list.end(),
                                                              keepEvenIntegers,
                                                              intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(list.constBegin(),
                                                             list.constEnd(),
                                                             KeepEvenIntegers(),
                                                             IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(list.constBegin(),
                                                              list.constEnd(),
                                                              keepEvenIntegers,
                                                              intSumReduce);
        QCOMPARE(sum2, 6);
    }

    // function-functor
    {
        int sum = QtConcurrent::filteredReduced<int>(list, keepEvenIntegers, IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(list.begin(),
                                                     list.end(),
                                                     keepEvenIntegers,
                                                     IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(list.constBegin(),
                                                     list.constEnd(),
                                                     keepEvenIntegers,
                                                     IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(list, keepEvenIntegers, IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(list.begin(),
                                                             list.end(),
                                                             keepEvenIntegers,
                                                             IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(list.constBegin(),
                                                             list.constEnd(),
                                                             keepEvenIntegers,
                                                             IntSumReduce());
        QCOMPARE(sum, 6);
    }

    // functor-function
    {
        int sum = QtConcurrent::filteredReduced(list, KeepEvenIntegers(), intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(list.begin(),
                                                list.end(),
                                                KeepEvenIntegers(),
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(list.constBegin(),
                                                list.constEnd(),
                                                KeepEvenIntegers(),
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(list, KeepEvenIntegers(), intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(list.begin(),
                                                        list.end(),
                                                        KeepEvenIntegers(),
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(list.constBegin(),
                                                        list.constEnd(),
                                                        KeepEvenIntegers(),
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }

    // function-function
    {
        int sum = QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(list.begin(),
                                                list.end(),
                                                keepEvenIntegers,
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(list.constBegin(),
                                                list.constEnd(),
                                                keepEvenIntegers,
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(list.begin(),
                                                        list.end(),
                                                        keepEvenIntegers,
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(list.constBegin(),
                                                        list.constEnd(),
                                                        keepEvenIntegers,
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }

    // functor-member
    {
        QList<int> list2 = QtConcurrent::filteredReduced(list, KeepEvenIntegers(), &QList<int>::push_back, QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::filteredReduced(list.begin(),
                                                         list.end(),
                                                         KeepEvenIntegers(),
                                                         &QList<int>::push_back,
                                                         QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(),
                                                         list.constEnd(),
                                                         KeepEvenIntegers(),
                                                         &QList<int>::push_back,
                                                         QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list, KeepEvenIntegers(), &QList<int>::push_back, QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(),
                                                                 list.end(),
                                                                 KeepEvenIntegers(),
                                                                 &QList<int>::push_back,
                                                                 QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(),
                                                                 list.constEnd(),
                                                                 KeepEvenIntegers(),
                                                                 &QList<int>::push_back,
                                                                 QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }

    // member-functor
    {
        int sum = QtConcurrent::filteredReduced<int>(numberList, &Number::isEven, NumberSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(QList<Number>(numberList),
                                                      &Number::isEven,
                                                      NumberSumReduce());
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(numberList.begin(),
                                                     numberList.end(),
                                                     &Number::isEven,
                                                     NumberSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(numberList.constBegin(),
                                                     numberList.constEnd(),
                                                     &Number::isEven,
                                                     NumberSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(numberList, &Number::isEven, NumberSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(QList<Number>(numberList),
                                                              &Number::isEven,
                                                              NumberSumReduce());
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(numberList.begin(),
                                                             numberList.end(),
                                                             &Number::isEven,
                                                             NumberSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(numberList.constBegin(),
                                                             numberList.constEnd(),
                                                             &Number::isEven,
                                                             NumberSumReduce());
        QCOMPARE(sum, 6);
    }

    // member-member
    {
        QList<Number> numbers;
        numbers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::filteredReduced(numbers,
                                                            &Number::isEven,
                                                            &QList<Number>::push_back, QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> numbers;
        numbers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::filteredReduced(numbers.begin(),
                                                            numbers.end(),
                                                            &Number::isEven,
                                                            &QList<Number>::push_back,
                                                            QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> numbers;
        numbers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::filteredReduced(numbers.constBegin(),
                                                            numbers.constEnd(),
                                                            &Number::isEven,
                                                            &QList<Number>::push_back,
                                                            QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> numbers;
        numbers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers,
                                                                    &Number::isEven,
                                                                    &QList<Number>::push_back, QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> numbers;
        numbers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.begin(),
                                                                    numbers.end(),
                                                                    &Number::isEven,
                                                                    &QList<Number>::push_back,
                                                                    QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }
    {
        QList<Number> numbers;
        numbers << 1 << 2 << 3 << 4;
        QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.constBegin(),
                                                                    numbers.constEnd(),
                                                                    &Number::isEven,
                                                                    &QList<Number>::push_back,
                                                                    QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<Number>() << 2 << 4);
    }

    // function-member
    {
        QList<int> list2 = QtConcurrent::filteredReduced(list, keepEvenIntegers, &QList<int>::push_back, QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::filteredReduced(list.begin(),
                                                         list.end(),
                                                         keepEvenIntegers,
                                                         &QList<int>::push_back,
                                                         QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(),
                                                         list.constEnd(),
                                                         keepEvenIntegers,
                                                         &QList<int>::push_back,
                                                         QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, &QList<int>::push_back, QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(),
                                                                 list.end(),
                                                                 keepEvenIntegers,
                                                                 &QList<int>::push_back,
                                                                 QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }
    {
        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(),
                                                                 list.constEnd(),
                                                                 keepEvenIntegers,
                                                                 &QList<int>::push_back,
                                                                 QtConcurrent::OrderedReduce);
        QCOMPARE(list2, QList<int>() << 2 << 4);
    }

    // member-function
    {
        int sum = QtConcurrent::filteredReduced(numberList, &Number::isEven, numberSumReduce);
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced(QList<Number>(numberList),
                                                 &Number::isEven,
                                                 numberSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(numberList.begin(),
                                                numberList.end(),
                                                &Number::isEven,
                                                numberSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(numberList.constBegin(),
                                                numberList.constEnd(),
                                                &Number::isEven,
                                                numberSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(numberList, &Number::isEven, numberSumReduce);
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced(QList<Number>(numberList),
                                                         &Number::isEven,
                                                         numberSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(numberList.begin(),
                                                        numberList.end(),
                                                        &Number::isEven,
                                                        numberSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(numberList.constBegin(),
                                                        numberList.constEnd(),
                                                        &Number::isEven,
                                                        numberSumReduce);
        QCOMPARE(sum, 6);
    }

    // same as above on linked lists
    QLinkedList<int> linkedList;
    linkedList << 1 << 2 << 3 << 4;
    QLinkedList<Number> numberLinkedList;
    numberLinkedList << 1 << 2 << 3 << 4;

    // functor-functor
    {
        int sum = QtConcurrent::filteredReduced<int>(linkedList, KeepEvenIntegers(), IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(linkedList, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(linkedList.begin(),
                                                     linkedList.end(),
                                                     KeepEvenIntegers(),
                                                     IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(linkedList.begin(),
                                                      linkedList.end(),
                                                      keepEvenIntegers,
                                                      intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(linkedList.constBegin(),
                                                     linkedList.constEnd(),
                                                     KeepEvenIntegers(),
                                                     IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::filteredReduced<int>(linkedList.constBegin(),
                                                      linkedList.constEnd(),
                                                      keepEvenIntegers,
                                                      intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList, KeepEvenIntegers(), IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(),
                                                             linkedList.end(),
                                                             KeepEvenIntegers(),
                                                             IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(),
                                                              linkedList.end(),
                                                              keepEvenIntegers,
                                                              intSumReduce);
        QCOMPARE(sum2, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(),
                                                             linkedList.constEnd(),
                                                             KeepEvenIntegers(),
                                                             IntSumReduce());
        QCOMPARE(sum, 6);

        int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(),
                                                              linkedList.constEnd(),
                                                              keepEvenIntegers,
                                                              intSumReduce);
        QCOMPARE(sum2, 6);
    }

    // function-functor
    {
        int sum = QtConcurrent::filteredReduced<int>(linkedList, keepEvenIntegers, IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(linkedList.begin(),
                                                     linkedList.end(),
                                                     keepEvenIntegers,
                                                     IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced<int>(linkedList.constBegin(),
                                                     linkedList.constEnd(),
                                                     keepEvenIntegers,
                                                     IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList, keepEvenIntegers, IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(),
                                                             linkedList.end(),
                                                             keepEvenIntegers,
                                                             IntSumReduce());
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(),
                                                             linkedList.constEnd(),
                                                             keepEvenIntegers,
                                                             IntSumReduce());
        QCOMPARE(sum, 6);
    }

    // functor-function
    {
        int sum = QtConcurrent::filteredReduced(linkedList, KeepEvenIntegers(), intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(linkedList.begin(),
                                                linkedList.end(),
                                                KeepEvenIntegers(),
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(linkedList.constBegin(),
                                                linkedList.constEnd(),
                                                KeepEvenIntegers(),
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(linkedList, KeepEvenIntegers(), intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(linkedList.begin(),
                                                        linkedList.end(),
                                                        KeepEvenIntegers(),
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(),
                                                        linkedList.constEnd(),
                                                        KeepEvenIntegers(),
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }

    // function-function
    {
        int sum = QtConcurrent::filteredReduced(linkedList, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(linkedList.begin(),
                                                linkedList.end(),
                                                keepEvenIntegers,
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::filteredReduced(linkedList.constBegin(),
                                                linkedList.constEnd(),
                                                keepEvenIntegers,
                                                intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(linkedList, keepEvenIntegers, intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(linkedList.begin(),
                                                        linkedList.end(),
                                                        keepEvenIntegers,
                                                        intSumReduce);
        QCOMPARE(sum, 6);
    }
    {
        int sum = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(),
                                                        linkedList.constEnd(),
                                                        ke…