amass/qtpromise
1
0
Fork 0
mirror of https://github.com/simonbrunel/qtpromise.git synced 2025-07-02 07:15:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Use C++11 curly braces initialization

Browse Source
This commit is contained in:
Simon Brunel
2020-02-17 20:02:26 +01:00
parent 0bfdddd887
commit be5455a8c8
55 changed files with 655 additions and 655 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
tests/auto/qtpromise/benchmark/tst_benchmark.cpp
View File

@ -43,9 +43,9 @@ void tst_benchmark::valueResolve()
{
{ // should move the value when resolved by rvalue
Data::logs().reset();
QPromise<Data>([&](const QPromiseResolve<Data>& resolve) {
resolve(Data(42));
}).wait();
QPromise<Data>{[&](const QPromiseResolve<Data>& resolve) {
resolve(Data{42});
}}.wait();
QCOMPARE(Data::logs().ctor, 1);
QCOMPARE(Data::logs().copy, 0);
@ -54,10 +54,10 @@ void tst_benchmark::valueResolve()
}
{ // should create one copy of the value when resolved by lvalue
Data::logs().reset();
QPromise<Data>([&](const QPromiseResolve<Data>& resolve) {
Data value(42);
QPromise<Data>{[&](const QPromiseResolve<Data>& resolve) {
Data value{42};
resolve(value);
}).wait();
}}.wait();
QCOMPARE(Data::logs().ctor, 1);
QCOMPARE(Data::logs().copy, 1); // copy value to the promise data
@ -70,9 +70,9 @@ void tst_benchmark::valueReject()
{
{ // should not create any data if rejected
Data::logs().reset();
QPromise<Data>([&](const QPromiseResolve<Data>&, const QPromiseReject<Data>& reject) {
reject(QString("foo"));
}).wait();
QPromise<Data>{[&](const QPromiseResolve<Data>&, const QPromiseReject<Data>& reject) {
reject(QString{"foo"});
}}.wait();
QCOMPARE(Data::logs().ctor, 0);
QCOMPARE(Data::logs().copy, 0);
@ -86,7 +86,7 @@ void tst_benchmark::valueThen()
{ // should not copy value on continutation if fulfilled
int value = -1;
Data::logs().reset();
QPromise<Data>::resolve(Data(42)).then([&](const Data& res) {
QPromise<Data>::resolve(Data{42}).then([&](const Data& res) {
value = res.value();
}).wait();
@ -100,7 +100,7 @@ void tst_benchmark::valueThen()
int value = -1;
QString error;
Data::logs().reset();
QPromise<Data>::reject(QString("foo")).then([&](const Data& res) {
QPromise<Data>::reject(QString{"foo"}).then([&](const Data& res) {
value = res.value();
}, [&](const QString& err) {
error = err;
@ -110,14 +110,14 @@ void tst_benchmark::valueThen()
QCOMPARE(Data::logs().copy, 0);
QCOMPARE(Data::logs().move, 0);
QCOMPARE(Data::logs().refs, 0);
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
QCOMPARE(value, -1);
}
{ // should move the returned value when fulfilled
int value = -1;
Data::logs().reset();
QPromise<int>::resolve(42).then([&](int res) {
return Data(res+2);
return Data{res+2};
}).then([&](const Data& res) {
value = res.value();
}).wait();
@ -131,8 +131,8 @@ void tst_benchmark::valueThen()
{ // should not create any data if handler throws
Data::logs().reset();
QPromise<int>::resolve(42).then([&](int res) {
throw QString("foo");
return Data(res+2);
throw QString{"foo"};
return Data{res+2};
}).wait();
QCOMPARE(Data::logs().ctor, 0);
@ -148,7 +148,7 @@ void tst_benchmark::valueDelayed()
int value = -1;
Data::logs().reset();
QPromise<int>::resolve(42).then([&](int res) {
return QPromise<Data>::resolve(Data(res + 1));
return QPromise<Data>::resolve(Data{res + 1});
}).then([&](const Data& res) {
value = res.value();
}).wait();
@ -162,7 +162,7 @@ void tst_benchmark::valueDelayed()
{ // should not create value on continutation if rejected
Data::logs().reset();
QPromise<int>::resolve(42).then([&]() {
return QPromise<Data>::reject(QString("foo"));
return QPromise<Data>::reject(QString{"foo"});
}).wait();
QCOMPARE(Data::logs().ctor, 0);
@ -177,7 +177,7 @@ void tst_benchmark::valueFinally()
{ // should not copy the value on continutation if fulfilled
int value = -1;
Data::logs().reset();
QPromise<Data>::resolve(Data(42)).finally([&]() {
QPromise<Data>::resolve(Data{42}).finally([&]() {
value = 42;
}).wait();
@ -190,7 +190,7 @@ void tst_benchmark::valueFinally()
{ // should not create value on continutation if rejected
int value = -1;
Data::logs().reset();
QPromise<Data>::reject(QString("foo")).finally([&]() {
QPromise<Data>::reject(QString{"foo"}).finally([&]() {
value = 42;
}).wait();
@ -207,7 +207,7 @@ void tst_benchmark::valueTap()
{ // should not copy the value on continutation if fulfilled
int value = -1;
Data::logs().reset();
QPromise<Data>::resolve(Data(42)).tap([&](const Data& res) {
QPromise<Data>::resolve(Data{42}).tap([&](const Data& res) {
value = res.value();
}).wait();
@ -220,7 +220,7 @@ void tst_benchmark::valueTap()
{ // should not create value on continutation if rejected
int value = -1;
Data::logs().reset();
QPromise<Data>::reject(QString("foo")).tap([&](const Data& res) {
QPromise<Data>::reject(QString{"foo"}).tap([&](const Data& res) {
value = res.value();
}).wait();
@ -236,9 +236,9 @@ void tst_benchmark::errorReject()
{
{ // should create one copy of the error when rejected by rvalue
Data::logs().reset();
QPromise<int>([&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
reject(Data(42));
}).wait();
QPromise<int>{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
reject(Data{42});
}}.wait();
QCOMPARE(Data::logs().ctor, 1);
QCOMPARE(Data::logs().copy, 1 + EXCEPT_CALL_COPY_CTOR); // copy value in std::exception_ptr
@ -247,10 +247,10 @@ void tst_benchmark::errorReject()
}
{ // should create one copy of the error when rejected by lvalue (no extra copy)
Data::logs().reset();
QPromise<int>([&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
Data error(42);
QPromise<int>{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
Data error{42};
reject(error);
}).wait();
}}.wait();
QCOMPARE(Data::logs().ctor, 1);
QCOMPARE(Data::logs().copy, 1 + EXCEPT_CALL_COPY_CTOR); // copy value to the promise data
@ -264,7 +264,7 @@ void tst_benchmark::errorThen()
{ // should not copy error on continutation if rejected
int value = -1;
Data::logs().reset();
QPromise<void>::reject(Data(42)).fail([&](const Data& res) {
QPromise<void>::reject(Data{42}).fail([&](const Data& res) {
value = res.value();
}).wait();
@ -277,7 +277,7 @@ void tst_benchmark::errorThen()
{ // should not copy error on continutation if rethrown
int value = -1;
Data::logs().reset();
QPromise<void>::reject(Data(42)).fail([](const Data&) {
QPromise<void>::reject(Data{42}).fail([](const Data&) {
throw;
}).fail([&](const Data& res) {
value = res.value();

20
tests/auto/qtpromise/deprecations/tst_helpers_qpromise.cpp
View File

@ -72,7 +72,7 @@ void tst_deprecations_helpers_qpromise::moveRValue()
Data::logs().reset();
{
auto p = qPromise(Data(42)).wait();
auto p = qPromise(Data{42}).wait();
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Data>>::value));
}
@ -88,7 +88,7 @@ void tst_deprecations_helpers_qpromise::copyLValue()
Data::logs().reset();
{
Data value(42);
Data value{42};
auto p = qPromise(value).wait();
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Data>>::value));
@ -119,8 +119,8 @@ void tst_deprecations_helpers_qpromise::qtSharedPtr()
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<QSharedPointer<Data>>>::value));
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<QSharedPointer<Data>>>::value));
QCOMPARE(waitForValue(p1, QSharedPointer<Data>()), sptr0);
QCOMPARE(waitForValue(p2, QSharedPointer<Data>()), sptr1);
QCOMPARE(waitForValue(p1, QSharedPointer<Data>{}), sptr0);
QCOMPARE(waitForValue(p2, QSharedPointer<Data>{}), sptr1);
wptr = sptr0;
@ -155,8 +155,8 @@ void tst_deprecations_helpers_qpromise::stdSharedPtr()
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<std::shared_ptr<Data>>>::value));
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<std::shared_ptr<Data>>>::value));
QCOMPARE(waitForValue(p1, std::shared_ptr<Data>()), sptr0);
QCOMPARE(waitForValue(p2, std::shared_ptr<Data>()), sptr1);
QCOMPARE(waitForValue(p1, std::shared_ptr<Data>{}), sptr0);
QCOMPARE(waitForValue(p2, std::shared_ptr<Data>{}), sptr1);
wptr = sptr0;
@ -180,10 +180,10 @@ void tst_deprecations_helpers_qpromise::typedPromise()
});
};
QPromise<int> v0(resolver);
QPromise<int> v0{resolver};
const QPromise<int> v1 = v0;
auto p0 = qPromise(QPromise<int>(resolver));
auto p0 = qPromise(QPromise<int>{resolver});
auto p1 = qPromise(v0);
auto p2 = qPromise(v1);
@ -207,10 +207,10 @@ void tst_deprecations_helpers_qpromise::voidPromise()
});
};
QPromise<void> v0(resolver);
QPromise<void> v0{resolver};
const QPromise<void> v1 = v0;
auto p0 = qPromise(QPromise<void>(resolver));
auto p0 = qPromise(QPromise<void>{resolver});
auto p1 = qPromise(v0);
auto p2 = qPromise(v1);

32
tests/auto/qtpromise/deprecations/tst_helpers_qpromiseall.cpp
View File

@ -54,7 +54,7 @@ struct SequenceTester
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 46, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 46, 43, 44}));
}
};
@ -89,7 +89,7 @@ void tst_deprecations_helpers_qpromiseall::emptySequence()
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({}));
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
}
void tst_deprecations_helpers_qpromiseall::emptySequence_void()
@ -105,11 +105,11 @@ void tst_deprecations_helpers_qpromiseall::allPromisesSucceed()
{
auto p0 = QtPromise::resolve(42);
auto p1 = QtPromise::resolve(44);
auto p2 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p2 = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=](){
resolve(43);
});
});
}};
auto p = qPromiseAll(QVector<QPromise<int>>{p0, p2, p1});
@ -118,7 +118,7 @@ void tst_deprecations_helpers_qpromiseall::allPromisesSucceed()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(p2.isFulfilled(), true);
}
@ -126,11 +126,11 @@ void tst_deprecations_helpers_qpromiseall::allPromisesSucceed_void()
{
auto p0 = QtPromise::resolve();
auto p1 = QtPromise::resolve();
auto p2 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
auto p2 = QPromise<void>{[](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=](){
resolve();
});
});
}};
auto p = qPromiseAll(QVector<QPromise<void>>{p0, p2, p1});
@ -147,11 +147,11 @@ void tst_deprecations_helpers_qpromiseall::atLeastOnePromiseReject()
{
auto p0 = QtPromise::resolve(42);
auto p1 = QtPromise::resolve(44);
auto p2 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p2 = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=](){
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p = qPromiseAll(QVector<QPromise<int>>{p0, p2, p1});
@ -160,7 +160,7 @@ void tst_deprecations_helpers_qpromiseall::atLeastOnePromiseReject()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p2.isRejected(), true);
}
@ -168,11 +168,11 @@ void tst_deprecations_helpers_qpromiseall::atLeastOnePromiseReject_void()
{
auto p0 = QtPromise::resolve();
auto p1 = QtPromise::resolve();
auto p2 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
auto p2 = QPromise<void>{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=](){
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p = qPromiseAll(QVector<QPromise<void>>{p0, p2, p1});
@ -181,7 +181,7 @@ void tst_deprecations_helpers_qpromiseall::atLeastOnePromiseReject_void()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p2.isRejected(), true);
}
@ -198,7 +198,7 @@ void tst_deprecations_helpers_qpromiseall::preserveOrder()
QCOMPARE(p1.isPending(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(p0.isFulfilled(), true);
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isFulfilled(), true);

32
tests/auto/qtpromise/deprecations/tst_qpromise_all.cpp
View File

@ -55,7 +55,7 @@ struct SequenceTester
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 46, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 46, 43, 44}));
}
};
@ -92,7 +92,7 @@ void tst_deprecations_qpromise_all::emptySequence()
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>{});
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
}
void tst_deprecations_qpromise_all::emptySequence_void()
@ -109,11 +109,11 @@ void tst_deprecations_qpromise_all::allPromisesSucceed()
{
auto p0 = QtPromise::resolve(42);
auto p1 = QtPromise::resolve(44);
auto p2 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p2 = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=](){
resolve(43);
});
});
}};
auto p = QPromise<int>::all(QVector<QPromise<int>>{p0, p2, p1});
@ -123,7 +123,7 @@ void tst_deprecations_qpromise_all::allPromisesSucceed()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(p2.isFulfilled(), true);
}
@ -131,11 +131,11 @@ void tst_deprecations_qpromise_all::allPromisesSucceed_void()
{
auto p0 = QtPromise::resolve();
auto p1 = QtPromise::resolve();
auto p2 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
auto p2 = QPromise<void>{[](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=](){
resolve();
});
});
}};
auto p = QPromise<void>::all(QVector<QPromise<void>>{p0, p2, p1});
@ -153,11 +153,11 @@ void tst_deprecations_qpromise_all::atLeastOnePromiseReject()
{
auto p0 = QtPromise::resolve(42);
auto p1 = QtPromise::resolve(44);
auto p2 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p2 = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=](){
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p = QPromise<int>::all(QVector<QPromise<int>>{p0, p2, p1});
@ -167,7 +167,7 @@ void tst_deprecations_qpromise_all::atLeastOnePromiseReject()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p2.isRejected(), true);
}
@ -175,11 +175,11 @@ void tst_deprecations_qpromise_all::atLeastOnePromiseReject_void()
{
auto p0 = QtPromise::resolve();
auto p1 = QtPromise::resolve();
auto p2 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
auto p2 = QPromise<void>{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=](){
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p = QPromise<void>::all(QVector<QPromise<void>>{p0, p2, p1});
@ -189,7 +189,7 @@ void tst_deprecations_qpromise_all::atLeastOnePromiseReject_void()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p2.isRejected(), true);
}
@ -207,7 +207,7 @@ void tst_deprecations_qpromise_all::preserveOrder()
QCOMPARE(p1.isPending(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(p0.isFulfilled(), true);
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isFulfilled(), true);

50
tests/auto/qtpromise/future/tst_future.cpp
View File

@ -38,13 +38,13 @@ class MyException : public QException
{
public:
MyException(const QString& error)
: m_error(error)
: m_error{error}
{ }
const QString& error() const { return m_error; }
void raise() const { throw *this; }
MyException* clone() const { return new MyException(*this); }
MyException* clone() const { return new MyException{*this}; }
private:
QString m_error;
@ -91,7 +91,7 @@ void tst_future::rejected()
{
QString error;
auto p = QtPromise::resolve(QtConcurrent::run([]() {
throw MyException("foo");
throw MyException{"foo"};
return 42;
}));
@ -104,14 +104,14 @@ void tst_future::rejected()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
}
void tst_future::rejected_void()
{
QString error;
auto p = QtPromise::resolve(QtConcurrent::run([]() {
throw MyException("foo");
throw MyException{"foo"};
}));
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
@ -123,14 +123,14 @@ void tst_future::rejected_void()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
}
void tst_future::unhandled()
{
QString error;
auto p = QtPromise::resolve(QtConcurrent::run([]() {
throw QString("foo");
throw QString{"foo"};
return 42;
}));
@ -147,14 +147,14 @@ void tst_future::unhandled()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("bar"));
QCOMPARE(error, QString{"bar"});
}
void tst_future::unhandled_void()
{
QString error;
auto p = QtPromise::resolve(QtConcurrent::run([]() {
throw QString("foo");
throw QString{"foo"};
}));
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
@ -167,7 +167,7 @@ void tst_future::unhandled_void()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("bar"));
QCOMPARE(error, QString{"bar"});
}
void tst_future::canceled()
@ -183,7 +183,7 @@ void tst_future::canceled()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("canceled"));
QCOMPARE(error, QString{"canceled"});
}
void tst_future::canceled_void()
@ -198,14 +198,14 @@ void tst_future::canceled_void()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("canceled"));
QCOMPARE(error, QString{"canceled"});
}
void tst_future::canceledFromThread()
{
QString error;
auto p = QtPromise::resolve(QtConcurrent::run([]() {
throw QPromiseCanceledException();
throw QPromiseCanceledException{};
}));
QCOMPARE(p.isPending(), true);
@ -215,7 +215,7 @@ void tst_future::canceledFromThread()
}).wait();
QCOMPARE(p.isRejected(), true);
QCOMPARE(error, QString("bar"));
QCOMPARE(error, QString{"bar"});
}
void tst_future::then()
@ -224,7 +224,7 @@ void tst_future::then()
auto input = QtPromise::resolve(42);
auto output = input.then([](int res) {
return QtConcurrent::run([=]() {
return QString("foo%1").arg(res);
return QString{"foo%1"}.arg(res);
});
});
@ -236,7 +236,7 @@ void tst_future::then()
}).wait();
QCOMPARE(output.isFulfilled(), true);
QCOMPARE(result, QString("foo42"));
QCOMPARE(result, QString{"foo42"});
}
void tst_future::then_void()
@ -257,16 +257,16 @@ void tst_future::then_void()
}).wait();
QCOMPARE(input.isFulfilled(), true);
QCOMPARE(result, QString("foobar"));
QCOMPARE(result, QString{"foobar"});
}
void tst_future::fail()
{
QString result;
auto input = QPromise<QString>::reject(MyException("bar"));
auto input = QPromise<QString>::reject(MyException{"bar"});
auto output = input.fail([](const MyException& e) {
return QtConcurrent::run([](const QString& error) {
return QString("foo%1").arg(error);
return QString{"foo%1"}.arg(error);
}, e.error());
});
@ -278,13 +278,13 @@ void tst_future::fail()
}).wait();
QCOMPARE(output.isFulfilled(), true);
QCOMPARE(result, QString("foobar"));
QCOMPARE(result, QString{"foobar"});
}
void tst_future::fail_void()
{
QString result;
auto input = QPromise<void>::reject(MyException("bar"));
auto input = QPromise<void>::reject(MyException{"bar"});
auto output = input.fail([&](const MyException& e) {
return QtConcurrent::run([&](const QString& error) {
result = error;
@ -299,7 +299,7 @@ void tst_future::fail_void()
}).wait();
QCOMPARE(output.isFulfilled(), true);
QCOMPARE(result, QString("foobar"));
QCOMPARE(result, QString{"foobar"});
}
void tst_future::finally()
@ -307,7 +307,7 @@ void tst_future::finally()
auto input = QtPromise::resolve(42);
auto output = input.finally([]() {
return QtConcurrent::run([]() {
return QString("foo");
return QString{"foo"};
});
});
@ -330,7 +330,7 @@ void tst_future::finallyRejected()
auto input = QtPromise::resolve(42);
auto output = input.finally([]() {
return QtConcurrent::run([]() {
throw MyException("foo");
throw MyException{"foo"};
});
});
@ -346,5 +346,5 @@ void tst_future::finallyRejected()
}).wait();
QCOMPARE(output.isRejected(), true);
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
}

