1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include <qtconcurrentmap.h>

    42 #include <qtconcurrentexception.h>

    43 

    44 #include <qdebug.h>

    45 #include <QThread>

    46 

    47 #include <QtTest/QtTest>

    48 

    49 #include "functions.h"

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

    51 

    52 Q_DECLARE_METATYPE(QVector<int>);

    53 Q_DECLARE_METATYPE(QVector<double>);

    54 Q_DECLARE_METATYPE(QVector<QString>);

    55 Q_DECLARE_METATYPE(QList<int>);

    56 Q_DECLARE_METATYPE(QList<double>);

    57 Q_DECLARE_METATYPE(QList<QString>);

    58 

    59 class tst_map: public QObject

    60 {

    61     Q_OBJECT

    62 private slots:

    63     void map();

    64     void blocking_map();

    65     void mapped();

    66     void blocking_mapped();

    67     void mappedReduced();

    68     void blocking_mappedReduced();

    69     void assignResult();

    70     void functionOverloads();

    71 #ifndef QT_NO_EXCEPTIONS

    72     void exceptions();

    73 #endif

    74     void incrementalResults();

    75     void noDetatch();

    76     void stlContainers();

    77     void qFutureAssignmentLeak();

    78     void stressTest();

    79 public slots:

    80     void throttling();

    81 };

    82 

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

    84 

    85 using namespace QtConcurrent;

    86 

    87 void multiplyBy2Immutable(int x)

    88 {

    89     x *= 2;

    90 }

    91 

    92 class MultiplyBy2Immutable

    93 {

    94 public:

    95     void operator()(int x)

    96     {

    97         x *= 2;

    98     }

    99 };

   100 

   101 void multiplyBy2InPlace(int &x)

   102 {

   103     x *= 2;

   104 }

   105 

   106 class MultiplyBy2InPlace

   107 {

   108 public:

   109     void operator()(int &x)

   110     {

   111         x *= 2;

   112     }

   113 };

   114 

   115 Q_DECLARE_METATYPE(QList<Number>);

   116 

   117 void tst_map::map()

   118 {

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

   120     {

   121         QList<int> list;

   122         list << 1 << 2 << 3;

   123 

   124         // functor

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

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

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

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

   129 

   130         // function

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

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

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

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

   135 

   136         // bound function

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

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

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

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

   141 

   142         // member function

   143         QList<Number> numberList;

   144         numberList << 1 << 2 << 3;

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

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

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

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

   149     }

   150 

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

   152     {

   153         QList<int> list;

   154         list << 1 << 2 << 3;

   155 

   156         // functor

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

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

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

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

   161 

   162         // function

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

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

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

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

   167 

   168         // bound function

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

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

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

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

   173     }

   174 

   175     // Linked lists and forward iterators

   176     {

   177         QLinkedList<int> list;

   178         list << 1 << 2 << 3;

   179 

   180         // functor

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

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

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

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

   185 

   186         // function

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

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

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

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

   191 

   192         // bound function

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

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

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

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

   197 

   198         // member function

   199         QLinkedList<Number> numberList;

   200         numberList << 1 << 2 << 3;

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

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

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

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

   205     }

   206 

   207 #if 0

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

   209     {

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

   211 

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

   213         QtConcurrent::map(list, multiplyBy2Immutable);

   214         QtConcurrent::map(list, multiplyBy2Immutable);

   215     }

   216 #endif

   217 

   218 #if 0

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

   220     {

   221         QList<int> list;

   222         list << 1 << 2 << 3;

   223 

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

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

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

   227 

   228         QList<Number> numberList;

   229         numberList << 1 << 2 << 3;

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

   231     }

   232 #endif

   233 

   234 #if 0

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

   236     {

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

   238 

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

   240         QtConcurrent::map(list, multiplyBy2InPlace);

   241         QtConcurrent::map(list, multiplyBy2InPlace);

   242 

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

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

   245     }

   246 #endif

   247 }

   248 

   249 void tst_map::blocking_map()

   250 {

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

   252     {

   253         QList<int> list;

   254         list << 1 << 2 << 3;

   255 

   256         // functor

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

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

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

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

   261 

   262         // function

   263         QtConcurrent::blockingMap(list, multiplyBy2InPlace);

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

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

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

   267 

   268         // bound function

   269         QtConcurrent::blockingMap(list, multiplyBy2InPlace);

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

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

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

   273 

   274         // member function

   275         QList<Number> numberList;

   276         numberList << 1 << 2 << 3;

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

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

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

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

   281     }

   282 

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

   284     {

   285         QList<int> list;

   286         list << 1 << 2 << 3;

   287 

   288         // functor

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

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

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

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

   293 

   294         // function

   295         QtConcurrent::blockingMap(list, multiplyBy2Immutable);

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

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

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

   299 

   300         // bound function

   301         QtConcurrent::blockingMap(list, multiplyBy2Immutable);

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

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

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

   305     }

   306 

   307     // Linked lists and forward iterators

   308     {

   309         QLinkedList<int> list;

   310         list << 1 << 2 << 3;

   311 

   312         // functor

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

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

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

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

   317 

   318         // function

   319         QtConcurrent::blockingMap(list, multiplyBy2InPlace);

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

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

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

   323 

   324         // bound function

   325         QtConcurrent::blockingMap(list, multiplyBy2InPlace);

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

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

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

   329 

   330         // member function

   331         QLinkedList<Number> numberList;

   332         numberList << 1 << 2 << 3;

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

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

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

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

   337     }

   338 

   339 #if 0

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

   341     {

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

   343 

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

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

   346         QtConcurrent::blockingMap(list, multiplyBy2Immutable);

   347     }

   348 #endif

   349 

   350 #if 0

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

   352     {

   353         QList<int> list;

   354         list << 1 << 2 << 3;

   355 

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

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

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

   359 

   360         QList<Number> numberList;

   361         numberList << 1 << 2 << 3;

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

   363     }

   364 #endif

   365 

   366 #if 0

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

   368     {

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

   370 

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

   372         QtConcurrent::blockingMap(list, multiplyBy2InPlace);

   373         QtConcurrent::blockingMap(list, multiplyBy2InPlace);

   374 

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

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

   377     }

   378 #endif

   379 }

   380 

   381 int multiplyBy2(int x)

   382 {

   383     int y = x * 2;

   384     return y;

   385 }

   386 

   387 class MultiplyBy2

   388 {

   389 public:

   390     typedef int result_type;

   391 

   392     int operator()(int x) const

   393     {

   394         int y = x * 2;

   395         return y;

   396     }

   397 };

   398 

   399 double intToDouble(int x)

   400 {

   401     return double(x);

   402 }

   403 

   404 class IntToDouble

   405 {

   406 public:

   407     typedef double result_type;

   408 

   409     double operator()(int x) const

   410     {

   411         return double(x);

   412     }

   413 };

   414 

   415 int stringToInt(const QString &string)

   416 {

   417     return string.toInt();

   418 }

   419 

   420 class StringToInt

   421 {

   422 public:

   423     typedef int result_type;

   424 

   425     int operator()(const QString &string) const

   426     {

   427         return string.toInt();

   428     }

   429 };

   430 

   431 void tst_map::mapped()

   432 {

   433     QList<int> list;

   434     list << 1 << 2 << 3;

   435     QLinkedList<int> linkedList;

   436     linkedList << 1 << 2 << 3;

   437     QList<Number> numberList;

   438     numberList << 1 << 2 << 3;

   439     QLinkedList<Number> numberLinkedList;

   440     numberLinkedList << 1 << 2 << 3;

   441 

   442     // functor

   443     {

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

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

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

   447 

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

   449                                                 list.constEnd(),

   450                                                 MultiplyBy2()).results();

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

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

   453 

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

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

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

   457     }

   458     {

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

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

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

   462 

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

   464                                                 linkedList.constEnd(),

   465                                                 MultiplyBy2()).results();

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

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

   468 

   469         QList<int> list4 =

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

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

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

   473     }

   474 

   475     // function

   476     {

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

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

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

   480 

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

   482                                                 list.constEnd(),

   483                                                 multiplyBy2).results();

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

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

   486 

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

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

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

   490     }

   491     {

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

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

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

   495 

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

   497                                                 linkedList.constEnd(),

   498                                                 multiplyBy2).results();

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

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

   501 

   502         QList<int> list4 =

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

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

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

   506     }

   507 

   508     // bound function

   509     {

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

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

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

   513 

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

   515                                                 list.constEnd(),

   516                                                 multiplyBy2).results();

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

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

   519 

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

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

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

   523     }

   524     {

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

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

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

   528 

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

   530                                                 linkedList.constEnd(),

   531                                                 multiplyBy2)

   532                            .results();

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

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

   535 

   536         QList<int> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList), multiplyBy2)

   537                            .results();

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

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

   540     }

   541 

   542     // const member function

   543     {

   544         QList<Number> numberList2 = QtConcurrent::mapped(numberList, &Number::multipliedBy2)

   545                                     .results();

   546         QCOMPARE(numberList, QList<Number>() << 1 << 2 << 3);

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

   548 

   549         QList<Number> numberList3 = QtConcurrent::mapped(numberList.constBegin(),

   550                                                          numberList.constEnd(),

   551                                                          &Number::multipliedBy2)

   552                                     .results();

   553         QCOMPARE(numberList, QList<Number>() << 1 << 2 << 3);

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

   555 

   556         QList<Number> numberList4 = QtConcurrent::mapped(QList<Number>(numberList),

   557                                                          &Number::multipliedBy2)

   558                                     .results();

   559         QCOMPARE(numberList, QList<Number>() << 1 << 2 << 3);

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

   561     }

   562     {

   563         QList<Number> numberList2 = QtConcurrent::mapped(numberLinkedList, &Number::multipliedBy2)

   564                                     .results();

   565         QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3);

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

   567 

   568         QList<Number> numberList3 = QtConcurrent::mapped(numberLinkedList.constBegin(),

   569                                                          numberLinkedList.constEnd(),

   570                                                          &Number::multipliedBy2)

   571                                     .results();

   572         QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3);

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

   574 

   575         QList<Number> numberList4 = QtConcurrent::mapped(QLinkedList<Number>(numberLinkedList),

   576                                                          &Number::multipliedBy2)

   577                                     .results();

   578         QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3);

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

   580     }

   581 

   582     // change the value_type, same container

   583 

   584     // functor

   585     {

   586         QList<double> list2 = QtConcurrent::mapped(list, IntToDouble()).results();

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

   588         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   589 

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

   591                                                    list.constEnd(),

   592                                                    IntToDouble())

   593                               .results();

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

   595         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   596 

   597         QList<double> list4 = QtConcurrent::mapped(QList<int>(list),

   598                                                    IntToDouble())

   599                               .results();

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

   601         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   602     }

   603     {

   604         QList<double> list2 = QtConcurrent::mapped(linkedList, IntToDouble()).results();

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

   606         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   607 

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

   609                                                    linkedList.constEnd(),

   610                                                    IntToDouble())

   611                               .results();

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

   613         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   614 

   615         QList<double> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList),

   616                                                    IntToDouble())

   617                               .results();

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

   619         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   620     }

   621 

   622     // function

   623     {

   624         QList<double> list2 = QtConcurrent::mapped(list, intToDouble).results();

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

   626         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   627 

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

   629                                                    list.constEnd(),

   630                                                    intToDouble)

   631                               .results();

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

   633         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   634 

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

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

   637         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   638     }

   639     {

   640         QList<double> list2 = QtConcurrent::mapped(linkedList, intToDouble).results();

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

   642         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   643 

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

   645                                                    linkedList.constEnd(),

   646                                                    intToDouble)

   647                               .results();

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

   649         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   650 

   651         QList<double> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList), intToDouble)

   652                               .results();

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

   654         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   655     }

   656 

   657     // bound function

   658     {

   659         QList<double> list2 = QtConcurrent::mapped(list, intToDouble).results();

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

   661         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   662 

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

   664                                                    list.constEnd(),

   665                                                    intToDouble)

   666                               .results();

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

   668         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   669 

   670 

   671         QList<double> list4 = QtConcurrent::mapped(QList<int>(list),

   672                                                    intToDouble)

   673                               .results();

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

   675         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   676     }

   677     {

   678         QList<double> list2 = QtConcurrent::mapped(linkedList, intToDouble).results();

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

   680         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   681 

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

   683                                                    linkedList.constEnd(),

   684                                                    intToDouble)

   685                               .results();

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

   687         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   688 

   689 

   690         QList<double> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList),

   691                                                    intToDouble)

   692                               .results();

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

   694         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   695     }

   696 

   697     // const member function

   698     {

   699         QList<QString> list2 = QtConcurrent::mapped(numberList, &Number::toString).results();

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

   701         QCOMPARE(list2, QList<QString>() << "1" << "2" << "3");

   702 

   703         QList<QString> list3 = QtConcurrent::mapped(numberList.constBegin(),

   704                                                     numberList.constEnd(),

   705                                                     &Number::toString)

   706                                .results();

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

   708         QCOMPARE(list3, QList<QString>() << "1" << "2" << "3");

   709 

   710         QList<QString> list4 = QtConcurrent::mapped(QList<Number>(numberList), &Number::toString)

   711                                .results();

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

   713         QCOMPARE(list4, QList<QString>() << "1" << "2" << "3");

   714     }

   715     {

   716         QList<QString> list2 = QtConcurrent::mapped(numberLinkedList, &Number::toString).results();

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

   718         QCOMPARE(list2, QList<QString>() << "1" << "2" << "3");

   719 

   720         QList<QString> list3 = QtConcurrent::mapped(numberLinkedList.constBegin(),

   721                                                     numberLinkedList.constEnd(),

   722                                                     &Number::toString)

   723                                .results();

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

   725         QCOMPARE(list3, QList<QString>() << "1" << "2" << "3");

   726 

   727         QList<QString> list4 = QtConcurrent::mapped(QLinkedList<Number>(numberLinkedList),

   728                                                     &Number::toString)

   729                                .results();

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

   731         QCOMPARE(list4, QList<QString>() << "1" << "2" << "3");

   732     }

   733 

   734     // change the value_type

   735     {

   736         QList<QString> strings = QStringList() << "1" << "2" << "3";

   737         QList<int> list = QtConcurrent::mapped(strings, StringToInt()).results();

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

   739 

   740         QList<int> list2 = QtConcurrent::mapped(strings.constBegin(),

   741                                                 strings.constEnd(),

   742                                                 StringToInt())

   743                            .results();

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

   745     }

   746     {

   747         QList<QString> strings = QStringList() << "1" << "2" << "3";

   748         QList<int> list = QtConcurrent::mapped(strings, stringToInt).results();

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

   750 

   751         QList<int> list2 = QtConcurrent::mapped(strings.constBegin(),

   752                                                 strings.constEnd(),

   753                                                 stringToInt).results();

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

   755     }

   756 

   757     {

   758         QList<int> numberList2 = QtConcurrent::mapped(numberList, &Number::toInt).results();

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

   760 

   761         QList<int> numberList3 = QtConcurrent::mapped(numberList.constBegin(),

   762                                                       numberList.constEnd(),

   763                                                       &Number::toInt)

   764                                  .results();

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

   766     }

   767 

   768     // change the value_type from QStringList

   769     {

   770         QStringList strings = QStringList() << "1" << "2" << "3";

   771         QList<int> list = QtConcurrent::mapped(strings, StringToInt()).results();

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

   773 

   774         QList<int> list2 = QtConcurrent::mapped(strings.constBegin(),

   775                                                 strings.constEnd(),

   776                                                 StringToInt())

   777                            .results();

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

   779     }

   780     {

   781         QStringList strings = QStringList() << "1" << "2" << "3";

   782         QList<int> list = QtConcurrent::mapped(strings, stringToInt).results();

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

   784 

   785         QList<int> list2 = QtConcurrent::mapped(strings.constBegin(),

   786                                                 strings.constEnd(),

   787                                                 stringToInt)

   788                            .results();

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

   790     }

   791 }

   792 

   793 void tst_map::blocking_mapped()

   794 {

   795     QList<int> list;

   796     list << 1 << 2 << 3;

   797     QLinkedList<int> linkedList;

   798     linkedList << 1 << 2 << 3;

   799     QList<Number> numberList;

   800     numberList << 1 << 2 << 3;

   801     QLinkedList<Number> numberLinkedList;

   802     numberLinkedList << 1 << 2 << 3;

   803 

   804     // functor

   805     {

   806         QList<int> list2 = QtConcurrent::blockingMapped(list, MultiplyBy2());

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

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

   809 

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

   811                                                                        list.constEnd(),

   812                                                                        MultiplyBy2());

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

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

   815 

   816         QList<int> list4 = QtConcurrent::blockingMapped(QList<int>(list), MultiplyBy2());

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

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

   819     }

   820     {

   821         QLinkedList<int> linkedList2 = QtConcurrent::blockingMapped(linkedList, MultiplyBy2());

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

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

   824 

   825         QLinkedList<int> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<int> >(linkedList.constBegin(),

   826                                                                        linkedList.constEnd(),

   827                                                                        MultiplyBy2());

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

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

   830 

   831         QLinkedList<int> linkedList4 = QtConcurrent::blockingMapped(QLinkedList<int>(linkedList), MultiplyBy2());

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

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

   834     }

   835 

   836     // function

   837     {

   838         QList<int> list2 = QtConcurrent::blockingMapped(list, multiplyBy2);

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

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

   841 

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

   843                                                              list.constEnd(),

   844                                                              multiplyBy2);

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

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

   847 

   848         QList<int> list4 = QtConcurrent::blockingMapped(QList<int>(list), multiplyBy2);

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

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

   851     }

   852     {

   853         QLinkedList<int> linkedList2 = QtConcurrent::blockingMapped(linkedList, multiplyBy2);

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

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

   856 

   857         QLinkedList<int> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<int> >(linkedList.constBegin(),

   858                                                              linkedList.constEnd(),

   859                                                              multiplyBy2);

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

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

   862 

   863         QLinkedList<int> linkedList4 = QtConcurrent::blockingMapped(QLinkedList<int>(linkedList), multiplyBy2);

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

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

   866     }

   867 

   868     // bound function

   869     {

   870         QList<int> list2 = QtConcurrent::blockingMapped(list, multiplyBy2);

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

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

   873 

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

   875                                                              list.constEnd(),

   876                                                              multiplyBy2);

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

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

   879 

   880         QList<int> list4 = QtConcurrent::blockingMapped(QList<int>(list), multiplyBy2);

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

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

   883     }

   884     {

   885         QLinkedList<int> linkedList2 = QtConcurrent::blockingMapped(linkedList, multiplyBy2);

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

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

   888 

   889         QLinkedList<int> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<int> >(linkedList.constBegin(),

   890                                                              linkedList.constEnd(),

   891                                                              multiplyBy2);

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

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

   894 

   895         QLinkedList<int> linkedList4 = QtConcurrent::blockingMapped(QLinkedList<int>(linkedList), multiplyBy2);

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

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

   898     }

   899 

   900     // const member function

   901     {

   902         QList<Number> numberList2 = QtConcurrent::blockingMapped(numberList, &Number::multipliedBy2);

   903         QCOMPARE(numberList, QList<Number>() << 1 << 2 << 3);

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

   905 

   906         QList<Number> numberList3 = QtConcurrent::blockingMapped<QList<Number> >(numberList.constBegin(),

   907                                                                          numberList.constEnd(),

   908                                                                          &Number::multipliedBy2);

   909         QCOMPARE(numberList, QList<Number>() << 1 << 2 << 3);

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

   911 

   912         QList<Number> numberList4 = QtConcurrent::blockingMapped(QList<Number>(numberList),

   913                                                          &Number::multipliedBy2);

   914         QCOMPARE(numberList, QList<Number>() << 1 << 2 << 3);

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

   916     }

   917     {

   918         QLinkedList<Number> numberLinkedList2 = QtConcurrent::blockingMapped(numberLinkedList, &Number::multipliedBy2);

   919         QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3);

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

   921 

   922         QLinkedList<Number> numberLinkedList3 = QtConcurrent::blockingMapped<QLinkedList<Number> >(numberLinkedList.constBegin(),

   923                                                                          numberLinkedList.constEnd(),

   924                                                                          &Number::multipliedBy2);

   925         QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3);

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

   927 

   928         QLinkedList<Number> numberLinkedList4 = QtConcurrent::blockingMapped(QLinkedList<Number>(numberLinkedList),

   929                                                          &Number::multipliedBy2);

   930         QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3);

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

   932     }

   933 

   934     // change the value_type, same container

   935 

   936     // functor

   937     {

   938         QList<double> list2 = QtConcurrent::blockingMapped<QList<double> >(list, IntToDouble());

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

   940         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   941 

   942         QList<double> list3 = QtConcurrent::blockingMapped<QList<double> >(list.constBegin(),

   943                                                                    list.constEnd(),

   944                                                                    IntToDouble());

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

   946         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   947 

   948         QList<double> list4 = QtConcurrent::blockingMapped<QList<double> >(QList<int>(list),

   949                                                                    IntToDouble());

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

   951         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   952     }

   953     {

   954         QLinkedList<double> linkedList2 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList, IntToDouble());

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

   956         QCOMPARE(linkedList2, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

   957 

   958         QLinkedList<double> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList.constBegin(),

   959                                                                    linkedList.constEnd(),

   960                                                                    IntToDouble());

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

   962         QCOMPARE(linkedList3, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

   963 

   964         QLinkedList<double> linkedList4 = QtConcurrent::blockingMapped<QLinkedList<double> >(QLinkedList<int>(linkedList),

   965                                                                    IntToDouble());

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

   967         QCOMPARE(linkedList4, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

   968     }

   969 

   970     // function

   971     {

   972         QList<double> list2 = QtConcurrent::blockingMapped<QList<double> >(list, intToDouble);

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

   974         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

   975 

   976         QList<double> list3 = QtConcurrent::blockingMapped<QList<double> >(list.constBegin(),

   977                                                                    list.constEnd(),

   978                                                                    intToDouble);

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

   980         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

   981 

   982         QList<double> list4 = QtConcurrent::blockingMapped<QList<double> >(QList<int>(list), intToDouble);

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

   984         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

   985     }

   986     {

   987         QLinkedList<double> linkedList2 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList, intToDouble);

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

   989         QCOMPARE(linkedList2, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

   990 

   991         QLinkedList<double> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList.constBegin(),

   992                                                                    linkedList.constEnd(),

   993                                                                    intToDouble);

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

   995         QCOMPARE(linkedList3, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

   996 

   997         QLinkedList<double> linkedList4 = QtConcurrent::blockingMapped<QLinkedList<double> >(QLinkedList<int>(linkedList), intToDouble);

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

   999         QCOMPARE(linkedList4, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

  1000     }

  1001 

  1002     // bound function

  1003     {

  1004         QList<double> list2 = QtConcurrent::blockingMapped<QList<double> >(list, intToDouble);

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

  1006         QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0);

  1007 

  1008         QList<double> list3 = QtConcurrent::blockingMapped<QList<double> >(list.constBegin(),

  1009                                                                    list.constEnd(),

  1010                                                                    intToDouble);

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

  1012         QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0);

  1013 

  1014 

  1015         QList<double> list4 = QtConcurrent::blockingMapped<QList<double> >(QList<int>(list),

  1016                                                                    intToDouble);

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

  1018         QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0);

  1019     }

  1020     {

  1021         QLinkedList<double> linkedList2 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList, intToDouble);

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

  1023         QCOMPARE(linkedList2, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

  1024 

  1025         QLinkedList<double> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList.constBegin(),

  1026                                                                    linkedList.constEnd(),

  1027                                                                    intToDouble);

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

  1029         QCOMPARE(linkedList3, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

  1030 

  1031 

  1032         QLinkedList<double> linkedList4 = QtConcurrent::blockingMapped<QLinkedList<double> >(QLinkedList<int>(linkedList),

  1033                                                                    intToDouble);

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

  1035         QCOMPARE(linkedList4, QLinkedList<double>() << 1.0 << 2.0 << 3.0);

  1036     }

  1037 

  1038     // const member function

  1039     {

  1040         QList<QString> list2 =

  1041             QtConcurrent::blockingMapped<QList<QString> >(numberList, &Number::toString);

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

  1043         QCOMPARE(list2, QList<QString>() << "1" << "2" << "3");

  1044 

  1045         QList<QString> list3 = QtConcurrent::blockingMapped<QList<QString> >(numberList.constBegin(),

  1046                                                                      numberList.constEnd()

  1047                                                                      , &Number::toString);

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

  1049         QCOMPARE(list3, QList<QString>() << "1" << "2" << "3");

  1050 

  1051         QList<QString> list4 =

  1052             QtConcurrent::blockingMapped<QList<QString> >(QList<Number>(numberList), &Number::toString);

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

  1054         QCOMPARE(list4, QList<QString>() << "1" << "2" << "3");

  1055     }

  1056     {

  1057         QLinkedList<QString> linkedList2 =

  1058             QtConcurrent::blockingMapped<QLinkedList<QString> >(numberLinkedList, &Number::toString);

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

  1060         QCOMPARE(linkedList2, QLinkedList<QString>() << "1" << "2" << "3");

  1061 

  1062         QLinkedList<QString> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<QString> >(numberLinkedList.constBegin(),

  1063                                                                      numberLinkedList.constEnd()

  1064                                                                      , &Number::toString);

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

  1066         QCOMPARE(linkedList3, QLinkedList<QString>() << "1" << "2" << "3");

  1067 

  1068         QLinkedList<QString> linkedList4 =

  1069             QtConcurrent::blockingMapped<QLinkedList<QString> >(QLinkedList<Number>(numberLinkedList), &Number::toString);

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

  1071         QCOMPARE(linkedList4, QLinkedList<QString>() << "1" << "2" << "3");

  1072     }

  1073 

  1074     // change the value_type

  1075     {

  1076         QList<QString> strings = QStringList() << "1" << "2" << "3";

  1077         QList<int> list = QtConcurrent::blockingMapped(strings, StringToInt());

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

  1079 

  1080         QList<int> list2 = QtConcurrent::blockingMapped<QList<int> >(strings.constBegin(),

  1081                                                              strings.constEnd(),

  1082                                                              StringToInt());

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

  1084     }

  1085     {

  1086         QList<QString> strings = QStringList() << "1" << "2" << "3";

  1087         QList<int> list = QtConcurrent::blockingMapped(strings, stringToInt);

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

  1089 

  1090         QList<int> list2 = QtConcurrent::blockingMapped<QList<int> >(strings.constBegin(),

  1091                                                              strings.constEnd(),

  1092                                                              stringToInt);

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

  1094     }

  1095 

  1096     {

  1097         QList<int> numberList2 = QtConcurrent::blockingMapped(numberList, &Number::toInt);

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

  1099 

  1100         QList<int> numberList3 = QtConcurrent::blockingMapped<QList<int> >(numberList.constBegin(),

  1101                                                                    numberList.constEnd(),

  1102                                                                    &Number::toInt);

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

  1104     }

  1105 

  1106     // change the value_type from QStringList

  1107     {

  1108         QStringList strings = QStringList() << "1" << "2" << "3";

  1109         QList<int> list = QtConcurrent::blockingMapped(strings, StringToInt());

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

  1111 

  1112         QList<int> list2 = QtConcurrent::blockingMapped<QList<int> >(strings.constBegin(),

  1113                                                              strings.constEnd(),

  1114                                                              StringToInt());

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

  1116     }

  1117     {

  1118         QStringList strings = QStringList() << "1" << "2" << "3";

  1119         QList<int> list = QtConcurrent::blockingMapped(strings, stringToInt);

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

  1121 

  1122         QList<int> list2 = QtConcurrent::blockingMapped<QList<int> >(strings.constBegin(),

  1123                                                              strings.constEnd(),

  1124                                                              stringToInt);

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

  1126     }

  1127 

  1128     // functor

  1129     {

  1130         QVector<double> list2 = QtConcurrent::blockingMapped<QVector<double> >(list, IntToDouble());

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

  1132         QCOMPARE(list2, QVector<double>() << 1.0 << 2.0 << 3.0);

  1133 

  1134         QVector<double> list3 = QtConcurrent::blockingMapped<QVector<double> >(list.constBegin(),