diff options
Diffstat (limited to 'tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp')
-rw-r--r-- | tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp | 160 |
1 files changed, 139 insertions, 21 deletions
diff --git a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp index 8a289ff4e1..35d39aaca2 100644 --- a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp +++ b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp @@ -1,40 +1,32 @@ /**************************************************************************** ** -** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). ** Contact: http://www.qt-project.org/legal ** ** This file is part of the test suite of the Qt Toolkit. ** -** $QT_BEGIN_LICENSE:LGPL$ +** $QT_BEGIN_LICENSE:LGPL21$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and Digia. For licensing terms and -** conditions see http://qt.digia.com/licensing. For further information +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information ** use the contact form at http://qt.digia.com/contact-us. ** ** 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. +** General Public License version 2.1 or version 3 as published by the Free +** Software Foundation and appearing in the file LICENSE.LGPLv21 and +** LICENSE.LGPLv3 included in the packaging of this file. Please review the +** following information to ensure the GNU Lesser General Public License +** requirements will be met: https://www.gnu.org/licenses/lgpl.html and +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Digia gives you certain additional -** rights. These rights are described in the Digia Qt LGPL Exception +** rights. These rights are described in the Digia 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. -** -** ** $QT_END_LICENSE$ ** ****************************************************************************/ @@ -95,8 +87,9 @@ void tst_QtConcurrentRun::runLightFunction() void tst_QtConcurrentRun::runHeavyFunction() { + QThreadPool pool; qDebug("starting function"); - QFuture<void> future = run(heavy); + QFuture<void> future = run(&pool, heavy); qDebug("waiting"); future.waitForFinished(); qDebug("done"); @@ -136,60 +129,95 @@ public: void tst_QtConcurrentRun::returnValue() { + QThreadPool pool; QFuture<int> f; f = run(returnInt0); QCOMPARE(f.result(), 10); + f = run(&pool, returnInt0); + QCOMPARE(f.result(), 10); A a; f = run(&a, &A::member0); QCOMPARE(f.result(), 10); + f = run(&pool, &a, &A::member0); + QCOMPARE(f.result(), 10); f = run(&a, &A::member1, 20); QCOMPARE(f.result(), 20); + f = run(&pool, &a, &A::member1, 20); + QCOMPARE(f.result(), 20); f = run(a, &A::member0); QCOMPARE(f.result(), 10); + f = run(&pool, a, &A::member0); + QCOMPARE(f.result(), 10); f = run(a, &A::member1, 20); QCOMPARE(f.result(), 20); + f = run(&pool, a, &A::member1, 20); + QCOMPARE(f.result(), 20); f = run(a); QCOMPARE(f.result(), 10); + f = run(&pool, a); + QCOMPARE(f.result(), 10); f = run(&a); QCOMPARE(f.result(), 10); + f = run(&pool, &a); + QCOMPARE(f.result(), 10); f = run(a, 20); QCOMPARE(f.result(), 20); + f = run(&pool, a, 20); + QCOMPARE(f.result(), 20); f = run(&a, 20); QCOMPARE(f.result(), 20); + f = run(&pool, &a, 20); + QCOMPARE(f.result(), 20); const AConst aConst = AConst(); f = run(&aConst, &AConst::member0); QCOMPARE(f.result(), 10); + f = run(&pool, &aConst, &AConst::member0); + QCOMPARE(f.result(), 10); f = run(&aConst, &AConst::member1, 20); QCOMPARE(f.result(), 20); + f = run(&pool, &aConst, &AConst::member1, 20); + QCOMPARE(f.result(), 20); f = run(aConst, &AConst::member0); QCOMPARE(f.result(), 10); + f = run(&pool, aConst, &AConst::member0); + QCOMPARE(f.result(), 10); f = run(aConst, &AConst::member1, 20); QCOMPARE(f.result(), 20); + f = run(&pool, aConst, &AConst::member1, 20); + QCOMPARE(f.result(), 20); f = run(aConst); QCOMPARE(f.result(), 10); + f = run(&pool, aConst); + QCOMPARE(f.result(), 10); f = run(&aConst); QCOMPARE(f.result(), 10); + f = run(&pool, &aConst); + QCOMPARE(f.result(), 10); f = run(aConst, 20); QCOMPARE(f.result(), 20); + f = run(&pool, aConst, 20); + QCOMPARE(f.result(), 20); f = run(&aConst, 20); QCOMPARE(f.result(), 20); + f = run(&pool, &aConst, 20); + QCOMPARE(f.result(), 20); } struct TestClass @@ -212,6 +240,7 @@ struct TestConstClass void tst_QtConcurrentRun::functionObject() { + QThreadPool pool; QFuture<void> f; TestClass c; @@ -220,16 +249,28 @@ void tst_QtConcurrentRun::functionObject() f = run(c, 10); f = run(&c, 10); + f = run(&pool, c); + f = run(&pool, &c); + f = run(&pool, c, 10); + f = run(&pool, &c, 10); + const TestConstClass cc = TestConstClass(); f = run(cc); f = run(&cc); f = run(cc, 10); f = run(&cc, 10); + + f = run(&pool, cc); + f = run(&pool, &cc); + f = run(&pool, cc, 10); + f = run(&pool, &cc, 10); } void tst_QtConcurrentRun::memberFunctions() { + QThreadPool pool; + TestClass c; run(c, &TestClass::foo).waitForFinished(); @@ -237,11 +278,21 @@ void tst_QtConcurrentRun::memberFunctions() run(c, &TestClass::fooInt, 10).waitForFinished(); run(&c, &TestClass::fooInt, 10).waitForFinished(); + run(&pool, c, &TestClass::foo).waitForFinished(); + run(&pool, &c, &TestClass::foo).waitForFinished(); + run(&pool, c, &TestClass::fooInt, 10).waitForFinished(); + run(&pool, &c, &TestClass::fooInt, 10).waitForFinished(); + const TestConstClass cc = TestConstClass(); run(cc, &TestConstClass::foo).waitForFinished(); run(&cc, &TestConstClass::foo).waitForFinished(); run(cc, &TestConstClass::fooInt, 10).waitForFinished(); run(&cc, &TestConstClass::fooInt, 10).waitForFinished(); + + run(&pool, cc, &TestConstClass::foo).waitForFinished(); + run(&pool, &cc, &TestConstClass::foo).waitForFinished(); + run(&pool, cc, &TestConstClass::fooInt, 10).waitForFinished(); + run(&pool, &cc, &TestConstClass::fooInt, 10).waitForFinished(); } @@ -273,16 +324,25 @@ void stringIntFunction(QString) void tst_QtConcurrentRun::implicitConvertibleTypes() { + QThreadPool pool; + double d; run(doubleFunction, d).waitForFinished(); + run(&pool, doubleFunction, d).waitForFinished(); int i; run(doubleFunction, d).waitForFinished(); + run(&pool, doubleFunction, d).waitForFinished(); run(doubleFunction, i).waitForFinished(); + run(&pool, doubleFunction, i).waitForFinished(); run(doubleFunction, 10).waitForFinished(); + run(&pool, doubleFunction, 10).waitForFinished(); run(stringFunction, QLatin1String("Foo")).waitForFinished(); + run(&pool, stringFunction, QLatin1String("Foo")).waitForFinished(); run(stringConstRefFunction, QLatin1String("Foo")).waitForFinished(); + run(&pool, stringConstRefFunction, QLatin1String("Foo")).waitForFinished(); QString string; run(stringRefFunction, string).waitForFinished(); + run(&pool, stringRefFunction, string).waitForFinished(); } void fn() { } @@ -382,7 +442,10 @@ int throwFunctionReturn() void tst_QtConcurrentRun::exceptions() { - bool caught = false; + QThreadPool pool; + bool caught; + + caught = false; try { QtConcurrent::run(throwFunction).waitForFinished(); } catch (QException &) { @@ -393,12 +456,30 @@ void tst_QtConcurrentRun::exceptions() caught = false; try { + QtConcurrent::run(&pool, throwFunction).waitForFinished(); + } catch (QException &) { + caught = true; + } + if (!caught) + QFAIL("did not get exception"); + + caught = false; + try { QtConcurrent::run(throwFunctionReturn).waitForFinished(); } catch (QException &) { caught = true; } if (!caught) QFAIL("did not get exception"); + + caught = false; + try { + QtConcurrent::run(&pool, throwFunctionReturn).waitForFinished(); + } catch (QException &) { + caught = true; + } + if (!caught) + QFAIL("did not get exception"); } #endif @@ -438,6 +519,27 @@ void tst_QtConcurrentRun::functor() QtConcurrent::run(f, 1,2,3,4).waitForFinished(); QtConcurrent::run(f, 1,2,3,4,5).waitForFinished(); } + // and now with explicit pool: + QThreadPool pool; + { + QFuture<int> fut = QtConcurrent::run(&pool, f); + QCOMPARE(fut.result(), 42); + } + { + QFuture<double> fut = QtConcurrent::run(&pool, f, 8.5, 1.8); + QCOMPARE(fut.result(), (8.5/1.8)); + } + { + QFuture<int> fut = QtConcurrent::run(&pool, f, 19, 3); + QCOMPARE(fut.result(), int(19/3)); + } + { + QtConcurrent::run(&pool, f, 1).waitForFinished(); + QtConcurrent::run(&pool, f, 1,2).waitForFinished(); + QtConcurrent::run(&pool, f, 1,2,3).waitForFinished(); + QtConcurrent::run(&pool, f, 1,2,3,4).waitForFinished(); + QtConcurrent::run(&pool, f, 1,2,3,4,5).waitForFinished(); + } } #endif @@ -458,6 +560,22 @@ void tst_QtConcurrentRun::lambda() QCOMPARE(r, QStringList({"Hello", "World", "Foo"})); } #endif + + // and now with explicit pool: + QThreadPool pool; + QCOMPARE(QtConcurrent::run(&pool, [](){ return 45; }).result(), 45); + QCOMPARE(QtConcurrent::run(&pool, [](int a){ return a+15; }, 12).result(), 12+15); + QCOMPARE(QtConcurrent::run(&pool, [](int a, double b){ return a + b; }, 12, 15).result(), double(12+15)); + QCOMPARE(QtConcurrent::run(&pool, [](int a , int, int, int, int b){ return a + b; }, 1, 2, 3, 4, 5).result(), 1 + 5); + +#ifdef Q_COMPILER_INITIALIZER_LISTS + { + QString str { "Hello World Foo" }; + QFuture<QStringList> f1 = QtConcurrent::run(&pool, [&](){ return str.split(' '); }); + auto r = f1.result(); + QCOMPARE(r, QStringList({"Hello", "World", "Foo"})); + } +#endif } #endif |