32
tests/auto/qtpromise/helpers/tst_all.cpp
View File

@ -54,7 +54,7 @@ struct SequenceTester
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 46, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 46, 43, 44}));
}
};
@ -89,7 +89,7 @@ void tst_helpers_all::emptySequence()
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({}));
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
}
void tst_helpers_all::emptySequence_void()
@ -105,11 +105,11 @@ void tst_helpers_all::allPromisesSucceed()
{
auto p0 = QtPromise::resolve(42);
auto p1 = QtPromise::resolve(44);
auto p2 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p2 = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=](){
resolve(43);
});
});
}};
auto p = QtPromise::all(QVector<QPromise<int>>{p0, p2, p1});
@ -118,7 +118,7 @@ void tst_helpers_all::allPromisesSucceed()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(p2.isFulfilled(), true);
}
@ -126,11 +126,11 @@ void tst_helpers_all::allPromisesSucceed_void()
{
auto p0 = QtPromise::resolve();
auto p1 = QtPromise::resolve();
auto p2 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
auto p2 = QPromise<void>{[](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=](){
resolve();
});
});
}};
auto p = QtPromise::all(QVector<QPromise<void>>{p0, p2, p1});
@ -147,11 +147,11 @@ void tst_helpers_all::atLeastOnePromiseReject()
{
auto p0 = QtPromise::resolve(42);
auto p1 = QtPromise::resolve(44);
auto p2 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p2 = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=](){
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p = QtPromise::all(QVector<QPromise<int>>{p0, p2, p1});
@ -160,7 +160,7 @@ void tst_helpers_all::atLeastOnePromiseReject()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p2.isRejected(), true);
}
@ -168,11 +168,11 @@ void tst_helpers_all::atLeastOnePromiseReject_void()
{
auto p0 = QtPromise::resolve();
auto p1 = QtPromise::resolve();
auto p2 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
auto p2 = QPromise<void>{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=](){
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p = QtPromise::all(QVector<QPromise<void>>{p0, p2, p1});
@ -181,7 +181,7 @@ void tst_helpers_all::atLeastOnePromiseReject_void()
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p2.isRejected(), true);
}
@ -198,7 +198,7 @@ void tst_helpers_all::preserveOrder()
QCOMPARE(p1.isPending(), true);
QCOMPARE(p2.isPending(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(p0.isFulfilled(), true);
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(p2.isFulfilled(), true);

16
tests/auto/qtpromise/helpers/tst_attempt.cpp
View File

@ -43,25 +43,25 @@ void tst_helpers_attempt::voidResult()
void tst_helpers_attempt::typedResult()
{
auto p = QtPromise::attempt([]() {
return QString("foo");
return QString{"foo"};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo"));
QCOMPARE(waitForValue(p, QString{}), QString{"foo"});
}
void tst_helpers_attempt::futureResult()
{
auto p = QtPromise::attempt([]() {
return QtConcurrent::run([]() {
return QString("foo");
return QString{"foo"};
});
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo"));
QCOMPARE(waitForValue(p, QString{}), QString{"foo"});
}
void tst_helpers_attempt::promiseResult()
@ -79,23 +79,23 @@ void tst_helpers_attempt::functorThrows()
{
auto p = QtPromise::attempt([]() {
if (true) {
throw QString("bar");
throw QString{"bar"};
}
return 42;
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<int>>::value));
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
}
void tst_helpers_attempt::callWithParams()
{
auto p = QtPromise::attempt([&](int i, const QString& s) {
return QString("%1:%2").arg(i).arg(s);
return QString{"%1:%2"}.arg(i).arg(s);
}, 42, "foo");
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QString()), QString("42:foo"));
QCOMPARE(waitForValue(p, QString{}), QString{"42:foo"});
}

12
tests/auto/qtpromise/helpers/tst_connect.cpp
View File

@ -65,7 +65,7 @@ void tst_helpers_connect::resolveOneSenderOneArg()
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(sender.hasConnections(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo"));
QCOMPARE(waitForValue(p, QString{}), QString{"foo"});
QCOMPARE(sender.hasConnections(), false);
}
@ -110,7 +110,7 @@ void tst_helpers_connect::rejectOneSenderOneArg()
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
QCOMPARE(sender.hasConnections(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(sender.hasConnections(), false);
}
@ -131,7 +131,7 @@ void tst_helpers_connect::rejectOneSenderManyArgs()
void tst_helpers_connect::rejectOneSenderDestroyed()
{
Object* sender = new Object();
auto sender = new Object{};
QtPromisePrivate::qtpromise_defer([&]() {
sender->deleteLater();
});
@ -171,7 +171,7 @@ void tst_helpers_connect::rejectTwoSendersOneArg()
QCOMPARE(s0.hasConnections(), true);
QCOMPARE(s1.hasConnections(), true);
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(s0.hasConnections(), false);
QCOMPARE(s1.hasConnections(), false);
}
@ -195,8 +195,8 @@ void tst_helpers_connect::rejectTwoSendersManyArgs()
void tst_helpers_connect::rejectTwoSendersDestroyed()
{
Object* s0 = new Object();
Object* s1 = new Object();
auto s0 = new Object{};
auto s1 = new Object{};
QtPromisePrivate::qtpromise_defer([&]() {
QObject::connect(s1, &QObject::destroyed, [&]() {

38
tests/auto/qtpromise/helpers/tst_each.cpp
View File

@ -43,8 +43,8 @@ struct SequenceTester
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Sequence>>::value));
QCOMPARE(waitForValue(p, Sequence()), Sequence({42, 43, 44}));
QCOMPARE(values, QVector<int>({0, 42, 1, 43, 2, 44}));
QCOMPARE(waitForValue(p, Sequence{}), (Sequence{42, 43, 44}));
QCOMPARE(values, (QVector<int>{0, 42, 1, 43, 2, 44}));
}
};
@ -58,8 +58,8 @@ void tst_helpers_each::emptySequence()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>());
QCOMPARE(values, QVector<int>({}));
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
QCOMPARE(values, QVector<int>{});
}
void tst_helpers_each::preserveValues()
@ -70,8 +70,8 @@ void tst_helpers_each::preserveValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(values, QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(values, (QVector<int>{43, 44, 45}));
}
void tst_helpers_each::ignoreResult()
@ -83,24 +83,24 @@ void tst_helpers_each::ignoreResult()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(values, QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(values, (QVector<int>{43, 44, 45}));
}
void tst_helpers_each::delayedFulfilled()
{
QMap<int, int> values;
auto p = QtPromise::each(QVector<int>{42, 43, 44}, [&](int v, int index) {
return QPromise<int>([&](const QPromiseResolve<int>& resolve) {
return QPromise<int>{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=, &values]() {
values[v] = index;
resolve(42);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QMap<int, int> expected{{42, 0}, {43, 1}, {44, 2}};
QCOMPARE(values, expected);
}
@ -108,32 +108,32 @@ void tst_helpers_each::delayedFulfilled()
void tst_helpers_each::delayedRejected()
{
auto p = QtPromise::each(QVector<int>{42, 43, 44}, [](int v, ...) {
return QPromise<int>([&](
return QPromise<int>{[&](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
if (v == 43) {
reject(QString("foo"));
reject(QString{"foo"});
}
resolve(v);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_helpers_each::functorThrows()
{
auto p = QtPromise::each(QVector<int>{42, 43, 44}, [](int v, ...) {
if (v == 44) {
throw QString("foo");
throw QString{"foo"};
}
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_helpers_each::functorArguments()
@ -144,8 +144,8 @@ void tst_helpers_each::functorArguments()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(values, QVector<int>({0, 42, 1, 43, 2, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(values, (QVector<int>{0, 42, 1, 43, 2, 44}));
}
void tst_helpers_each::sequenceTypes()

28
tests/auto/qtpromise/helpers/tst_filter.cpp
View File

@ -44,7 +44,7 @@ struct SequenceTester
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Sequence>>::value));
QCOMPARE(waitForValue(p, Sequence()), Sequence({42, 45, 48, 51}));
QCOMPARE(waitForValue(p, Sequence{}), (Sequence{42, 45, 48, 51}));
}
};
@ -57,7 +57,7 @@ void tst_helpers_filter::emptySequence()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>{});
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
}
void tst_helpers_filter::filterValues()
@ -67,53 +67,53 @@ void tst_helpers_filter::filterValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 44}));
}
void tst_helpers_filter::delayedFulfilled()
{
auto p = QtPromise::filter(QVector<int>{42, 43, 44}, [](int v, ...) {
return QPromise<bool>([&](const QPromiseResolve<bool>& resolve) {
return QPromise<bool>{[&](const QPromiseResolve<bool>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(v % 2 == 0);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 44}));
}
void tst_helpers_filter::delayedRejected()
{
auto p = QtPromise::filter(QVector<int>{42, 43, 44}, [](int v, ...) {
return QPromise<bool>([&](
return QPromise<bool>{[&](
const QPromiseResolve<bool>& resolve,
const QPromiseReject<bool>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
if (v == 44) {
reject(QString("foo"));
reject(QString{"foo"});
}
resolve(true);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_helpers_filter::functorThrows()
{
auto p = QtPromise::filter(QVector<int>{42, 43, 44}, [](int v, ...) {
if (v == 44) {
throw QString("foo");
throw QString{"foo"};
}
return true;
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_helpers_filter::functorArguments()
@ -125,7 +125,7 @@ void tst_helpers_filter::functorArguments()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 44}));
QMap<int, int> expected{{42, 0}, {43, 1}, {44, 2}};
QCOMPARE(args, expected);
}
@ -137,7 +137,7 @@ void tst_helpers_filter::preserveOrder()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({500, 300, 250, 400}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{500, 300, 250, 400}));
}
void tst_helpers_filter::sequenceTypes()

30
tests/auto/qtpromise/helpers/tst_map.cpp
View File

@ -43,7 +43,7 @@ struct SequenceTester
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<QString>>>::value));
QCOMPARE(waitForValue(p, QVector<QString>()), QVector<QString>({"43", "44", "45"}));
QCOMPARE(waitForValue(p, QVector<QString>{}), (QVector<QString>{"43", "44", "45"}));
}
};
@ -56,7 +56,7 @@ void tst_helpers_map::emptySequence()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{}));
}
void tst_helpers_map::modifyValues()
@ -66,7 +66,7 @@ void tst_helpers_map::modifyValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{43, 44, 45}));
}
void tst_helpers_map::convertValues()
@ -76,53 +76,53 @@ void tst_helpers_map::convertValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<QString>>>::value));
QCOMPARE(waitForValue(p, QVector<QString>()), QVector<QString>({"43", "44", "45"}));
QCOMPARE(waitForValue(p, QVector<QString>{}), (QVector<QString>{"43", "44", "45"}));
}
void tst_helpers_map::delayedFulfilled()
{
auto p = QtPromise::map(QVector<int>{42, 43, 44}, [](int v, ...) {
return QPromise<int>([&](const QPromiseResolve<int>& resolve) {
return QPromise<int>{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(v + 1);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{43, 44, 45}));
}
void tst_helpers_map::delayedRejected()
{
auto p = QtPromise::map(QVector<int>{42, 43, 44}, [](int v, ...) {
return QPromise<int>([&](
return QPromise<int>{[&](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
if (v == 43) {
reject(QString("foo"));
reject(QString{"foo"});
}
resolve(v);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_helpers_map::functorThrows()
{
auto p = QtPromise::map(QVector<int>{42, 43, 44}, [](int v, ...) {
if (v == 43) {
throw QString("foo");
throw QString{"foo"};
}
return v + 1;
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_helpers_map::functorArguments()
@ -132,7 +132,7 @@ void tst_helpers_map::functorArguments()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({0, 42, 84}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{0, 42, 84}));
}
void tst_helpers_map::preserveOrder()
@ -142,7 +142,7 @@ void tst_helpers_map::preserveOrder()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({501, 101, 251}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{501, 101, 251}));
}
void tst_helpers_map::sequenceTypes()

48
tests/auto/qtpromise/helpers/tst_reduce.cpp
View File

@ -63,8 +63,8 @@ struct SequenceTester
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
};
@ -109,8 +109,8 @@ void tst_helpers_reduce::regularValues()
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_helpers_reduce::promiseValues()
@ -139,8 +139,8 @@ void tst_helpers_reduce::promiseValues()
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_helpers_reduce::convertResultType()
@ -148,15 +148,15 @@ void tst_helpers_reduce::convertResultType()
QVector<int> inputs{4, 6, 8};
auto p = QtPromise::reduce(inputs, [&](const QString& acc, int cur, int idx) {
return QString("%1:%2:%3").arg(acc).arg(cur).arg(idx);
}, QString("foo"));
return QString{"%1:%2:%3"}.arg(acc).arg(cur).arg(idx);
}, QString{"foo"});
// NOTE(SB): when no initial value is given, the result type is the sequence type.
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo:4:0:6:1:8:2"));
QCOMPARE(waitForValue(p, QString{}), QString{"foo:4:0:6:1:8:2"});
}
void tst_helpers_reduce::delayedInitialValue()
@ -172,7 +172,7 @@ void tst_helpers_reduce::delayedInitialValue()
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, -1), 23);
QCOMPARE(values, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(values, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_helpers_reduce::delayedFulfilled()
@ -197,8 +197,8 @@ void tst_helpers_reduce::delayedFulfilled()
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_helpers_reduce::delayedRejected()
@ -210,14 +210,14 @@ void tst_helpers_reduce::delayedRejected()
auto p0 = QtPromise::reduce(inputs, [&](int acc, int cur, int idx) {
v0 << acc << cur << idx;
if (cur == 6) {
return QPromise<int>::reject(QString("foo"));
return QPromise<int>::reject(QString{"foo"});
}
return QtPromise::resolve(acc + cur + idx);
});
auto p1 = QtPromise::reduce(inputs, [&](int acc, int cur, int idx) {
v1 << acc << cur << idx;
if (cur == 6) {
return QPromise<int>::reject(QString("bar"));
return QPromise<int>::reject(QString{"bar"});
}
return QtPromise::resolve(acc + cur + idx);
}, 2);
@ -227,10 +227,10 @@ void tst_helpers_reduce::delayedRejected()
QCOMPARE(p0.isPending(), true);
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p1, QString()), QString("bar"));
QCOMPARE(v0, QVector<int>({4, 6, 1}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1}));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
QCOMPARE(v0, (QVector<int>{4, 6, 1}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1}));
}
void tst_helpers_reduce::functorThrows()
@ -242,14 +242,14 @@ void tst_helpers_reduce::functorThrows()
auto p0 = QtPromise::reduce(inputs, [&](int acc, int cur, int idx) {
v0 << acc << cur << idx;
if (cur == 6) {
throw QString("foo");
throw QString{"foo"};
}
return acc + cur + idx;
});
auto p1 = QtPromise::reduce(inputs, [&](int acc, int cur, int idx) {
v1 << acc << cur << idx;
if (cur == 6) {
throw QString("bar");
throw QString{"bar"};
}
return acc + cur + idx;
}, 2);
@ -259,10 +259,10 @@ void tst_helpers_reduce::functorThrows()
QCOMPARE(p0.isPending(), true);
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p1, QString()), QString("bar"));
QCOMPARE(v0, QVector<int>({4, 6, 1}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1}));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
QCOMPARE(v0, (QVector<int>{4, 6, 1}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1}));
}
void tst_helpers_reduce::sequenceTypes()

4
tests/auto/qtpromise/helpers/tst_reject.cpp
View File

@ -44,7 +44,7 @@ void tst_helpers_reject::rejectWithQSharedPtr()
auto sptr = QSharedPointer<int>::create(42);
auto p = QPromise<int>::reject(sptr);
QCOMPARE(waitForError(p, QSharedPointer<int>()), sptr);
QCOMPARE(waitForError(p, QSharedPointer<int>{}), sptr);
wptr = sptr;
sptr.reset();
@ -64,7 +64,7 @@ void tst_helpers_reject::rejectWithStdSharedPtr()
auto sptr = std::make_shared<int>(42);
auto p = QPromise<int>::reject(sptr);
QCOMPARE(waitForError(p, std::shared_ptr<int>()), sptr);
QCOMPARE(waitForError(p, std::shared_ptr<int>{}), sptr);
wptr = sptr;
sptr.reset();

20
tests/auto/qtpromise/helpers/tst_resolve.cpp
View File

@ -72,7 +72,7 @@ void tst_helpers_resolve::moveRValue()
Data::logs().reset();
{
auto p = QtPromise::resolve(Data(42)).wait();
auto p = QtPromise::resolve(Data{42}).wait();
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Data>>::value));
}
@ -88,7 +88,7 @@ void tst_helpers_resolve::copyLValue()
Data::logs().reset();
{
Data value(42);
Data value{42};
auto p = QtPromise::resolve(value).wait();
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Data>>::value));
@ -119,8 +119,8 @@ void tst_helpers_resolve::qtSharedPtr()
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<QSharedPointer<Data>>>::value));
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<QSharedPointer<Data>>>::value));
QCOMPARE(waitForValue(p1, QSharedPointer<Data>()), sptr0);
QCOMPARE(waitForValue(p2, QSharedPointer<Data>()), sptr1);
QCOMPARE(waitForValue(p1, QSharedPointer<Data>{}), sptr0);
QCOMPARE(waitForValue(p2, QSharedPointer<Data>{}), sptr1);
wptr = sptr0;
@ -155,8 +155,8 @@ void tst_helpers_resolve::stdSharedPtr()
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<std::shared_ptr<Data>>>::value));
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<std::shared_ptr<Data>>>::value));
QCOMPARE(waitForValue(p1, std::shared_ptr<Data>()), sptr0);
QCOMPARE(waitForValue(p2, std::shared_ptr<Data>()), sptr1);
QCOMPARE(waitForValue(p1, std::shared_ptr<Data>{}), sptr0);
QCOMPARE(waitForValue(p2, std::shared_ptr<Data>{}), sptr1);
wptr = sptr0;
@ -180,10 +180,10 @@ void tst_helpers_resolve::typedPromise()
});
};
QPromise<int> v0(resolver);
QPromise<int> v0{resolver};
const QPromise<int> v1 = v0;
auto p0 = QtPromise::resolve(QPromise<int>(resolver));
auto p0 = QtPromise::resolve(QPromise<int>{resolver});
auto p1 = QtPromise::resolve(v0);
auto p2 = QtPromise::resolve(v1);
@ -207,10 +207,10 @@ void tst_helpers_resolve::voidPromise()
});
};
QPromise<void> v0(resolver);
QPromise<void> v0{resolver};
const QPromise<void> v1 = v0;
auto p0 = QtPromise::resolve(QPromise<void>(resolver));
auto p0 = QtPromise::resolve(QPromise<void>{resolver});
auto p1 = QtPromise::resolve(v0);
auto p2 = QtPromise::resolve(v1);

