Use C++11 curly braces initialization

docs/qtpromise/getting-started.md

@@ -145,11 +145,11 @@ will be resolved when the network request is finished:
 ```cpp
 QtPromise::QPromise<QByteArray> download(const QUrl& url)
 {
-    return QtPromise::QPromise<QByteArray>([&](
+    return QtPromise::QPromise<QByteArray>{[&](
         const QtPromise::QPromiseResolve<QByteArray>& resolve,
         const QtPromise::QPromiseReject<QByteArray>& reject) {
 
-        QNetworkReply* reply = manager->get(QNetworkRequest(url));
+        QNetworkReply* reply = manager->get(QNetworkRequest{url});
         QObject::connect(reply, &QNetworkReply::finished, [=]() {
             if (reply->error() == QNetworkReply::NoError) {
                 resolve(reply->readAll());
@@ -159,7 +159,7 @@ QtPromise::QPromise<QByteArray> download(const QUrl& url)
 
             reply->deleteLater();
         });
-    });
+    }};
 }
 ```
 
@@ -174,7 +174,7 @@ QtPromise::QPromise<Entries> uncompress(const QByteArray& data)
         // {...} uncompress data and parse content.
 
         if (error) {
-            throw MalformedException();
+            throw MalformedException{};
         }
 
         return entries;
@@ -193,7 +193,7 @@ It's then easy to chain the whole asynchronous process using promises:
 ```cpp
 download(url).then(&uncompress).then([](const Entries& entries) {
     if (entries.isEmpty()) {
-        throw UpdateException("No entries");
+        throw UpdateException{"No entries"};
     }
     // {...} process entries
 }).finally([]() {

docs/qtpromise/helpers/attempt.md

@@ -29,7 +29,7 @@ QPromise<QByteArray> process(const QUrl& url)
 {
     return QtPromise::attempt([&]() {
         if (!url.isValid()) {
-            throw InvalidUrlException();
+            throw InvalidUrlException{};
         }
 
         return download(url);

docs/qtpromise/helpers/connect.md

@@ -31,7 +31,7 @@ Q_SIGNALS:
     void error(ErrorCode);
 };
 
-auto sender = new Sender();
+auto sender = new Sender{};
 auto output = QtPromise::connect(sender, &Sender::finished, &Sender::error);
 
 // 'output' resolves as soon as one of the following events happens:

docs/qtpromise/helpers/each.md

@@ -27,9 +27,9 @@ auto output = QtPromise::each(QVector<QUrl>{
     QUrl("http://b..."),
     QUrl("http://c...")
 }, [](const QUrl& url, ...) {
-    return QPromise<void>([&](auto resolve, auto reject) {
+    return QPromise<void>{[&](auto resolve, auto reject) {
         // process url asynchronously ...
-    })
+    }};
 });
 
 // `output` resolves as soon as all promises returned by

docs/qtpromise/helpers/filter.md

@@ -29,10 +29,10 @@ auto output = QtPromise::filter(QVector{
     QUrl("http://b..."),
     QUrl("http://c...")
 }, [](const QUrl& url, ...) {
-    return QPromise<bool>([&](auto resolve, auto reject) {
+    return QPromise<bool>{[&](auto resolve, auto reject) {
         // resolve(true) if 'url' is reachable, else resolve(false)
         // {...}
-    });
+    }};
 });
 
 // 'output' resolves as soon as all promises returned by

docs/qtpromise/helpers/map.md

@@ -28,10 +28,10 @@ auto output = QtPromise::map(QVector{
     QUrl("http://b..."),
     QUrl("http://c...")
 }, [](const QUrl& url, ...) {
-    return QPromise<QByteArray>([&](auto resolve, auto reject) {
+    return QPromise<QByteArray>{[&](auto resolve, auto reject) {
         // download content at url and resolve
         // {...}
-    });
+    }};
 });
 
 // 'output' resolves as soon as all promises returned by

docs/qtpromise/helpers/reduce.md

@@ -33,9 +33,9 @@ auto output = QtPromise::reduce(QList<QUrl>{
     "file:f2.txt"    // contains "42"
 }, [](const QString& acc, const QString& cur, int idx) {
     return readAsync(cur).then([=](const QString& res) {
-        return QString("%1;%2:%3").arg(acc).arg(idx).arg(res);
+        return QString{"%1;%2:%3"}.arg(acc).arg(idx).arg(res);
     });
-}, QString("index:text"));
+}, QString{"index:text"});
 
 // 'output' resolves as soon as all promises returned by
 // 'reducer' are fulfilled or at least one is rejected.

docs/qtpromise/helpers/resolve.md

@@ -16,7 +16,7 @@ resolved from a given `value` but without the extra typing:
 ```cpp
 auto promise = QtPromise::resolve();                // QPromise<void>
 auto promise = QtPromise::resolve(42);              // QPromise<int>
