/****************************************************************************

**

** Copyright (C) 2009 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$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qtconcurrentmap.h>

#include <qtconcurrentexception.h>

#include <qdebug.h>

#include <QThread>

#include <QtTest/QtTest>

#include "functions.h"

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

Q_DECLARE_METATYPE(QVector<int>);

Q_DECLARE_METATYPE(QVector<double>);

Q_DECLARE_METATYPE(QVector<QString>);

Q_DECLARE_METATYPE(QList<int>);

Q_DECLARE_METATYPE(QList<double>);

Q_DECLARE_METATYPE(QList<QString>);

class tst_map: public QObject

{

    Q_OBJECT

private slots:

    void map();

    void blocking_map();

    void mapped();

    void blocking_mapped();

    void mappedReduced();

    void blocking_mappedReduced();

    void assignResult();

    void functionOverloads();

#ifndef QT_NO_EXCEPTIONS

    void exceptions();

#endif

    void incrementalResults();

    void noDetatch();

    void stlContainers();

    void qFutureAssignmentLeak();

    void stressTest();

public slots:

    void throttling();

};

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

using namespace QtConcurrent;

void multiplyBy2Immutable(int x)

{

    x *= 2;

}

class MultiplyBy2Immutable

{

public:

    void operator()(int x)

    {

        x *= 2;

    }

};

void multiplyBy2InPlace(int &x)

{

    x *= 2;

}

class MultiplyBy2InPlace

{

public:

    void operator()(int &x)

    {

        x *= 2;

    }

};

Q_DECLARE_METATYPE(QList<Number>);

void tst_map::map()

{

    // functors take arguments by reference, modifying the sequence in place

    {

        QList<int> list;

        list << 1 << 2 << 3;

        // functor

        QtConcurrent::map(list, MultiplyBy2InPlace()).waitForFinished();

        QCOMPARE(list, QList<int>() << 2 << 4 << 6);

        QtConcurrent::map(list.begin(), list.end(), MultiplyBy2InPlace()).waitForFinished();

        QCOMPARE(list, QList<int>() << 4 << 8 << 12);

        // function

        QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QList<int>() << 8 << 16 << 24);

        QtConcurrent::map(list.begin(), list.end(), multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QList<int>() << 16 << 32 << 48);

        // bound function

        QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QList<int>() << 32 << 64 << 96);

        QtConcurrent::map(list.begin(), list.end(), multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QList<int>() << 64 << 128 << 192);

        // member function

        QList<Number> numberList;

        numberList << 1 << 2 << 3;

        QtConcurrent::map(numberList, &Number::multiplyBy2).waitForFinished();

        QCOMPARE(numberList, QList<Number>() << 2 << 4 << 6);

        QtConcurrent::map(numberList.begin(), numberList.end(), &Number::multiplyBy2).waitForFinished();

        QCOMPARE(numberList, QList<Number>() << 4 << 8 << 12);

    }

    // functors don't take arguments by reference, making these no-ops

    {

        QList<int> list;

        list << 1 << 2 << 3;

        // functor

        QtConcurrent::map(list, MultiplyBy2Immutable()).waitForFinished();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QtConcurrent::map(list.begin(), list.end(), MultiplyBy2Immutable()).waitForFinished();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        // function

        QtConcurrent::map(list, multiplyBy2Immutable).waitForFinished();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QtConcurrent::map(list.begin(), list.end(), multiplyBy2Immutable).waitForFinished();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        // bound function

        QtConcurrent::map(list, multiplyBy2Immutable).waitForFinished();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QtConcurrent::map(list.begin(), list.end(), multiplyBy2Immutable).waitForFinished();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

    }

    // Linked lists and forward iterators

    {

        QLinkedList<int> list;

        list << 1 << 2 << 3;

        // functor

        QtConcurrent::map(list, MultiplyBy2InPlace()).waitForFinished();

        QCOMPARE(list, QLinkedList<int>() << 2 << 4 << 6);

        QtConcurrent::map(list.begin(), list.end(), MultiplyBy2InPlace()).waitForFinished();

        QCOMPARE(list, QLinkedList<int>() << 4 << 8 << 12);

        // function

        QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QLinkedList<int>() << 8 << 16 << 24);

        QtConcurrent::map(list.begin(), list.end(), multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QLinkedList<int>() << 16 << 32 << 48);

        // bound function

        QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QLinkedList<int>() << 32 << 64 << 96);

        QtConcurrent::map(list.begin(), list.end(), multiplyBy2InPlace).waitForFinished();

        QCOMPARE(list, QLinkedList<int>() << 64 << 128 << 192);

        // member function

        QLinkedList<Number> numberList;

        numberList << 1 << 2 << 3;

        QtConcurrent::map(numberList, &Number::multiplyBy2).waitForFinished();

        QCOMPARE(numberList, QLinkedList<Number>() << 2 << 4 << 6);

        QtConcurrent::map(numberList.begin(), numberList.end(), &Number::multiplyBy2).waitForFinished();

        QCOMPARE(numberList, QLinkedList<Number>() << 4 << 8 << 12);

    }

#if 0

    // not allowed: map() with immutable sequences makes no sense

    {

        const QList<int> list = QList<int>() << 1 << 2 << 3;

        QtConcurrent::map(list, MultiplyBy2Immutable());

        QtConcurrent::map(list, multiplyBy2Immutable);

        QtConcurrent::map(list, multiplyBy2Immutable);

    }

#endif

#if 0

    // not allowed: in place modification of a temp copy (since temp copy goes out of scope)

    {

        QList<int> list;

        list << 1 << 2 << 3;

        QtConcurrent::map(QList<int>(list), MultiplyBy2InPlace());

        QtConcurrent::map(QList<int>(list), multiplyBy2);

        QtConcurrent::map(QList<int>(list), multiplyBy2InPlace);

        QList<Number> numberList;

        numberList << 1 << 2 << 3;

        QtConcurrent::map(QList<Number>(numberList), &Number::multiplyBy2);

    }

#endif

#if 0

    // not allowed: map() on a const list, where functors try to modify the items in the list

    {

        const QList<int> list = QList<int>() << 1 << 2 << 3;;

        QtConcurrent::map(list, MultiplyBy2InPlace());

        QtConcurrent::map(list, multiplyBy2InPlace);

        QtConcurrent::map(list, multiplyBy2InPlace);

        const QList<Number> numberList = QList<Number>() << 1 << 2 << 3;

        QtConcurrent::map(numberList, &Number::multiplyBy2);

    }

#endif

}

void tst_map::blocking_map()

{

    // functors take arguments by reference, modifying the sequence in place

    {

        QList<int> list;

        list << 1 << 2 << 3;

        // functor

        QtConcurrent::blockingMap(list, MultiplyBy2InPlace());

        QCOMPARE(list, QList<int>() << 2 << 4 << 6);

        QtConcurrent::blockingMap(list.begin(), list.end(), MultiplyBy2InPlace());

        QCOMPARE(list, QList<int>() << 4 << 8 << 12);

        // function

        QtConcurrent::blockingMap(list, multiplyBy2InPlace);

        QCOMPARE(list, QList<int>() << 8 << 16 << 24);

        QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2InPlace);

        QCOMPARE(list, QList<int>() << 16 << 32 << 48);

        // bound function

        QtConcurrent::blockingMap(list, multiplyBy2InPlace);

        QCOMPARE(list, QList<int>() << 32 << 64 << 96);

        QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2InPlace);

        QCOMPARE(list, QList<int>() << 64 << 128 << 192);

        // member function

        QList<Number> numberList;

        numberList << 1 << 2 << 3;

        QtConcurrent::blockingMap(numberList, &Number::multiplyBy2);

        QCOMPARE(numberList, QList<Number>() << 2 << 4 << 6);

        QtConcurrent::blockingMap(numberList.begin(), numberList.end(), &Number::multiplyBy2);

        QCOMPARE(numberList, QList<Number>() << 4 << 8 << 12);

    }

    // functors don't take arguments by reference, making these no-ops

    {

        QList<int> list;

        list << 1 << 2 << 3;

        // functor

        QtConcurrent::blockingMap(list, MultiplyBy2Immutable());

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QtConcurrent::blockingMap(list.begin(), list.end(), MultiplyBy2Immutable());

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        // function

        QtConcurrent::blockingMap(list, multiplyBy2Immutable);

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2Immutable);

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        // bound function

        QtConcurrent::blockingMap(list, multiplyBy2Immutable);

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2Immutable);

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

    }

    // Linked lists and forward iterators

    {

        QLinkedList<int> list;

        list << 1 << 2 << 3;

        // functor

        QtConcurrent::blockingMap(list, MultiplyBy2InPlace());

        QCOMPARE(list, QLinkedList<int>() << 2 << 4 << 6);

        QtConcurrent::blockingMap(list.begin(), list.end(), MultiplyBy2InPlace());

        QCOMPARE(list, QLinkedList<int>() << 4 << 8 << 12);

        // function

        QtConcurrent::blockingMap(list, multiplyBy2InPlace);

        QCOMPARE(list, QLinkedList<int>() << 8 << 16 << 24);

        QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2InPlace);

        QCOMPARE(list, QLinkedList<int>() << 16 << 32 << 48);

        // bound function

        QtConcurrent::blockingMap(list, multiplyBy2InPlace);

        QCOMPARE(list, QLinkedList<int>() << 32 << 64 << 96);

        QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2InPlace);

        QCOMPARE(list, QLinkedList<int>() << 64 << 128 << 192);

        // member function

        QLinkedList<Number> numberList;

        numberList << 1 << 2 << 3;

        QtConcurrent::blockingMap(numberList, &Number::multiplyBy2);

        QCOMPARE(numberList, QLinkedList<Number>() << 2 << 4 << 6);

        QtConcurrent::blockingMap(numberList.begin(), numberList.end(), &Number::multiplyBy2);

        QCOMPARE(numberList, QLinkedList<Number>() << 4 << 8 << 12);

    }

#if 0

    // not allowed: map() with immutable sequences makes no sense

    {

        const QList<int> list = QList<int>() << 1 << 2 << 3;

        QtConcurrent::blockingMap(list, MultiplyBy2Immutable());

        QtConcurrent::blockkng::map(list, multiplyBy2Immutable);

        QtConcurrent::blockingMap(list, multiplyBy2Immutable);

    }

#endif

#if 0

    // not allowed: in place modification of a temp copy (since temp copy goes out of scope)

    {

        QList<int> list;

        list << 1 << 2 << 3;

        QtConcurrent::blockingMap(QList<int>(list), MultiplyBy2InPlace());

        QtConcurrent::blockingMap(QList<int>(list), multiplyBy2);

        QtConcurrent::blockingMap(QList<int>(list), multiplyBy2InPlace);

        QList<Number> numberList;

        numberList << 1 << 2 << 3;

        QtConcurrent::blockingMap(QList<Number>(numberList), &Number::multiplyBy2);

    }

#endif

#if 0

    // not allowed: map() on a const list, where functors try to modify the items in the list

    {

        const QList<int> list = QList<int>() << 1 << 2 << 3;;

        QtConcurrent::blockingMap(list, MultiplyBy2InPlace());

        QtConcurrent::blockingMap(list, multiplyBy2InPlace);

        QtConcurrent::blockingMap(list, multiplyBy2InPlace);

        const QList<Number> numberList = QList<Number>() << 1 << 2 << 3;

        QtConcurrent::blockingMap(numberList, &Number::multiplyBy2);

    }

#endif

}

int multiplyBy2(int x)

{

    int y = x * 2;

    return y;

}

class MultiplyBy2

{

public:

    typedef int result_type;

    int operator()(int x) const

    {

        int y = x * 2;

        return y;

    }

};

double intToDouble(int x)

{

    return double(x);

}

class IntToDouble

{

public:

    typedef double result_type;

    double operator()(int x) const

    {

        return double(x);

    }

};

int stringToInt(const QString &string)

{

    return string.toInt();

}

class StringToInt

{

public:

    typedef int result_type;

    int operator()(const QString &string) const

    {

        return string.toInt();

    }

};

void tst_map::mapped()

{

    QList<int> list;

    list << 1 << 2 << 3;

    QLinkedList<int> linkedList;

    linkedList << 1 << 2 << 3;

    QList<Number> numberList;

    numberList << 1 << 2 << 3;

    QLinkedList<Number> numberLinkedList;

    numberLinkedList << 1 << 2 << 3;

    // functor

    {

        QList<int> list2 = QtConcurrent::mapped(list, MultiplyBy2()).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list2, QList<int>() << 2 << 4 << 6);

        QList<int> list3 = QtConcurrent::mapped(list.constBegin(),

                                                list.constEnd(),

                                                MultiplyBy2()).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list3, QList<int>() << 2 << 4 << 6);

        QList<int> list4 = QtConcurrent::mapped(QList<int>(list), MultiplyBy2()).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list4, QList<int>() << 2 << 4 << 6);

    }

    {

        QList<int> list2 = QtConcurrent::mapped(linkedList, MultiplyBy2()).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list2, QList<int>() << 2 << 4 << 6);

        QList<int> list3 = QtConcurrent::mapped(linkedList.constBegin(),

                                                linkedList.constEnd(),

                                                MultiplyBy2()).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list3, QList<int>() << 2 << 4 << 6);

        QList<int> list4 =

            QtConcurrent::mapped(QLinkedList<int>(linkedList), MultiplyBy2()).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list4, QList<int>() << 2 << 4 << 6);

    }

    // function

    {

        QList<int> list2 = QtConcurrent::mapped(list, multiplyBy2).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list2, QList<int>() << 2 << 4 << 6);

        QList<int> list3 = QtConcurrent::mapped(list.constBegin(),

                                                list.constEnd(),

                                                multiplyBy2).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list3, QList<int>() << 2 << 4 << 6);

        QList<int> list4 = QtConcurrent::mapped(QList<int>(list), multiplyBy2).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list4, QList<int>() << 2 << 4 << 6);

    }

    {

        QList<int> list2 = QtConcurrent::mapped(linkedList, multiplyBy2).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list2, QList<int>() << 2 << 4 << 6);

        QList<int> list3 = QtConcurrent::mapped(linkedList.constBegin(),

                                                linkedList.constEnd(),

                                                multiplyBy2).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list3, QList<int>() << 2 << 4 << 6);

        QList<int> list4 =

            QtConcurrent::mapped(QLinkedList<int>(linkedList), multiplyBy2).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list4, QList<int>() << 2 << 4 << 6);

    }

    // bound function

    {

        QList<int> list2 = QtConcurrent::mapped(list, multiplyBy2).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list2, QList<int>() << 2 << 4 << 6);

        QList<int> list3 = QtConcurrent::mapped(list.constBegin(),

                                                list.constEnd(),

                                                multiplyBy2).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list3, QList<int>() << 2 << 4 << 6);

        QList<int> list4 = QtConcurrent::mapped(QList<int>(list), multiplyBy2).results();

        QCOMPARE(list, QList<int>() << 1 << 2 << 3);

        QCOMPARE(list4, QList<int>() << 2 << 4 << 6);

    }

    {

        QList<int> list2 = QtConcurrent::mapped(linkedList, multiplyBy2).results();

        QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3);

        QCOMPARE(list2, QList<int>() << 2 << 4 << 6);