136
tests/auto/qtpromise/qpromise/tst_construct.cpp
View File

@ -46,205 +46,205 @@ QTEST_MAIN(tst_qpromise_construct)
void tst_qpromise_construct::resolveSyncOneArg()
{
QPromise<int> p([](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[](const QPromiseResolve<int>& resolve) {
resolve(42);
});
}};
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1), 42);
}
void tst_qpromise_construct::resolveSyncOneArg_void()
{
QPromise<void> p([](const QPromiseResolve<void>& resolve) {
QPromise<void> p{[](const QPromiseResolve<void>& resolve) {
resolve();
});
}};
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1, 42), 42);
}
void tst_qpromise_construct::resolveSyncTwoArgs()
{
QPromise<int> p([](const QPromiseResolve<int>& resolve, const QPromiseReject<int>&) {
QPromise<int> p{[](const QPromiseResolve<int>& resolve, const QPromiseReject<int>&) {
resolve(42);
});
}};
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1), 42);
}
void tst_qpromise_construct::resolveSyncTwoArgs_void()
{
QPromise<void> p([](const QPromiseResolve<void>& resolve, const QPromiseReject<void>&) {
QPromise<void> p{[](const QPromiseResolve<void>& resolve, const QPromiseReject<void>&) {
resolve();
});
}};
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1, 42), 42);
}
void tst_qpromise_construct::resolveAsyncOneArg()
{
QPromise<int> p([](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(42);
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1), 42);
QCOMPARE(p.isFulfilled(), true);
}
void tst_qpromise_construct::resolveAsyncOneArg_void()
{
QPromise<void> p([](const QPromiseResolve<void>& resolve) {
QPromise<void> p{[](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve();
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1, 42), 42);
QCOMPARE(p.isFulfilled(), true);
}
void tst_qpromise_construct::resolveAsyncTwoArgs()
{
QPromise<int> p([](const QPromiseResolve<int>& resolve, const QPromiseReject<int>&) {
QPromise<int> p{[](const QPromiseResolve<int>& resolve, const QPromiseReject<int>&) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(42);
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1), 42);
QCOMPARE(p.isFulfilled(), true);
}
void tst_qpromise_construct::resolveAsyncTwoArgs_void()
{
QPromise<void> p([](const QPromiseResolve<void>& resolve, const QPromiseReject<void>&) {
QPromise<void> p{[](const QPromiseResolve<void>& resolve, const QPromiseReject<void>&) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve();
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForError(p, QString()), QString());
QCOMPARE(waitForError(p, QString{}), QString{});
QCOMPARE(waitForValue(p, -1, 42), 42);
QCOMPARE(p.isFulfilled(), true);
}
void tst_qpromise_construct::rejectSync()
{
QPromise<int> p([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
reject(QString("foo"));
});
QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
reject(QString{"foo"});
}};
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForValue(p, -1), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_construct::rejectSync_void()
{
QPromise<void> p([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
reject(QString("foo"));
});
QPromise<void> p{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
reject(QString{"foo"});
}};
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForValue(p, -1, 42), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_construct::rejectAsync()
{
QPromise<int> p([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, -1), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_construct::rejectAsync_void()
{
QPromise<void> p([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QPromise<void> p{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, -1, 42), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_construct::rejectThrowOneArg()
{
QPromise<int> p([](const QPromiseResolve<int>&) {
throw QString("foo");
});
QPromise<int> p{[](const QPromiseResolve<int>&) {
throw QString{"foo"};
}};
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForValue(p, -1), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_construct::rejectThrowOneArg_void()
{
QPromise<void> p([](const QPromiseResolve<void>&) {
throw QString("foo");
});
QPromise<void> p{[](const QPromiseResolve<void>&) {
throw QString{"foo"};
}};
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForValue(p, -1, 42), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_construct::rejectThrowTwoArgs()
{
QPromise<int> p([](const QPromiseResolve<int>&, const QPromiseReject<int>&) {
throw QString("foo");
});
QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>&) {
throw QString{"foo"};
}};
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForValue(p, -1), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_construct::rejectThrowTwoArgs_void()
{
QPromise<void> p([](const QPromiseResolve<void>&, const QPromiseReject<void>&) {
throw QString("foo");
});
QPromise<void> p{[](const QPromiseResolve<void>&, const QPromiseReject<void>&) {
throw QString{"foo"};
}};
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForValue(p, -1, 42), -1);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_construct::rejectUndefined()
{
QPromise<int> p([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject();
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForRejected<QPromiseUndefinedException>(p), true);
@ -252,11 +252,11 @@ void tst_qpromise_construct::rejectUndefined()
void tst_qpromise_construct::rejectUndefined_void()
{
QPromise<void> p([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QPromise<void> p{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject();
});
});
}};
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForRejected<QPromiseUndefinedException>(p), true);
@ -265,12 +265,12 @@ void tst_qpromise_construct::rejectUndefined_void()
// https://github.com/simonbrunel/qtpromise/issues/6
void tst_qpromise_construct::connectAndResolve()
{
QScopedPointer<QObject> object(new QObject());
QScopedPointer<QObject> object(new QObject{});
std::weak_ptr<int> wptr;
{
auto p = QPromise<std::shared_ptr<int>>([&](
auto p = QPromise<std::shared_ptr<int>>{[&](
const QPromiseResolve<std::shared_ptr<int>>& resolve,
const QPromiseReject<std::shared_ptr<int>>& reject) {
@ -286,13 +286,13 @@ void tst_qpromise_construct::connectAndResolve()
reject(42);
}
});
});
}};
QCOMPARE(p.isPending(), true);
object->setObjectName("foobar");
QCOMPARE(waitForValue(p, std::shared_ptr<int>()), wptr.lock());
QCOMPARE(waitForValue(p, std::shared_ptr<int>{}), wptr.lock());
QCOMPARE(wptr.use_count(), 1l); // "p" still holds a reference
}
@ -302,12 +302,12 @@ void tst_qpromise_construct::connectAndResolve()
// https://github.com/simonbrunel/qtpromise/issues/6
void tst_qpromise_construct::connectAndReject()
{
QScopedPointer<QObject> object(new QObject());
QScopedPointer<QObject> object(new QObject{});
std::weak_ptr<int> wptr;
{
auto p = QPromise<int>([&](
auto p = QPromise<int>{[&](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
@ -323,13 +323,13 @@ void tst_qpromise_construct::connectAndReject()
resolve(42);
}
});
});
}};
QCOMPARE(p.isPending(), true);
object->setObjectName("foobar");
QCOMPARE(waitForError(p, std::shared_ptr<int>()), wptr.lock());
QCOMPARE(waitForError(p, std::shared_ptr<int>{}), wptr.lock());
QCOMPARE(wptr.use_count(), 1l); // "p" still holds a reference
}

8
tests/auto/qtpromise/qpromise/tst_delay.cpp
View File

@ -57,11 +57,11 @@ void tst_qpromise_delay::rejected()
timer.start();
auto p = QPromise<int>::reject(QString("foo")).delay(1000).finally([&]() {
auto p = QPromise<int>::reject(QString{"foo"}).delay(1000).finally([&]() {
elapsed = timer.elapsed();
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QVERIFY(elapsed <= 10);
}
@ -94,11 +94,11 @@ void tst_qpromise_delay::rejectedStdChrono()
timer.start();
auto p = QPromise<int>::reject(QString("foo")).delay(std::chrono::seconds{1}).finally([&]() {
auto p = QPromise<int>::reject(QString{"foo"}).delay(std::chrono::seconds{1}).finally([&]() {
elapsed = timer.elapsed();
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QVERIFY(elapsed <= 10);
}

36
tests/auto/qtpromise/qpromise/tst_each.cpp
View File

@ -42,10 +42,10 @@ struct SequenceTester
values << i << v;
}).each([&](int v, ...) {
values << v;
return QString("foo");
return QString{"foo"};
}).each([&](int v, ...) {
values << v + 1;
return QtPromise::resolve(QString("foo")).then([&](){
return QtPromise::resolve(QString{"foo"}).then([&](){
values << -1;
});
}).each([&](int v, ...) {
@ -53,7 +53,7 @@ struct SequenceTester
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Sequence>>::value));
QCOMPARE(waitForValue(p, Sequence()), Sequence({42, 43, 44}));
QCOMPARE(waitForValue(p, Sequence{}), (Sequence{42, 43, 44}));
QVector<int> expected{
0, 42, 1, 43, 2, 44,
@ -76,8 +76,8 @@ void tst_qpromise_each::emptySequence()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>());
QCOMPARE(values, QVector<int>({}));
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
QCOMPARE(values, (QVector<int>{}));
}
void tst_qpromise_each::preserveValues()
@ -88,8 +88,8 @@ void tst_qpromise_each::preserveValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(values, QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(values, (QVector<int>{43, 44, 45}));
}
void tst_qpromise_each::ignoreResult()
@ -101,8 +101,8 @@ void tst_qpromise_each::ignoreResult()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(values, QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(values, (QVector<int>{43, 44, 45}));
}
void tst_qpromise_each::delayedFulfilled()
@ -116,7 +116,7 @@ void tst_qpromise_each::delayedFulfilled()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QMap<int, int> expected{{42, 0}, {43, 1}, {44, 2}};
QCOMPARE(values, expected);
}
@ -124,32 +124,32 @@ void tst_qpromise_each::delayedFulfilled()
void tst_qpromise_each::delayedRejected()
{
auto p = QPromise<QVector<int>>::resolve({42, 43, 44}).each([](int v, ...) {
return QPromise<int>([&](
return QPromise<int>{[&](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
if (v == 44) {
reject(QString("foo"));
reject(QString{"foo"});
}
resolve(v);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_each::functorThrows()
{
auto p = QPromise<QVector<int>>::resolve({42, 43, 44}).each([](int v, ...) {
if (v == 44) {
throw QString("foo");
throw QString{"foo"};
}
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_each::functorArguments()
@ -160,8 +160,8 @@ void tst_qpromise_each::functorArguments()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
QCOMPARE(values, QVector<int>({0, 42, 1, 43, 2, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
QCOMPARE(values, (QVector<int>{0, 42, 1, 43, 2, 44}));
}
void tst_qpromise_each::sequenceTypes()

26
tests/auto/qtpromise/qpromise/tst_fail.cpp
View File

@ -32,7 +32,7 @@ QTEST_MAIN(tst_qpromise_fail)
namespace {
const QString kErr = "0.42";
const QString kErr{"0.42"};
const float kRes = 0.42f;
const float kFail = -1.f;
@ -66,17 +66,17 @@ void tst_qpromise_fail::sameType()
QString error;
p.fail([&](const std::domain_error& e) {
error += QString(e.what()) + "0";
error += QString{e.what()} + "0";
return -1;
}).fail([&](const std::out_of_range& e) {
error += QString(e.what()) + "1";
error += QString{e.what()} + "1";
return -1;
}).fail([&](const std::exception& e) {
error += QString(e.what()) + "2";
error += QString{e.what()} + "2";
return -1;
}).wait();
QCOMPARE(error, QString("foo1"));
QCOMPARE(error, QString{"foo1"});
}
void tst_qpromise_fail::baseClass()
@ -86,17 +86,17 @@ void tst_qpromise_fail::baseClass()
QString error;
p.fail([&](const std::runtime_error& e) {
error += QString(e.what()) + "0";
error += QString{e.what()} + "0";
return -1;
}).fail([&](const std::logic_error& e) {
error += QString(e.what()) + "1";
error += QString{e.what()} + "1";
return -1;
}).fail([&](const std::exception& e) {
error += QString(e.what()) + "2";
error += QString{e.what()} + "2";
return -1;
}).wait();
QCOMPARE(error, QString("foo1"));
QCOMPARE(error, QString{"foo1"});
}
void tst_qpromise_fail::catchAll()
@ -105,17 +105,17 @@ void tst_qpromise_fail::catchAll()
QString error;
p.fail([&](const std::runtime_error& e) {
error += QString(e.what()) + "0";
error += QString{e.what()} + "0";
return -1;
}).fail([&]() {
error += "bar";
return -1;
}).fail([&](const std::exception& e) {
error += QString(e.what()) + "2";
error += QString{e.what()} + "2";
return -1;
}).wait();
QCOMPARE(error, QString("bar"));
QCOMPARE(error, QString{"bar"});
}
void tst_qpromise_fail::functionPtrHandlers()
@ -185,7 +185,7 @@ void tst_qpromise_fail::stdBindHandlers()
{
using namespace std::placeholders;
const float val{42.f};
const float val = 42.f;
const Klass obj{val};
const std::function<float()> bindNoArg = std::bind(&Klass::fnNoArg, &obj);

28
tests/auto/qtpromise/qpromise/tst_filter.cpp
View File

@ -49,7 +49,7 @@ struct SequenceTester
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Sequence>>::value));
QCOMPARE(waitForValue(p, Sequence()), Sequence({43, 47, 49}));
QCOMPARE(waitForValue(p, Sequence{}), (Sequence{43, 47, 49}));
}
};
@ -62,7 +62,7 @@ void tst_qpromise_filter::emptySequence()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>{});
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
}
void tst_qpromise_filter::filterValues()
@ -72,53 +72,53 @@ void tst_qpromise_filter::filterValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 44}));
}
void tst_qpromise_filter::delayedFulfilled()
{
auto p = QPromise<QVector<int>>::resolve({42, 43, 44}).filter([](int v, ...) {
return QPromise<bool>([&](const QPromiseResolve<bool>& resolve) {
return QPromise<bool>{[&](const QPromiseResolve<bool>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(v % 2 == 0);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 44}));
}
void tst_qpromise_filter::delayedRejected()
{
auto p = QPromise<QVector<int>>::resolve({42, 43, 44}).filter([](int v, ...) {
return QPromise<bool>([&](
return QPromise<bool>{[&](
const QPromiseResolve<bool>& resolve,
const QPromiseReject<bool>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
if (v == 43) {
reject(QString("foo"));
reject(QString{"foo"});
}
resolve(true);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_filter::functorThrows()
{
auto p = QPromise<QVector<int>>::resolve({42, 43, 44}).filter([](int v, ...) {
if (v == 43) {
throw QString("foo");
throw QString{"foo"};
}
return true;
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_filter::functorArguments()
@ -130,7 +130,7 @@ void tst_qpromise_filter::functorArguments()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 44}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{42, 44}));
QMap<int, int> expected{{42, 0}, {43, 1}, {44, 2}};
QCOMPARE(args, expected);
}
@ -142,7 +142,7 @@ void tst_qpromise_filter::preserveOrder()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({250, 400, 300}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{250, 400, 300}));
}
void tst_qpromise_filter::sequenceTypes()

62
tests/auto/qtpromise/qpromise/tst_finally.cpp
View File

@ -65,22 +65,22 @@ void tst_qpromise_finally::fulfilledSync_void()
void tst_qpromise_finally::fulfilledThrows()
{
auto p = QPromise<int>::resolve(42).finally([&]() {
throw QString("bar");
throw QString{"bar"};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<int>>::value));
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_finally::fulfilledThrows_void()
{
auto p = QPromise<void>::resolve().finally([&]() {
throw QString("bar");
throw QString{"bar"};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
@ -88,12 +88,12 @@ void tst_qpromise_finally::fulfilledAsyncResolve()
{
QVector<int> values;
auto p = QPromise<int>::resolve(42).finally([&]() {
QPromise<int> p([&](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=, &values]() {
values << 64;
resolve(16); // ignored!
});
});
}};
values << 8;
return p;
@ -101,33 +101,33 @@ void tst_qpromise_finally::fulfilledAsyncResolve()
QCOMPARE(waitForValue(p, -1), 42);
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(values, QVector<int>({8, 64}));
QCOMPARE(values, (QVector<int>{8, 64}));
}
void tst_qpromise_finally::fulfilledAsyncReject()
{
auto p = QPromise<int>::resolve(42).finally([]() {
return QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
return QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("bar"));
reject(QString{"bar"});
});
});
}};
});
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_finally::rejectedSync()
{
int value = -1;
auto p = QPromise<int>::reject(QString("foo")).finally([&]() {
auto p = QPromise<int>::reject(QString{"foo"}).finally([&]() {
value = 8;
return 16; // ignored!
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<int>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(value, 8);
}
@ -135,49 +135,49 @@ void tst_qpromise_finally::rejectedSync()
void tst_qpromise_finally::rejectedSync_void()
{
int value = -1;
auto p = QPromise<void>::reject(QString("foo")).finally([&]() {
auto p = QPromise<void>::reject(QString{"foo"}).finally([&]() {
value = 8;
return 16; // ignored!
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(value, 8);
}
void tst_qpromise_finally::rejectedThrows()
{
auto p = QPromise<int>::reject(QString("foo")).finally([&]() {
throw QString("bar");
auto p = QPromise<int>::reject(QString{"foo"}).finally([&]() {
throw QString{"bar"};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<int>>::value));
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_finally::rejectedThrows_void()
{
auto p = QPromise<void>::reject(QString("foo")).finally([&]() {
throw QString("bar");
auto p = QPromise<void>::reject(QString{"foo"}).finally([&]() {
throw QString{"bar"};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_finally::rejectedAsyncResolve()
{
QVector<int> values;
auto p = QPromise<int>::reject(QString("foo")).finally([&]() {
QPromise<int> p([&](const QPromiseResolve<int>& resolve) {
auto p = QPromise<int>::reject(QString{"foo"}).finally([&]() {
QPromise<int> p{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=, &values]() {
values << 64;
resolve(16); // ignored!
});
});
}};
values << 8;
return p;
@ -187,21 +187,21 @@ void tst_qpromise_finally::rejectedAsyncResolve()
values << r;
}).wait();
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(values, QVector<int>({8, 64}));
QCOMPARE(values, (QVector<int>{8, 64}));
}
void tst_qpromise_finally::rejectedAsyncReject()
{
auto p = QPromise<int>::reject(QString("foo")).finally([]() {
return QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p = QPromise<int>::reject(QString{"foo"}).finally([]() {
return QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("bar"));
reject(QString{"bar"});
});
});
}};
});
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}

32
tests/auto/qtpromise/qpromise/tst_map.cpp
View File

@ -41,7 +41,7 @@ struct SequenceTester
auto p = QtPromise::resolve(Sequence{42, 43, 44}).map([](int v, ...) {
return QString::number(v + 1);
}).map([](const QString& v, int i) {
return QtPromise::resolve(QString("%1:%2").arg(i).arg(v));
return QtPromise::resolve(QString{"%1:%2"}.arg(i).arg(v));
}).map([](const QString& v, ...) {
return QtPromise::resolve((v + "!").toUtf8());
}).map([](const QByteArray& v, ...) {
@ -49,7 +49,7 @@ struct SequenceTester
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<QString>>>::value));
QCOMPARE(waitForValue(p, QVector<QString>()), QVector<QString>({"0:43!", "1:44!", "2:45!"}));
QCOMPARE(waitForValue(p, QVector<QString>{}), (QVector<QString>{"0:43!", "1:44!", "2:45!"}));
}
};
@ -62,7 +62,7 @@ void tst_qpromise_map::emptySequence()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({}));
QCOMPARE(waitForValue(p, QVector<int>{}), QVector<int>{});
}
void tst_qpromise_map::modifyValues()
@ -72,7 +72,7 @@ void tst_qpromise_map::modifyValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{43, 44, 45}));
}
void tst_qpromise_map::convertValues()
@ -82,53 +82,53 @@ void tst_qpromise_map::convertValues()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<QString>>>::value));
QCOMPARE(waitForValue(p, QVector<QString>()), QVector<QString>({"43", "44", "45"}));
QCOMPARE(waitForValue(p, QVector<QString>{}), (QVector<QString>{"43", "44", "45"}));
}
void tst_qpromise_map::delayedFulfilled()
{
auto p = QtPromise::resolve(QVector<int>{42, 43, 44}).map([](int v, ...) {
return QPromise<int>([&](const QPromiseResolve<int>& resolve) {
return QPromise<int>{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(v + 1);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({43, 44, 45}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{43, 44, 45}));
}
void tst_qpromise_map::delayedRejected()
{
auto p = QtPromise::resolve(QVector<int>{42, 43, 44}).map([](int v, ...) {
return QPromise<int>([&](
return QPromise<int>{[&](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
if (v == 43) {
reject(QString("foo"));
reject(QString{"foo"});
}
resolve(v);
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_map::functorThrows()
{
auto p = QtPromise::resolve(QVector<int>{42, 43, 44}).map([](int v, ...) {
if (v == 43) {
throw QString("foo");
throw QString{"foo"};
}
return v + 1;
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
}
void tst_qpromise_map::functorArguments()
@ -138,7 +138,7 @@ void tst_qpromise_map::functorArguments()
});
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p1, QVector<int>()), QVector<int>({0, 42, 84}));
QCOMPARE(waitForValue(p1, QVector<int>{}), (QVector<int>{0, 42, 84}));
}
void tst_qpromise_map::preserveOrder()
@ -148,7 +148,7 @@ void tst_qpromise_map::preserveOrder()
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({251, 501, 101}));
QCOMPARE(waitForValue(p, QVector<int>{}), (QVector<int>{251, 501, 101}));
}
void tst_qpromise_map::sequenceTypes()

46
tests/auto/qtpromise/qpromise/tst_operators.cpp
View File

@ -39,20 +39,20 @@ void tst_qpromise_operators::move()
QCOMPARE(p0.isFulfilled(), true);
QCOMPARE(waitForValue(p0, -1), 42);
p0 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
p0 = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
QCOMPARE(p0.isPending(), true);
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
p0 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
p0 = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(43);
});
});
}};
QCOMPARE(p0.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 43);
@ -65,20 +65,20 @@ void tst_qpromise_operators::move_void()
QCOMPARE(p0.isFulfilled(), true);
QCOMPARE(waitForValue(p0, -1, 42), 42);
p0 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
p0 = QPromise<void>{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
QCOMPARE(p0.isPending(), true);
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
p0 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
p0 = QPromise<void>{[](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve();
});
});
}};
QCOMPARE(p0.isPending(), true);
QCOMPARE(waitForValue(p0, -1, 43), 43);
@ -86,17 +86,17 @@ void tst_qpromise_operators::move_void()
void tst_qpromise_operators::copy()
{
auto p0 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p0 = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p1 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p1 = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(42);
});
});
}};
QCOMPARE(p0 == p1, false);
QCOMPARE(p0.isPending(), true);
@ -113,17 +113,17 @@ void tst_qpromise_operators::copy()
void tst_qpromise_operators::copy_void()
{
auto p0 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
auto p0 = QPromise<void>{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
auto p1 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
auto p1 = QPromise<void>{[](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve();
});
});
}};
QCOMPARE(p0 == p1, false);
QCOMPARE(p0.isPending(), true);
@ -229,5 +229,5 @@ void tst_qpromise_operators::chaining_void()
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, -1, 42), 42);
QCOMPARE(values, QVector<int>({0, 2, 4, 6}));
QCOMPARE(values, (QVector<int>{0, 2, 4, 6}));
}