-auto promise = QtPromise::resolve(QString("foo"));  // QPromise<QString>
+auto promise = QtPromise::resolve(QString{"foo"});  // QPromise<QString>
 ```
 
 This method also allows to convert `QFuture<T>` to `QPromise<T>`, delayed until the `QFuture` is

docs/qtpromise/qpromise/constructor.md

@@ -18,7 +18,7 @@ QPromise<int> promise([](const QPromiseResolve<int>& resolve, const QPromiseReje
         if (success) {
             resolve(result);
         } else {
-            reject(customException());
+            reject(customException{});
         }
     });
 });
@@ -32,9 +32,9 @@ no argument.
 C++14 alternative:
 
 ```cpp
-QPromise<int> promise([](const auto& resolve, const auto& reject) {
+QPromise<int> promise{[](const auto& resolve, const auto& reject) {
     // {...}
-});
+}};
 ```
 
 ## Undefined rejection reason
@@ -46,7 +46,7 @@ a promise without explicit reason, in which case, a built-in [`QPromiseUndefined
 is thrown:
 
 ```cpp
-QPromise<int> promise([](const QPromiseResolve<int>& resolve, const QPromiseReject<int>& reject) {
+QPromise<int> promise{[](const QPromiseResolve<int>& resolve, const QPromiseReject<int>& reject) {
     async_method([=](bool success, int result) {
         if (success) {
             resolve(result);
@@ -54,7 +54,7 @@ QPromise<int> promise([](const QPromiseResolve<int>& resolve, const QPromiseReje
             reject();
         }
     });
-});
+}};
 ```
 
 ```cpp

docs/qtpromise/qpromise/each.md

@@ -43,9 +43,9 @@ of the promise that rejected, whether or not the other promises are resolved.
 QPromise<QList<QUrl>> input = {...}
 
 auto output = input.each([](const QUrl& url, ...) {
-    return QPromise<void>([&](auto resolve, auto reject) {
+    return QPromise<void>{[&](auto resolve, auto reject) {
         // process url asynchronously ...
-    })
+    }};
 });
 
 // `output` resolves as soon as all promises returned by

docs/qtpromise/qpromise/filter.md

@@ -33,9 +33,9 @@ QPromise<QList<QUrl>> input = {...}
 auto output = input.filter([](const QUrl& url, ...) {
     return url.isValid();  // Keep only valid URLs
 }).filter([](const QUrl& url, ...) {
-    return QPromise<bool>([&](auto resolve, auto reject) {
+    return QPromise<bool>{[&](auto resolve, auto reject) {
         // resolve(true) if `url` is reachable, else resolve(false)
-    });
+    }};
 });
 
 // 'output' resolves as soon as all promises returned by

docs/qtpromise/qpromise/map.md

@@ -30,14 +30,14 @@ promise that rejected, whether or not the other promises are resolved.
 QPromise<QList<QUrl>> input = {...}
 
 auto output = input.map([](const QUrl& url, int index) {
-    return QPromise<QByteArray>([&](auto resolve, auto reject) {
+    return QPromise<QByteArray>{[&](auto resolve, auto reject) {
         // download content at 'url' and resolve
         // {...}
-    });
+    }};
 }).map([](const QByteArray& value, ...) {
     // process the downloaded QByteArray
     // {...}
-    return DownloadResult(value);
+    return DownloadResult{value};
 });
 
 // 'output' resolves as soon as all promises returned by

docs/qtpromise/qpromise/reduce.md

@@ -44,9 +44,9 @@ auto input = QtPromise::resolve(QList<QUrl>{
 // Concatenate the content of the given files, read asynchronously
 auto output = input.reduce([](const QString& acc, const QString& cur, int idx) {
     return readAsync(cur).then([=](const QString& res) {
-        return QString("%1;%2:%3").arg(acc).arg(idx).arg(res);
+        return QString{"%1;%2:%3"}.arg(acc).arg(idx).arg(res);
     });
-}, QString("index:text"));
+}, QString{"index:text"});
 
 // 'output' resolves as soon as all promises returned by
 // 'reducer' are fulfilled or at least one is rejected.

docs/qtpromise/qpromise/reject.md

@@ -16,11 +16,11 @@ Creates a `QPromise<T>` that is rejected with the given `reason` of *whatever ty
 QPromise<int> compute(const QString& type)
 {
     if (type == "foobar") {
-        return QPromise<int>::reject(QString("Unknown type: %1").arg(type));
+        return QPromise<int>::reject(QString{"Unknown type: %1"}.arg(type));
     }
 
-    return QPromise<int>([](const QPromiseResolve<int>& resolve) {
+    return QPromise<int>{[](const QPromiseResolve<int>& resolve) {
         // {...}
-    });
+    }};
 }
 ```

docs/qtpromise/qpromise/resolve.md

@@ -19,9 +19,9 @@ QPromise<int> compute(const QString& type)
         return QPromise<int>::resolve(42);
     }
 