48
tests/auto/qtpromise/qpromise/tst_reduce.cpp
View File

@ -63,8 +63,8 @@ struct SequenceTester
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
};
@ -109,8 +109,8 @@ void tst_qpromise_reduce::regularValues()
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_qpromise_reduce::promiseValues()
@ -139,8 +139,8 @@ void tst_qpromise_reduce::promiseValues()
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_qpromise_reduce::convertResultType()
@ -148,15 +148,15 @@ void tst_qpromise_reduce::convertResultType()
QVector<int> inputs{4, 6, 8};
auto p = QtPromise::resolve(inputs).reduce([&](const QString& acc, int cur, int idx) {
return QString("%1:%2:%3").arg(acc).arg(cur).arg(idx);
}, QString("foo"));
return QString{"%1:%2:%3"}.arg(acc).arg(cur).arg(idx);
}, QString{"foo"});
// NOTE(SB): when no initial value is given, the result type is the sequence type.
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo:4:0:6:1:8:2"));
QCOMPARE(waitForValue(p, QString{}), QString{"foo:4:0:6:1:8:2"});
}
void tst_qpromise_reduce::delayedInitialValue()
@ -172,7 +172,7 @@ void tst_qpromise_reduce::delayedInitialValue()
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, -1), 23);
QCOMPARE(values, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(values, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_qpromise_reduce::delayedFulfilled()
@ -197,8 +197,8 @@ void tst_qpromise_reduce::delayedFulfilled()
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForValue(p0, -1), 21);
QCOMPARE(waitForValue(p1, -1), 23);
QCOMPARE(v0, QVector<int>({4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 8, 2}));
QCOMPARE(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1, 13, 8, 2}));
}
void tst_qpromise_reduce::delayedRejected()
@ -210,14 +210,14 @@ void tst_qpromise_reduce::delayedRejected()
auto p0 = QtPromise::resolve(inputs).reduce([&](int acc, int cur, int idx) {
v0 << acc << cur << idx;
if (cur == 6) {
return QPromise<int>::reject(QString("foo"));
return QPromise<int>::reject(QString{"foo"});
}
return QtPromise::resolve(acc + cur + idx);
});
auto p1 = QtPromise::resolve(inputs).reduce([&](int acc, int cur, int idx) {
v1 << acc << cur << idx;
if (cur == 6) {
return QPromise<int>::reject(QString("bar"));
return QPromise<int>::reject(QString{"bar"});
}
return QtPromise::resolve(acc + cur + idx);
}, 2);
@ -227,10 +227,10 @@ void tst_qpromise_reduce::delayedRejected()
QCOMPARE(p0.isPending(), true);
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p1, QString()), QString("bar"));
QCOMPARE(v0, QVector<int>({4, 6, 1}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1}));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
QCOMPARE(v0, (QVector<int>{4, 6, 1}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1}));
}
void tst_qpromise_reduce::functorThrows()
@ -242,14 +242,14 @@ void tst_qpromise_reduce::functorThrows()
auto p0 = QtPromise::resolve(inputs).reduce([&](int acc, int cur, int idx) {
v0 << acc << cur << idx;
if (cur == 6) {
throw QString("foo");
throw QString{"foo"};
}
return acc + cur + idx;
});
auto p1 = QtPromise::resolve(inputs).reduce([&](int acc, int cur, int idx) {
v1 << acc << cur << idx;
if (cur == 6) {
throw QString("bar");
throw QString{"bar"};
}
return acc + cur + idx;
}, 2);
@ -259,10 +259,10 @@ void tst_qpromise_reduce::functorThrows()
QCOMPARE(p0.isPending(), true);
QCOMPARE(p1.isPending(), true);
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p1, QString()), QString("bar"));
QCOMPARE(v0, QVector<int>({4, 6, 1}));
QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1}));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
QCOMPARE(v0, (QVector<int>{4, 6, 1}));
QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1}));
}
void tst_qpromise_reduce::sequenceTypes()

12
tests/auto/qtpromise/qpromise/tst_resolve.cpp
View File

@ -67,7 +67,7 @@ void tst_qpromise_resolve::moveRValue()
Data::logs().reset();
{
auto p = QtPromise::resolve(Data(42)).wait();
auto p = QtPromise::resolve(Data{42}).wait();
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Data>>::value));
}
@ -83,7 +83,7 @@ void tst_qpromise_resolve::copyLValue()
Data::logs().reset();
{
Data value(42);
Data value{42};
auto p = QtPromise::resolve(value).wait();
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<Data>>::value));
@ -114,8 +114,8 @@ void tst_qpromise_resolve::qtSharedPtr()
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<QSharedPointer<Data>>>::value));
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<QSharedPointer<Data>>>::value));
QCOMPARE(waitForValue(p1, QSharedPointer<Data>()), sptr0);
QCOMPARE(waitForValue(p2, QSharedPointer<Data>()), sptr1);
QCOMPARE(waitForValue(p1, QSharedPointer<Data>{}), sptr0);
QCOMPARE(waitForValue(p2, QSharedPointer<Data>{}), sptr1);
wptr = sptr0;
@ -150,8 +150,8 @@ void tst_qpromise_resolve::stdSharedPtr()
Q_STATIC_ASSERT((std::is_same<decltype(p1), QPromise<std::shared_ptr<Data>>>::value));
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<std::shared_ptr<Data>>>::value));
QCOMPARE(waitForValue(p1, std::shared_ptr<Data>()), sptr0);
QCOMPARE(waitForValue(p2, std::shared_ptr<Data>()), sptr1);
QCOMPARE(waitForValue(p1, std::shared_ptr<Data>{}), sptr0);
QCOMPARE(waitForValue(p2, std::shared_ptr<Data>{}), sptr1);
wptr = sptr0;