-    return QPromise<int>([](const QPromiseResolve<int>& resolve) {
+    return QPromise<int>{[](const QPromiseResolve<int>& resolve) {
         // {...}
-    });
+    }};
 }
 ```
 

docs/qtpromise/qtconcurrent.md

@@ -35,7 +35,7 @@ QPromise<int> input = ...
 auto output = input.then([](int res) {
     return QtConcurrent::run([]() {
         // {...}
-        return QString("42");
+        return QString{"42"};
     });
 });
 
@@ -62,10 +62,10 @@ promise.then([](int res) {
         // {...}
 
         if (!success) {
-            throw CustomException();
+            throw CustomException{};
         }
 
-        return QString("42");
+        return QString{"42"};
     });
 }).fail([](const CustomException& error) {
     // {...}

src/qtpromise/qpromise.h

@@ -31,8 +31,8 @@ public:
     template <typename F, typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count == 2, int>::type = 0>
     inline QPromiseBase(F resolver);
 
-    QPromiseBase(const QPromiseBase<T>& other): m_d(other.m_d) {}
+    QPromiseBase(const QPromiseBase<T>& other): m_d{other.m_d} {}
-    QPromiseBase(const QPromise<T>& other): m_d(other.m_d) {}
+    QPromiseBase(const QPromise<T>& other): m_d{other.m_d} {}
     QPromiseBase(QPromiseBase<T>&& other) Q_DECL_NOEXCEPT { swap(other); }
 
     virtual ~QPromiseBase() { }
@@ -72,10 +72,10 @@ public:
     inline QPromise<T> tapFail(THandler handler) const;
 
     template <typename E = QPromiseTimeoutException>
-    inline QPromise<T> timeout(int msec, E&& error = E()) const;
+    inline QPromise<T> timeout(int msec, E&& error = E{}) const;
 
     template <typename E = QPromiseTimeoutException>
-    inline QPromise<T> timeout(std::chrono::milliseconds msec, E&& error = E()) const;
+    inline QPromise<T> timeout(std::chrono::milliseconds msec, E&& error = E{}) const;
 
     inline QPromise<T> delay(int msec) const;
     inline QPromise<T> delay(std::chrono::milliseconds msec) const;

src/qtpromise/qpromise.inl

@@ -17,9 +17,9 @@ namespace QtPromise {
 template <typename T>
 template <typename F, typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count == 1, int>::type>
 inline QPromiseBase<T>::QPromiseBase(F callback)
-    : m_d(new QtPromisePrivate::PromiseData<T>())
+    : m_d{new QtPromisePrivate::PromiseData<T>{}}
 {
-    QtPromisePrivate::PromiseResolver<T> resolver(*this);
+    QtPromisePrivate::PromiseResolver<T> resolver{*this};
 
     try {
         callback(QPromiseResolve<T>(resolver));
@@ -31,9 +31,9 @@ inline QPromiseBase<T>::QPromiseBase(F callback)
 template <typename T>
 template <typename F, typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count == 2, int>::type>
 inline QPromiseBase<T>::QPromiseBase(F callback)
-    : m_d(new QtPromisePrivate::PromiseData<T>())
+    : m_d{new QtPromisePrivate::PromiseData<T>{}}
 {
-    QtPromisePrivate::PromiseResolver<T> resolver(*this);
+    QtPromisePrivate::PromiseResolver<T> resolver{*this};
 
     try {
         callback(QPromiseResolve<T>(resolver), QPromiseReject<T>(resolver));
@@ -115,7 +115,7 @@ template <typename E>
 inline QPromise<T> QPromiseBase<T>::timeout(int msec, E&& error) const
 {
     QPromise<T> p = *this;
-    return QPromise<T>([&](
+    return QPromise<T>{[&](
         const QPromiseResolve<T>& resolve,
         const QPromiseReject<T>& reject) {
 
@@ -127,7 +127,7 @@ inline QPromise<T> QPromiseBase<T>::timeout(int msec, E&& error) const
         });
 
         QtPromisePrivate::PromiseFulfill<QPromise<T>>::call(p, resolve, reject);
-    });
+    }};
 }
 
 template <typename T>
@@ -141,9 +141,9 @@ template <typename T>
 inline QPromise<T> QPromiseBase<T>::delay(int msec) const
 {
     return tap([=]() {
-        return QPromise<void>([&](const QPromiseResolve<void>& resolve) {
+        return QPromise<void>{[&](const QPromiseResolve<void>& resolve) {
             QTimer::singleShot(msec, resolve);
-        });
+        }};
     });
 }
 
@@ -169,9 +169,9 @@ template <typename T>
 template <typename E>
 inline QPromise<T> QPromiseBase<T>::reject(E&& error)
 {
-    return QPromise<T>([&](const QPromiseResolve<T>&, const QPromiseReject<T>& reject) {
+    return QPromise<T>{[&](const QPromiseResolve<T>&, const QPromiseReject<T>& reject) {
         reject(std::forward<E>(error));
-    });
+    }};
 }
 
 template <typename T>
@@ -246,17 +246,17 @@ inline QPromise<QVector<T>> QPromise<T>::all(const Sequence<QPromise<T>, Args...
 template <typename T>
 inline QPromise<T> QPromise<T>::resolve(const T& value)
 {
-    return QPromise<T>([&](const QPromiseResolve<T>& resolve) {
+    return QPromise<T>{[&](const QPromiseResolve<T>& resolve) {
        resolve(value);
-    });
+    }};
 }
 
 template <typename T>
 inline QPromise<T> QPromise<T>::resolve(T&& value)
 {
-    return QPromise<T>([&](const QPromiseResolve<T>& resolve) {
+    return QPromise<T>{[&](const QPromiseResolve<T>& resolve) {
        resolve(std::forward<T>(value));
-    });
+    }};
 }
 
 template <template <typename, typename...> class Sequence, typename ...Args>

src/qtpromise/qpromise_p.h

@@ -42,8 +42,8 @@ static void qtpromise_defer(F&& f, const QPointer<QThread>& thread)
 
     struct Event : public QEvent
     {
-        Event(FType&& f) : QEvent(QEvent::None), m_f(std::move(f)) { }
+        Event(FType&& f) : QEvent{QEvent::None}, m_f{std::move(f)} { }
-        Event(const FType& f) : QEvent(QEvent::None), m_f(f) { }
+        Event(const FType& f) : QEvent{QEvent::None}, m_f{f} { }
         ~Event() { m_f(); }
         FType m_f;
     };
@@ -66,7 +66,7 @@ static void qtpromise_defer(F&& f, const QPointer<QThread>& thread)
     }
 
     Q_ASSERT_X(target, "postMetaCall", "Target thread must have an event loop");
-    QCoreApplication::postEvent(target, new Event(std::forward<F>(f)));
+    QCoreApplication::postEvent(target, new Event{std::forward<F>(f)});
 }
 
 template <typename F>
@@ -104,7 +104,7 @@ public:
     }
 
     PromiseError() { }
-    PromiseError(const std::exception_ptr& exception) : m_data(exception) { }
+    PromiseError(const std::exception_ptr& exception) : m_data{exception} { }
     void rethrow() const { std::rethrow_exception(m_data); }
     bool isNull() const { return m_data == nullptr; }
 
@@ -422,19 +422,19 @@ public:
 
     bool isPending() const
     {
-        QReadLocker lock(&m_lock);
+        QReadLocker lock{&m_lock};
         return !m_settled;
     }
 
     void addHandler(std::function<F> handler)
     {
-        QWriteLocker lock(&m_lock);
+        QWriteLocker lock{&m_lock};
         m_handlers.append({QThread::currentThread(), std::move(handler)});
     }
 
     void addCatcher(std::function<void(const PromiseError&)> catcher)
     {
-        QWriteLocker lock(&m_lock);
+        QWriteLocker lock{&m_lock};
         m_catchers.append({QThread::currentThread(), std::move(catcher)});
     }
 
@@ -443,7 +443,7 @@ public:
     {
         Q_ASSERT(isPending());
         Q_ASSERT(m_error.isNull());
-        m_error = PromiseError(std::forward<E>(error));
+        m_error = PromiseError{std::forward<E>(error)};
         setSettled();
     }
 
@@ -467,8 +467,8 @@ public:
         // captured in the handler and/or catcher lambdas.
 
         m_lock.lockForWrite();
-        QVector<Handler> handlers(std::move(m_handlers));
+        QVector<Handler> handlers = std::move(m_handlers);
-        QVector<Catcher> catchers(std::move(m_catchers));
+        QVector<Catcher> catchers = std::move(m_catchers);
         m_lock.unlock();
 
         if (m_error.isNull()) {
@@ -476,7 +476,7 @@ public:
             return;
         }
 
-        PromiseError error(m_error);
+        PromiseError error = m_error;
         Q_ASSERT(!error.isNull());
 
         for (const auto& catcher: catchers) {
@@ -492,7 +492,7 @@ protected:
 
     void setSettled()
     {
-        QWriteLocker lock(&m_lock);
+        QWriteLocker lock{&m_lock};
         Q_ASSERT(!m_settled);
         m_settled = true;
     }
@@ -517,7 +517,7 @@ public:
     {
         Q_ASSERT(this->isPending());
         Q_ASSERT(m_value.isNull());
-        m_value = PromiseValue<T>(std::forward<V>(value));
+        m_value = PromiseValue<T>{std::forward<V>(value)};
         this->setSettled();
     }
 
@@ -529,7 +529,7 @@ public:
 
     void notify(const QVector<Handler>& handlers) Q_DECL_OVERRIDE
     {
-        PromiseValue<T> value(m_value);
+        PromiseValue<T> value = m_value;
         Q_ASSERT(!value.isNull());
 
         for (const auto& handler: handlers) {

src/qtpromise/qpromiseexceptions.h

@@ -21,7 +21,7 @@ public:
     void raise() const Q_DECL_OVERRIDE { throw *this; }
     QPromiseCanceledException* clone() const Q_DECL_OVERRIDE
     {
-        return new QPromiseCanceledException(*this);
+        return new QPromiseCanceledException{*this};
     }
 };
 
@@ -31,7 +31,7 @@ public:
     void raise() const Q_DECL_OVERRIDE { throw *this; }
     QPromiseContextException* clone() const Q_DECL_OVERRIDE
     {
-        return new QPromiseContextException(*this);
+        return new QPromiseContextException{*this};
     }
 };
 
@@ -41,7 +41,7 @@ public:
     void raise() const Q_DECL_OVERRIDE { throw *this; }
     QPromiseTimeoutException* clone() const Q_DECL_OVERRIDE
     {
-        return new QPromiseTimeoutException(*this);
+        return new QPromiseTimeoutException{*this};
     }
 };
 
@@ -51,7 +51,7 @@ public:
     void raise() const Q_DECL_OVERRIDE { throw *this; }
     QPromiseUndefinedException* clone() const Q_DECL_OVERRIDE
     {
-        return new QPromiseUndefinedException(*this);
+        return new QPromiseUndefinedException{*this};
     }
 };
 

src/qtpromise/qpromisefuture.h

@@ -30,7 +30,7 @@ struct PromiseFulfill<QFuture<T>>
     {
         using Watcher = QFutureWatcher<T>;
 
-        Watcher* watcher = new Watcher();
+        Watcher* watcher = new Watcher{};
         QObject::connect(watcher, &Watcher::finished, [=]() mutable {
             try {
                 if (watcher->isCanceled()) {
@@ -40,7 +40,7 @@ struct PromiseFulfill<QFuture<T>>
                     // rethrown potential exceptions using waitForFinished() and thus detect
                     // if the future has been canceled by the user or an exception.
                     watcher->waitForFinished();
-                    reject(QtPromise::QPromiseCanceledException());
+                    reject(QtPromise::QPromiseCanceledException{});
                 } else {
                     PromiseFulfill<T>::call(watcher->result(), resolve, reject);
                 }
@@ -65,13 +65,13 @@ struct PromiseFulfill<QFuture<void>>
     {
         using Watcher = QFutureWatcher<void>;
 
-        Watcher* watcher = new Watcher();
+        Watcher* watcher = new Watcher{};
         QObject::connect(watcher, &Watcher::finished, [=]() mutable {
             try {
                 if (watcher->isCanceled()) {
                     // let's rethrown potential exception
                     watcher->waitForFinished();
-                    reject(QtPromise::QPromiseCanceledException());
+                    reject(QtPromise::QPromiseCanceledException{});
                 } else {
                     resolve();
                 }

src/qtpromise/qpromisehelpers.h

@@ -23,12 +23,12 @@ resolve(T&& value)
     using ResolveType = QPromiseResolve<ValueType>;
     using RejectType = QPromiseReject<ValueType>;
 
-    return PromiseType([&](ResolveType&& resolve, RejectType&& reject) {
+    return PromiseType{[&](ResolveType&& resolve, RejectType&& reject) {
         PromiseFulfill<Unqualified<T>>::call(
             std::forward<T>(value),
             std::forward<ResolveType>(resolve),
             std::forward<RejectType>(reject));
-    });
+    }};
 }
 
 template <typename T>
@@ -41,9 +41,9 @@ resolve(QPromise<T> value)
 static inline QPromise<void>
 resolve()
 {
-    return QPromise<void>([](const QPromiseResolve<void>& resolve) {
+    return QPromise<void>{[](const QPromiseResolve<void>& resolve) {
         resolve();
-    });
+    }};
 }
 
 template <typename T, template <typename, typename...> class Sequence = QVector, typename ...Args>
@@ -55,7 +55,7 @@ all(const Sequence<QPromise<T>, Args...>& promises)
         return QtPromise::resolve(QVector<T>{});
     }
 
-    return QPromise<QVector<T>>([=](
+    return QPromise<QVector<T>>{[=](
         const QPromiseResolve<QVector<T>>& resolve,
         const QPromiseReject<QVector<T>>& reject) {
 
@@ -78,7 +78,7 @@ all(const Sequence<QPromise<T>, Args...>& promises)
 
             i++;
         }
-    });
+    }};
 }
 
 template <template <typename, typename...> class Sequence = QVector, typename ...Args>
@@ -90,7 +90,7 @@ all(const Sequence<QPromise<void>, Args...>& promises)
         return QtPromise::resolve();
     }
 
-    return QPromise<void>([=](
+    return QPromise<void>{[=](
         const QPromiseResolve<void>& resolve,
         const QPromiseReject<void>& reject) {
 
@@ -108,7 +108,7 @@ all(const Sequence<QPromise<void>, Args...>& promises)
                 }
             });
         }
-    });
+    }};
 }
 
 template <typename Functor, typename... Args>
@@ -127,14 +127,14 @@ attempt(Functor&& fn, Args&&... args)
     using ResolveType = QPromiseResolve<ValueType>;
     using RejectType = QPromiseReject<ValueType>;
 
-    return PromiseType(
+    return PromiseType{
         [&](ResolveType&& resolve, RejectType&& reject) {
             PromiseDispatch<typename FunctorType::ResultType>::call(
                 std::forward<ResolveType>(resolve),
                 std::forward<RejectType>(reject),
                 std::forward<Functor>(fn),
                 std::forward<Args>(args)...);
-        });
+        }};
 }
 
 template <typename Sender, typename Signal>
@@ -144,12 +144,12 @@ connect(const Sender* sender, Signal signal)
     using namespace QtPromisePrivate;
     using T = typename PromiseFromSignal<Signal>::Type;
 
-    return QPromise<T>(
+    return QPromise<T>{
         [&](const QPromiseResolve<T>& resolve, const QPromiseReject<T>& reject) {
             QPromiseConnections connections;
             connectSignalToResolver(connections, resolve, sender, signal);
             connectDestroyedToReject(connections, reject, sender);
-        });
+        }};
 }
 
 template <typename FSender, typename FSignal, typename RSender, typename RSignal>
@@ -159,13 +159,13 @@ connect(const FSender* fsender, FSignal fsignal, const RSender* rsender, RSignal
     using namespace QtPromisePrivate;
     using T = typename PromiseFromSignal<FSignal>::Type;
 
-    return QPromise<T>(
+    return QPromise<T>{
         [&](const QPromiseResolve<T>& resolve, const QPromiseReject<T>& reject) {
             QPromiseConnections connections;
             connectSignalToResolver(connections, resolve, fsender, fsignal);
             connectSignalToResolver(connections, reject, rsender, rsignal);
             connectDestroyedToReject(connections, reject, fsender);
-        });
+        }};
 }
 
 template <typename Sender, typename FSignal, typename RSignal>
@@ -195,11 +195,11 @@ map(const Sequence& values, Functor fn)
 
     std::vector<QPromise<ResType>> promises;
     for (const auto& v : values) {
-        promises.push_back(QPromise<ResType>([&](
+        promises.push_back(QPromise<ResType>{[&](
             const QPromiseResolve<ResType>& resolve,
             const QPromiseReject<ResType>& reject) {
                 PromiseFulfill<RetType>::call(fn(v, i), resolve, reject);
-            }));
+            }});
 
         i++;
     }

src/qtpromise/qpromisehelpers_p.h

@@ -45,7 +45,7 @@ connectSignalToResolver(
 {
     connections << QObject::connect(sender, signal, [=]() {
         connections.disconnect();
-        reject(QtPromise::QPromiseUndefinedException());
+        reject(QtPromise::QPromiseUndefinedException{});
     });
 }
 
@@ -89,7 +89,7 @@ void connectDestroyedToReject(
 {
     connections << QObject::connect(sender, &QObject::destroyed, [=]() {
         connections.disconnect();
-        reject(QtPromise::QPromiseContextException());
+        reject(QtPromise::QPromiseContextException{});
     });
 }
 

src/qtpromise/qpromiseresolver.h

@@ -25,9 +25,9 @@ class PromiseResolver
 {
 public:
     PromiseResolver(QtPromise::QPromise<T> promise)
-        : m_d(new Data())
+        : m_d{new Data{}}
     {
-        m_d->promise = new QtPromise::QPromise<T>(std::move(promise));
+        m_d->promise = new QtPromise::QPromise<T>{std::move(promise)};
     }
 
     template <typename E>
@@ -47,7 +47,7 @@ public:
         auto promise = m_d->promise;
         if (promise) {
             Q_ASSERT(promise->isPending());
-            promise->m_d->reject(QtPromise::QPromiseUndefinedException());
+            promise->m_d->reject(QtPromise::QPromiseUndefinedException{});
             promise->m_d->dispatch();
             release();
         }
@@ -102,7 +102,7 @@ class QPromiseResolve
 {
 public:
     QPromiseResolve(QtPromisePrivate::PromiseResolver<T> resolver)
-        : m_resolver(std::move(resolver))
+        : m_resolver{std::move(resolver)}
     { }
 
     template <typename V>
@@ -125,7 +125,7 @@ class QPromiseReject
 {
 public:
     QPromiseReject(QtPromisePrivate::PromiseResolver<T> resolver)
-        : m_resolver(std::move(resolver))
+        : m_resolver{std::move(resolver)}
     { }
 
     template <typename E>

tests/auto/qtpromise/benchmark/tst_benchmark.cpp

@@ -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) {
+        QPromise<Data>{[&](const QPromiseResolve<Data>& resolve) {
-            resolve(Data(42));
+            resolve(Data{42});
-        }).wait();
+        }}.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) {
+        QPromise<Data>{[&](const QPromiseResolve<Data>& resolve) {
-            Data value(42);
+            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) {
+        QPromise<Data>{[&](const QPromiseResolve<Data>&, const QPromiseReject<Data>& reject) {
-            reject(QString("foo"));
+            reject(QString{"foo"});
-        }).wait();
+        }}.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");
+            throw QString{"foo"};
-            return Data(res+2);
+            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) {
+        QPromise<int>{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
-            reject(Data(42));
+            reject(Data{42});
-        }).wait();
+        }}.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) {
+        QPromise<int>{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
-            Data error(42);
+            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();

tests/auto/qtpromise/deprecations/tst_helpers_qpromise.cpp

@@ -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(p1, QSharedPointer<Data>{}), sptr0);
-        QCOMPARE(waitForValue(p2, QSharedPointer<Data>()), sptr1);
+        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(p1, std::shared_ptr<Data>{}), sptr0);
-        QCOMPARE(waitForValue(p2, std::shared_ptr<Data>()), sptr1);
+        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);
 

tests/auto/qtpromise/deprecations/tst_helpers_qpromiseall.cpp

@@ -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);

tests/auto/qtpromise/deprecations/tst_qpromise_all.cpp

@@ -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);

tests/auto/qtpromise/future/tst_future.cpp

@@ -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"});
 }

tests/auto/qtpromise/helpers/tst_all.cpp

@@ -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);

tests/auto/qtpromise/helpers/tst_attempt.cpp

@@ -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"});
 }

tests/auto/qtpromise/helpers/tst_connect.cpp

@@ -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();
+    auto s0 = new Object{};
-    Object* s1 = new Object();
+    auto s1 = new Object{};
 
     QtPromisePrivate::qtpromise_defer([&]() {
         QObject::connect(s1, &QObject::destroyed, [&]() {

tests/auto/qtpromise/helpers/tst_each.cpp

@@ -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(waitForValue(p, Sequence{}), (Sequence{42, 43, 44}));
-        QCOMPARE(values, QVector<int>({0, 42, 1, 43, 2, 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(waitForValue(p, QVector<int>{}), QVector<int>{});
-    QCOMPARE(values, 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(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
-    QCOMPARE(values, QVector<int>({43, 44, 45}));
+    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(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
-    QCOMPARE(values, QVector<int>({43, 44, 45}));
+    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(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
-    QCOMPARE(values, QVector<int>({0, 42, 1, 43, 2, 44}));
+    QCOMPARE(values, (QVector<int>{0, 42, 1, 43, 2, 44}));
 }
 
 void tst_helpers_each::sequenceTypes()

tests/auto/qtpromise/helpers/tst_filter.cpp

@@ -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()

tests/auto/qtpromise/helpers/tst_map.cpp

@@ -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()

tests/auto/qtpromise/helpers/tst_reduce.cpp

@@ -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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-        QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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);
+        return QString{"%1:%2:%3"}.arg(acc).arg(cur).arg(idx);
-    }, QString("foo"));
+    }, 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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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(p0, QString{}), QString{"foo"});
-    QCOMPARE(waitForError(p1, QString()), QString("bar"));
+    QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
-    QCOMPARE(v0, QVector<int>({4, 6, 1}));
+    QCOMPARE(v0, (QVector<int>{4, 6, 1}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 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(p0, QString{}), QString{"foo"});
-    QCOMPARE(waitForError(p1, QString()), QString("bar"));
+    QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
-    QCOMPARE(v0, QVector<int>({4, 6, 1}));
+    QCOMPARE(v0, (QVector<int>{4, 6, 1}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1}));
+    QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1}));
 }
 
 void tst_helpers_reduce::sequenceTypes()

tests/auto/qtpromise/helpers/tst_reject.cpp

@@ -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();

tests/auto/qtpromise/helpers/tst_resolve.cpp

@@ -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(p1, QSharedPointer<Data>{}), sptr0);
-        QCOMPARE(waitForValue(p2, QSharedPointer<Data>()), sptr1);
+        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(p1, std::shared_ptr<Data>{}), sptr0);
-        QCOMPARE(waitForValue(p2, std::shared_ptr<Data>()), sptr1);
+        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);
 

tests/auto/qtpromise/qpromise/tst_construct.cpp

@@ -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) {
+    QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
-        reject(QString("foo"));
+        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) {
+    QPromise<void> p{[](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
-        reject(QString("foo"));
+        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>&) {
+    QPromise<int> p{[](const QPromiseResolve<int>&) {
-        throw QString("foo");
+        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>&) {
+    QPromise<void> p{[](const QPromiseResolve<void>&) {
-        throw QString("foo");
+        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>&) {
+    QPromise<int> p{[](const QPromiseResolve<int>&, const QPromiseReject<int>&) {
-        throw QString("foo");
+        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>&) {
+    QPromise<void> p{[](const QPromiseResolve<void>&, const QPromiseReject<void>&) {
-        throw QString("foo");
+        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
     }
 

tests/auto/qtpromise/qpromise/tst_delay.cpp

@@ -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);
 }

tests/auto/qtpromise/qpromise/tst_each.cpp

@@ -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(waitForValue(p, QVector<int>{}), QVector<int>{});
-    QCOMPARE(values, 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(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
-    QCOMPARE(values, QVector<int>({43, 44, 45}));
+    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(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
-    QCOMPARE(values, QVector<int>({43, 44, 45}));
+    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(waitForValue(p, QVector<int>{}), (QVector<int>{42, 43, 44}));
-    QCOMPARE(values, QVector<int>({0, 42, 1, 43, 2, 44}));
+    QCOMPARE(values, (QVector<int>{0, 42, 1, 43, 2, 44}));
 }
 
 void tst_qpromise_each::sequenceTypes()

tests/auto/qtpromise/qpromise/tst_fail.cpp

@@ -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);

tests/auto/qtpromise/qpromise/tst_filter.cpp

@@ -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()

tests/auto/qtpromise/qpromise/tst_finally.cpp

@@ -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([&]() {
+    auto p = QPromise<int>::reject(QString{"foo"}).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::rejectedThrows_void()
 {
-    auto p = QPromise<void>::reject(QString("foo")).finally([&]() {
+    auto p = QPromise<void>::reject(QString{"foo"}).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);
 }
 
 void tst_qpromise_finally::rejectedAsyncResolve()
 {
     QVector<int> values;
-    auto p = QPromise<int>::reject(QString("foo")).finally([&]() {
+    auto p = QPromise<int>::reject(QString{"foo"}).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;
@@ -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([]() {
+    auto p = QPromise<int>::reject(QString{"foo"}).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);
 }

tests/auto/qtpromise/qpromise/tst_map.cpp

@@ -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()

tests/auto/qtpromise/qpromise/tst_operators.cpp

@@ -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}));
 }

tests/auto/qtpromise/qpromise/tst_reduce.cpp

@@ -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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-        QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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);
+        return QString{"%1:%2:%3"}.arg(acc).arg(cur).arg(idx);
-    }, QString("foo"));
+    }, 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(v0, (QVector<int>{4, 6, 1, 11, 8, 2}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1, 13, 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(p0, QString{}), QString{"foo"});
-    QCOMPARE(waitForError(p1, QString()), QString("bar"));
+    QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
-    QCOMPARE(v0, QVector<int>({4, 6, 1}));
+    QCOMPARE(v0, (QVector<int>{4, 6, 1}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 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(p0, QString{}), QString{"foo"});
-    QCOMPARE(waitForError(p1, QString()), QString("bar"));
+    QCOMPARE(waitForError(p1, QString{}), QString{"bar"});
-    QCOMPARE(v0, QVector<int>({4, 6, 1}));
+    QCOMPARE(v0, (QVector<int>{4, 6, 1}));
-    QCOMPARE(v1, QVector<int>({2, 4, 0, 6, 6, 1}));
+    QCOMPARE(v1, (QVector<int>{2, 4, 0, 6, 6, 1}));
 }
 
 void tst_qpromise_reduce::sequenceTypes()

tests/auto/qtpromise/qpromise/tst_resolve.cpp

@@ -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(p1, QSharedPointer<Data>{}), sptr0);
-        QCOMPARE(waitForValue(p2, QSharedPointer<Data>()), sptr1);
+        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(p1, std::shared_ptr<Data>{}), sptr0);
-        QCOMPARE(waitForValue(p2, std::shared_ptr<Data>()), sptr1);
+        QCOMPARE(waitForValue(p2, std::shared_ptr<Data>{}), sptr1);
 
         wptr = sptr0;
 

tests/auto/qtpromise/qpromise/tst_tap.cpp

@@ -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);
 }

tests/auto/qtpromise/qpromise/tst_tapfail.cpp

@@ -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(waitForError(p, QString{}), QString{"foo"});
-    QCOMPARE(values, QVector<int>({2, 3}));
+    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(waitForError(p, QString{}), QString{"bar"});
-    QCOMPARE(values, QVector<int>({2, 3}));
+    QCOMPARE(values, (QVector<int>{2, 3}));
 }

tests/auto/qtpromise/qpromise/tst_then.cpp

@@ -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);
     }
 }

tests/auto/qtpromise/qpromise/tst_timeout.cpp

@@ -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();
     });
 

tests/auto/qtpromise/requirements/tst_requirements.cpp

@@ -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) {
+        QPromise<int> p{[&](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
-            QtPromisePrivate::qtpromise_defer([=]() { reject(QString("foo")); });
+            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{"foo"});
-            reject(QString("bar"));
+            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{"foo"});
-            reject(QString("bar"));
+            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 p1 = QPromise<int>::reject(QString{"foo"});
-        auto p2 = p1.then(nullptr, [](){ throw QString("bar"); return 42; });
+        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"});
     }
 }

tests/auto/qtpromise/shared/data.h

@@ -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)
+        : Logger{other}
-        , m_value(other.m_value)
+        , 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);
     }

tests/auto/qtpromise/thread/tst_thread.cpp

@@ -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;