32
tests/auto/qtpromise/qpromise/tst_tap.cpp
View File

@ -59,20 +59,20 @@ void tst_qpromise_tap::fulfilledSync_void()
void tst_qpromise_tap::fulfilledThrows()
{
auto p = QPromise<int>::resolve(42).tap([&](int) {
throw QString("foo");
throw QString{"foo"};
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_tap::fulfilledThrows_void()
{
auto p = QPromise<void>::resolve().tap([&]() {
throw QString("foo");
throw QString{"foo"};
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
}
@ -80,12 +80,12 @@ void tst_qpromise_tap::fulfilledAsyncResolve()
{
QVector<int> values;
auto p = QPromise<int>::resolve(1).tap([&](int) {
QPromise<int> p([&](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=, &values]() {
values << 3;
resolve(4); // ignored!
});
});
}};
values << 2;
return p;
@ -96,19 +96,19 @@ void tst_qpromise_tap::fulfilledAsyncResolve()
}).wait();
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(values, QVector<int>({2, 3, 1}));
QCOMPARE(values, (QVector<int>{2, 3, 1}));
}
void tst_qpromise_tap::fulfilledAsyncReject()
{
QVector<int> values;
auto p = QPromise<int>::resolve(1).tap([&](int) {
QPromise<int> p([&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QPromise<int> p{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=, &values]() {
values << 3;
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
values << 2;
return p;
@ -118,19 +118,19 @@ void tst_qpromise_tap::fulfilledAsyncReject()
values << r;
}).wait();
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(values, QVector<int>({2, 3}));
QCOMPARE(values, (QVector<int>{2, 3}));
}
void tst_qpromise_tap::rejectedSync()
{
int value = -1;
auto p = QPromise<int>::reject(QString("foo")).tap([&](int res) {
auto p = QPromise<int>::reject(QString{"foo"}).tap([&](int res) {
value = res + 1;
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(value, -1);
}
@ -138,11 +138,11 @@ void tst_qpromise_tap::rejectedSync()
void tst_qpromise_tap::rejectedSync_void()
{
int value = -1;
auto p = QPromise<void>::reject(QString("foo")).tap([&]() {
auto p = QPromise<void>::reject(QString{"foo"}).tap([&]() {
value = 43;
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(value, -1);
}

46
tests/auto/qtpromise/qpromise/tst_tapfail.cpp
View File

@ -58,7 +58,7 @@ void tst_qpromise_tapfail::rejected()
{
QStringList errors;
auto p0 = QPromise<int>::reject(QString("foo"))
auto p0 = QPromise<int>::reject(QString{"foo"})
.tapFail([&](const QString& err) {
errors << "1:" + err;
});
@ -69,18 +69,18 @@ void tst_qpromise_tapfail::rejected()
return 43;
});
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
QCOMPARE(waitForValue(p1, -1), 43);
QCOMPARE(p0.isRejected(), true);
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(errors, QStringList() << "1:foo" << "2:foo");
QCOMPARE(errors, (QStringList{"1:foo", "2:foo"}));
}
void tst_qpromise_tapfail::rejected_void()
{
QStringList errors;
auto p0 = QPromise<void>::reject(QString("foo"))
auto p0 = QPromise<void>::reject(QString{"foo"})
.tapFail([&](const QString& err) {
errors << "1:" + err;
});
@ -90,73 +90,73 @@ void tst_qpromise_tapfail::rejected_void()
errors << "2:" + err;
});
QCOMPARE(waitForError(p0, QString()), QString("foo"));
QCOMPARE(waitForError(p0, QString{}), QString{"foo"});
QCOMPARE(waitForValue(p1, -1, 43), 43);
QCOMPARE(p0.isRejected(), true);
QCOMPARE(p1.isFulfilled(), true);
QCOMPARE(errors, QStringList() << "1:foo" << "2:foo");
QCOMPARE(errors, (QStringList{"1:foo", "2:foo"}));
}
void tst_qpromise_tapfail::throws()
{
auto p = QPromise<int>::reject(QString("foo"))
auto p = QPromise<int>::reject(QString{"foo"})
.tapFail([&]() {
throw QString("bar");
throw QString{"bar"};
});
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_tapfail::throws_void()
{
auto p = QPromise<void>::reject(QString("foo"))
auto p = QPromise<void>::reject(QString{"foo"})
.tapFail([&]() {
throw QString("bar");
throw QString{"bar"};
});
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(p.isRejected(), true);
}
void tst_qpromise_tapfail::delayedResolved()
{
QVector<int> values;
auto p = QPromise<int>::reject(QString("foo"))
auto p = QPromise<int>::reject(QString{"foo"})
.tapFail([&]() {
QPromise<void> p([&](const QPromiseResolve<void>& resolve) {
QPromise<void> p{[&](const QPromiseResolve<void>& resolve) {
QtPromisePrivate::qtpromise_defer([=, &values]() {
values << 3;
resolve(); // ignored!
});
});
}};
values << 2;
return p;
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(values, QVector<int>({2, 3}));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(values, (QVector<int>{2, 3}));
}
void tst_qpromise_tapfail::delayedRejected()
{
QVector<int> values;
auto p = QPromise<int>::reject(QString("foo"))
auto p = QPromise<int>::reject(QString{"foo"})
.tapFail([&]() {
QPromise<void> p([&](
QPromise<void> p{[&](
const QPromiseResolve<void>&,
const QPromiseReject<void>& reject){
QtPromisePrivate::qtpromise_defer([=, &values]() {
values << 3;
reject(QString("bar"));
reject(QString{"bar"});
});
});
}};
values << 2;
return p;
});
QCOMPARE(waitForError(p, QString()), QString("bar"));
QCOMPARE(values, QVector<int>({2, 3}));
QCOMPARE(waitForError(p, QString{}), QString{"bar"});
QCOMPARE(values, (QVector<int>{2, 3}));
}

26
tests/auto/qtpromise/qpromise/tst_then.cpp
View File

@ -78,7 +78,7 @@ void tst_qpromise_then::resolveSync()
values << 44;
}).wait();
QCOMPARE(values, QVariantList({42, QString("43"), 44}));
QCOMPARE(values, (QVariantList{42, QString{"43"}, 44}));
QCOMPARE(input.isFulfilled(), true);
QCOMPARE(output.isFulfilled(), true);
}
@ -86,15 +86,15 @@ void tst_qpromise_then::resolveSync()
void tst_qpromise_then::resolveAsync()
{
auto p = QPromise<int>::resolve(42).then([](int res) {
return QPromise<QString>([=](const QPromiseResolve<QString>& resolve) {
return QPromise<QString>{[=](const QPromiseResolve<QString>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(QString("foo%1").arg(res));
resolve(QString{"foo%1"}.arg(res));
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(waitForValue(p, QString()), QString("foo42"));
QCOMPARE(waitForValue(p, QString{}), QString{"foo42"});
QCOMPARE(p.isFulfilled(), true);
}
@ -102,7 +102,7 @@ void tst_qpromise_then::rejectSync()
{
auto input = QPromise<int>::resolve(42);
auto output = input.then([](int res) {
throw QString("foo%1").arg(res);
throw QString{"foo%1"}.arg(res);
return 42;
});
@ -113,7 +113,7 @@ void tst_qpromise_then::rejectSync()
error += err;
}).wait();
QCOMPARE(error, QString("foo42"));
QCOMPARE(error, QString{"foo42"});
QCOMPARE(input.isFulfilled(), true);
QCOMPARE(output.isRejected(), true);
}
@ -121,15 +121,15 @@ void tst_qpromise_then::rejectSync()
void tst_qpromise_then::rejectAsync()
{
auto p = QPromise<int>::resolve(42).then([](int res) {
return QPromise<void>([=](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
return QPromise<void>{[=](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(QString("foo%1").arg(res));
reject(QString{"foo%1"}.arg(res));
});
});
}};
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
QCOMPARE(waitForError(p, QString()), QString("foo42"));
QCOMPARE(waitForError(p, QString{}), QString{"foo42"});
QCOMPARE(p.isRejected(), true);
}
@ -155,9 +155,9 @@ void tst_qpromise_then::nullHandler()
QCOMPARE(p.isFulfilled(), true);
}
{ // rejected
auto p = QPromise<int>::reject(QString("foo")).then(nullptr);
auto p = QPromise<int>::reject(QString{"foo"}).then(nullptr);
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
}
}

32
tests/auto/qtpromise/qpromise/tst_timeout.cpp
View File

@ -38,11 +38,11 @@ void tst_qpromise_timeout::fulfilled()
timer.start();
auto p = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QTimer::singleShot(1000, [=]() {
resolve(42);
});
}).timeout(2000).finally([&]() {
}}.timeout(2000).finally([&]() {
elapsed = timer.elapsed();
});
@ -58,16 +58,16 @@ void tst_qpromise_timeout::rejected()
timer.start();
auto p = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QTimer::singleShot(1000, [=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
}).timeout(2000).finally([&]() {
}}.timeout(2000).finally([&]() {
elapsed = timer.elapsed();
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QVERIFY(elapsed < 2000);
}
@ -80,11 +80,11 @@ void tst_qpromise_timeout::timeout()
timer.start();
auto p = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QTimer::singleShot(4000, [=]() {
resolve(42);
});
}).timeout(2000).finally([&]() {
}}.timeout(2000).finally([&]() {
elapsed = timer.elapsed();
});
@ -111,11 +111,11 @@ void tst_qpromise_timeout::fulfilledStdChrono()
timer.start();
auto p = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QTimer::singleShot(1000, [=]() {
resolve(42);
});
}).timeout(std::chrono::seconds{2}).finally([&]() {
}}.timeout(std::chrono::seconds{2}).finally([&]() {
elapsed = timer.elapsed();
});
@ -131,16 +131,16 @@ void tst_qpromise_timeout::rejectedStdChrono()
timer.start();
auto p = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
auto p = QPromise<int>{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QTimer::singleShot(1000, [=]() {
reject(QString("foo"));
reject(QString{"foo"});
});
}).timeout(std::chrono::seconds{2}).finally([&]() {
}}.timeout(std::chrono::seconds{2}).finally([&]() {
elapsed = timer.elapsed();
});
QCOMPARE(waitForError(p, QString()), QString("foo"));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QVERIFY(elapsed < 2000);
}
@ -153,11 +153,11 @@ void tst_qpromise_timeout::timeoutStdChrono()
timer.start();
auto p = QPromise<int>([](const QPromiseResolve<int>& resolve) {
auto p = QPromise<int>{[](const QPromiseResolve<int>& resolve) {
QTimer::singleShot(4000, [=]() {
resolve(42);
});
}).timeout(std::chrono::seconds{2}).finally([&]() {
}}.timeout(std::chrono::seconds{2}).finally([&]() {
elapsed = timer.elapsed();
});

74
tests/auto/qtpromise/requirements/tst_requirements.cpp
View File

@ -43,9 +43,9 @@ void tst_requirements::statePending()
// 2.1.1. When pending, a promise:
// 2.1.1.1. may transition to either the fulfilled state
{
QPromise<int> p([&](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[&](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() { resolve(42); });
});
}};
QVERIFY(p.isPending());
QVERIFY(!p.isFulfilled());
@ -60,9 +60,9 @@ void tst_requirements::statePending()
// 2.1.1.1. ... or the rejected state
{
QPromise<int> p([&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() { reject(QString("foo")); });
});
QPromise<int> p{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() { reject(QString{"foo"}); });
}};
QVERIFY(p.isPending());
QVERIFY(!p.isFulfilled());
@ -82,7 +82,7 @@ void tst_requirements::stateFulfilled()
int value = -1;
// 2.1.2. When fulfilled, a promise:
QPromise<int> p([](
QPromise<int> p{[](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
@ -91,9 +91,9 @@ void tst_requirements::stateFulfilled()
resolve(43);
// 2.1.2.1. must not transition to any other state.
reject(QString("foo"));
reject(QString{"foo"});
});
});
}};
QVERIFY(p.isPending());
@ -115,18 +115,18 @@ void tst_requirements::stateRejected()
int value = -1;
// 2.1.3 When rejected, a promise:
QPromise<int> p([](
QPromise<int> p{[](
const QPromiseResolve<int>& resolve,
const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
// 2.1.3.2. must have a reason, which must not change.
reject(QString("foo"));
reject(QString("bar"));
reject(QString{"foo"});
reject(QString{"bar"});
// 2.1.3.1. must not transition to any other state.
resolve(42);
});
});
}};
QVERIFY(p.isPending());
@ -138,7 +138,7 @@ void tst_requirements::stateRejected()
QVERIFY(!p.isFulfilled());
QVERIFY(p.isRejected());
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
QCOMPARE(value, -1);
}
@ -159,24 +159,24 @@ void tst_requirements::thenArguments()
{
QString error;
int value = -1;
QPromise<int>::reject(QString("foo")).then(
QPromise<int>::reject(QString{"foo"}).then(
[&](int res) { value = res; },
[&](const QString& err){ error = err; }
).wait();
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
QCOMPARE(value, -1);
}
// 2.2.1. onFulfilled is an optional arguments:
{
QString error;
QPromise<int>::reject(QString("foo")).then(
QPromise<int>::reject(QString{"foo"}).then(
nullptr,
[&](const QString& err){ error = err; return 42; }
).wait();
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
}
// 2.2.1. onRejected is an optional arguments:
@ -198,13 +198,13 @@ void tst_requirements::thenOnFulfilled()
{
// 2.2.2. If onFulfilled is a function:
QVector<int> values;
QPromise<int> p0([](const QPromiseResolve<int>& resolve) {
QPromise<int> p0{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
// 2.2.2.3. it must not be called more than once
resolve(42);
resolve(43);
});
});
}};
auto p1 = p0.then([&](int res) { values << res; });
@ -226,13 +226,13 @@ void tst_requirements::thenOnRejected()
{
// 2.2.3. If onRejected is a function:
QStringList errors;
QPromise<void> p0([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QPromise<void> p0{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
// 2.2.3.3. it must not be called more than once.
reject(QString("foo"));
reject(QString("bar"));
reject(QString{"foo"});
reject(QString{"bar"});
});
});
}};
auto p1 = p0.then(nullptr, [&](const QString& err) { errors << err; });
@ -247,7 +247,7 @@ void tst_requirements::thenOnRejected()
// with promise’s reason as its first argument.
QVERIFY(p0.isRejected());
QVERIFY(p1.isFulfilled());
QCOMPARE(errors, QStringList({"foo"}));
QCOMPARE(errors, (QStringList{"foo"}));
}
void tst_requirements::thenAsynchronous()
@ -277,11 +277,11 @@ void tst_requirements::thenMultipleCalls()
// must execute in the order of their originating calls to then:
{
QVector<int> values;
QPromise<int> p([](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[](const QPromiseResolve<int>& resolve) {
QtPromisePrivate::qtpromise_defer([=]() {
resolve(42);
});
});
}};
QtPromise::all(QVector<QPromise<void>>{
p.then([&](int r) { values << r + 1; }),
@ -289,18 +289,18 @@ void tst_requirements::thenMultipleCalls()
p.then([&](int r) { values << r + 3; })
}).wait();
QCOMPARE(values, QVector<int>({43, 44, 45}));
QCOMPARE(values, (QVector<int>{43, 44, 45}));
}
// 2.2.6.2. If/when promise is rejected, all respective onRejected callbacks
// must execute in the order of their originating calls to then:
{
QVector<int> values;
QPromise<int> p([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtPromisePrivate::qtpromise_defer([=]() {
reject(8);
});
});
}};
QtPromise::all(QVector<QPromise<int>>{
p.then(nullptr, [&](int r) { values << r + 1; return r + 1; }),
@ -308,7 +308,7 @@ void tst_requirements::thenMultipleCalls()
p.then(nullptr, [&](int r) { values << r + 3; return r + 3; })
}).wait();
QCOMPARE(values, QVector<int>({9, 10, 11}));
QCOMPARE(values, (QVector<int>{9, 10, 11}));
}
}
@ -331,22 +331,22 @@ void tst_requirements::thenHandlers()
{
QString reason;
auto p1 = QPromise<int>::resolve(42);
auto p2 = p1.then([](){ throw QString("foo"); });
auto p2 = p1.then([](){ throw QString{"foo"}; });
p2.then(nullptr, [&](const QString& e) { reason = e; }).wait();
QVERIFY(p1.isFulfilled());
QVERIFY(p2.isRejected());
QCOMPARE(reason, QString("foo"));
QCOMPARE(reason, QString{"foo"});
}
{
QString reason;
auto p1 = QPromise<int>::reject(QString("foo"));
auto p2 = p1.then(nullptr, [](){ throw QString("bar"); return 42; });
auto p1 = QPromise<int>::reject(QString{"foo"});
auto p2 = p1.then(nullptr, [](){ throw QString{"bar"}; return 42; });
p2.then(nullptr, [&](const QString& e) { reason = e; return 0; }).wait();
QVERIFY(p1.isRejected());
QVERIFY(p2.isRejected());
QCOMPARE(reason, QString("bar"));
QCOMPARE(reason, QString{"bar"});
}
// 2.2.7.3. If onFulfilled is not a function and promise1 is fulfilled,
@ -354,12 +354,12 @@ void tst_requirements::thenHandlers()
{
QString value;
auto p1 = QPromise<QString>::resolve("42");
auto p2 = p1.then(nullptr, [](){ return QString(); });
auto p2 = p1.then(nullptr, [](){ return QString{}; });
Q_STATIC_ASSERT((std::is_same<decltype(p2), QPromise<QString>>::value));
p2.then([&](const QString& e) { value = e; }).wait();
QVERIFY(p1.isFulfilled());
QVERIFY(p2.isFulfilled());
QCOMPARE(value, QString("42"));
QCOMPARE(value, QString{"42"});
}
}

8
tests/auto/qtpromise/shared/data.h
View File

@ -40,7 +40,7 @@ public: // STATICS
struct Data : public Logger
{
Data(int v) : Logger(), m_value(v) {}
Data(int v) : Logger{}, m_value{v} {}
int value() const { return m_value; }
// MSVC 2013 doesn't support implicit generation of the move constructor and
@ -49,11 +49,11 @@ struct Data : public Logger
// https://stackoverflow.com/a/26581337
Data(const Data& other)
: Logger(other)
, m_value(other.m_value)
: Logger{other}
, m_value{other.m_value}
{ }
Data(Data&& other) : Logger(std::forward<Data>(other))
Data(Data&& other) : Logger{std::forward<Data>(other)}
{
std::swap(m_value, other.m_value);
}

36
tests/auto/qtpromise/thread/tst_thread.cpp
View File

@ -35,12 +35,12 @@ void tst_thread::resolve()
QThread* target = nullptr;
QThread* source = nullptr;
QPromise<int>([&](const QPromiseResolve<int>& resolve) {
QPromise<int>{[&](const QPromiseResolve<int>& resolve) {
QtConcurrent::run([=, &source]() {
source = QThread::currentThread();
resolve(42);
});
}).then([&](int res) {
}}.then([&](int res) {
target = QThread::currentThread();
value = res;
}).wait();
@ -57,12 +57,12 @@ void tst_thread::resolve_void()
QThread* target = nullptr;
QThread* source = nullptr;
QPromise<void>([&](const QPromiseResolve<void>& resolve) {
QPromise<void>{[&](const QPromiseResolve<void>& resolve) {
QtConcurrent::run([=, &source]() {
source = QThread::currentThread();
resolve();
});
}).then([&]() {
}}.then([&]() {
target = QThread::currentThread();
value = 43;
}).wait();
@ -79,12 +79,12 @@ void tst_thread::reject()
QThread* target = nullptr;
QThread* source = nullptr;
QPromise<int>([&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QPromise<int>{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QtConcurrent::run([=, &source]() {
source = QThread::currentThread();
reject(QString("foo"));
reject(QString{"foo"});
});
}).fail([&](const QString& err) {
}}.fail([&](const QString& err) {
target = QThread::currentThread();
error = err;
return -1;
@ -93,16 +93,16 @@ void tst_thread::reject()
QVERIFY(source != nullptr);
QVERIFY(source != target);
QCOMPARE(target, QThread::currentThread());
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
}
void tst_thread::then()
{
QThread* source = nullptr;
QPromise<int> p([&](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[&](const QPromiseResolve<int>& resolve) {
source = QThread::currentThread();
resolve(42);
});
}};
int value = -1;
QThread* target = nullptr;
@ -122,10 +122,10 @@ void tst_thread::then()
void tst_thread::then_void()
{
QThread* source = nullptr;
QPromise<void> p([&](const QPromiseResolve<void>& resolve) {
QPromise<void> p{[&](const QPromiseResolve<void>& resolve) {
source = QThread::currentThread();
resolve();
});
}};
int value = -1;
QThread* target = nullptr;
@ -145,10 +145,10 @@ void tst_thread::then_void()
void tst_thread::fail()
{
QThread* source = nullptr;
QPromise<int> p([&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
QPromise<int> p{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
source = QThread::currentThread();
reject(QString("foo"));
});
reject(QString{"foo"});
}};
QString error;
QThread* target = nullptr;
@ -163,16 +163,16 @@ void tst_thread::fail()
QVERIFY(target != nullptr);
QVERIFY(source != target);
QCOMPARE(source, QThread::currentThread());
QCOMPARE(error, QString("foo"));
QCOMPARE(error, QString{"foo"});
}
void tst_thread::finally()
{
QThread* source = nullptr;
QPromise<int> p([&](const QPromiseResolve<int>& resolve) {
QPromise<int> p{[&](const QPromiseResolve<int>& resolve) {
source = QThread::currentThread();
resolve(42);
});
}};
int value = -1;
QThread* target = nullptr;