Long live QVERIFY_THROWS_EXCEPTION!

Use variable args macros to swallow any extra commas in the
expression. To use this, the type of the exception has to be first.
Use Eddy's suggestion for a new name to avoid breaking the old macro.

[ChangeLog][QtTest] Added QVERIFY_THROWS_EXCEPTION, replacing
QVERIFY_EXCEPTION_THROWN, which has therefore been deprecated.

Change-Id: I16825c35bae0631c5fad5a9a3ace4d6edc067f83
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>

3 files changed, 46 insertions, 8 deletions

diff --git a/tests/auto/corelib/thread/qthread/tst_qthread.cpp b/tests/auto/corelib/thread/qthread/tst_qthread.cpp
index 9dcaaf99e9..d4950cd42b 100644
--- a/tests/auto/corelib/thread/qthread/tst_qthread.cpp
+++ b/tests/auto/corelib/thread/qthread/tst_qthread.cpp
@@ -1584,7 +1584,7 @@ void tst_QThread::create()
         const auto &function = [](const ThrowWhenCopying &){};
         QScopedPointer<QThread> thread;
         ThrowWhenCopying t;
-        QVERIFY_EXCEPTION_THROWN(thread.reset(QThread::create(function, t)), ThreadException);
+        QVERIFY_THROWS_EXCEPTION(ThreadException, thread.reset(QThread::create(function, t)));
         QVERIFY(!thread);
     }
 #endif // QT_NO_EXCEPTIONS
diff --git a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
index bd84d0bb3c..d526314d41 100644
--- a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
+++ b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
@@ -2688,7 +2688,7 @@ void tst_QSharedPointer::constructorThrow()
     int childDestructorCounter = ThrowData::childDestructorCounter;
 
     QSharedPointer<ThrowData> ptr;
-    QVERIFY_EXCEPTION_THROWN(ptr = QSharedPointer<ThrowData>::create(), QString);
+    QVERIFY_THROWS_EXCEPTION(QString, ptr = QSharedPointer<ThrowData>::create());
     QVERIFY(ptr.isNull());
     QCOMPARE(ThrowData::childGenerationCounter, childGeneration + 1);
     // destructor should never be called, if a constructor throws
diff --git a/tests/auto/testlib/selftests/verifyexceptionthrown/tst_verifyexceptionthrown.cpp b/tests/auto/testlib/selftests/verifyexceptionthrown/tst_verifyexceptionthrown.cpp
index e0e26a0a47..391031d1f4 100644
--- a/tests/auto/testlib/selftests/verifyexceptionthrown/tst_verifyexceptionthrown.cpp
+++ b/tests/auto/testlib/selftests/verifyexceptionthrown/tst_verifyexceptionthrown.cpp
@@ -81,67 +81,105 @@ private slots:
 
 void tst_VerifyExceptionThrown::testCorrectStdTypes() const
 {
+    QVERIFY_THROWS_EXCEPTION(int, throw int(5));
+    QVERIFY_THROWS_EXCEPTION(float, throw float(9.8));
+    QVERIFY_THROWS_EXCEPTION(bool, throw bool(true));
+    QVERIFY_THROWS_EXCEPTION(std::string, throw std::string("some string"));
+#if QT_DEPRECATED_SINCE(6, 3)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     QVERIFY_EXCEPTION_THROWN(throw int(5), int);
     QVERIFY_EXCEPTION_THROWN(throw float(9.8), float);
     QVERIFY_EXCEPTION_THROWN(throw bool(true), bool);
     QVERIFY_EXCEPTION_THROWN(throw std::string("some string"), std::string);
+    QT_WARNING_POP
+#endif
 }
 
 void tst_VerifyExceptionThrown::testCorrectStdExceptions() const
 {
     // same type
+    QVERIFY_THROWS_EXCEPTION(std::exception, throw std::exception());
+    QVERIFY_THROWS_EXCEPTION(std::runtime_error, throw std::runtime_error("runtime error"));
+    QVERIFY_THROWS_EXCEPTION(std::overflow_error, throw std::overflow_error("overflow error"));
+#if QT_DEPRECATED_SINCE(6, 3)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     QVERIFY_EXCEPTION_THROWN(throw std::exception(), std::exception);
     QVERIFY_EXCEPTION_THROWN(throw std::runtime_error("runtime error"), std::runtime_error);
     QVERIFY_EXCEPTION_THROWN(throw std::overflow_error("overflow error"), std::overflow_error);
+    QT_WARNING_POP
+#endif
 
     // inheritance
+    QVERIFY_THROWS_EXCEPTION(std::runtime_error, throw std::overflow_error("overflow error"));
+    QVERIFY_THROWS_EXCEPTION(std::exception, throw std::overflow_error("overflow error"));
+#if QT_DEPRECATED_SINCE(6, 3)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     QVERIFY_EXCEPTION_THROWN(throw std::overflow_error("overflow error"), std::runtime_error);
     QVERIFY_EXCEPTION_THROWN(throw std::overflow_error("overflow error"), std::exception);
+    QT_WARNING_POP
+#endif
 }
 
 void tst_VerifyExceptionThrown::testCorrectMyExceptions() const
 {
     // same type
+    QVERIFY_THROWS_EXCEPTION(MyBaseException, throw MyBaseException());
+    QVERIFY_THROWS_EXCEPTION(MyDerivedException, throw MyDerivedException());
+#if QT_DEPRECATED_SINCE(6, 3)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     QVERIFY_EXCEPTION_THROWN(throw MyBaseException(), MyBaseException);
     QVERIFY_EXCEPTION_THROWN(throw MyDerivedException(), MyDerivedException);
+    QT_WARNING_POP
+#endif
 
     // inheritance
+    QVERIFY_THROWS_EXCEPTION(MyBaseException, throw MyDerivedException());
+    QVERIFY_THROWS_EXCEPTION(std::domain_error, throw MyDerivedException());
+#if QT_DEPRECATED_SINCE(6, 3)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     QVERIFY_EXCEPTION_THROWN(throw MyDerivedException(), MyBaseException);
     QVERIFY_EXCEPTION_THROWN(throw MyDerivedException(), std::domain_error);
+    QT_WARNING_POP
+#endif
 }
 
 void tst_VerifyExceptionThrown::testFailInt() const
 {
     try {
-        QVERIFY_EXCEPTION_THROWN(throw int(5), double);
+        QVERIFY_THROWS_EXCEPTION(double, throw int(5));
     } catch (int) {}
 }
 
 void tst_VerifyExceptionThrown::testFailStdString() const
 {
     try {
-        QVERIFY_EXCEPTION_THROWN(throw std::string("some string"), char*);
+        QVERIFY_THROWS_EXCEPTION(char*, throw std::string("some string"));
     } catch (const std::string &) {}
 }
 
 void tst_VerifyExceptionThrown::testFailStdRuntimeError() const
 {
-    QVERIFY_EXCEPTION_THROWN(throw std::logic_error("logic error"), std::runtime_error);
+    QVERIFY_THROWS_EXCEPTION(std::runtime_error, throw std::logic_error("logic error"));
 }
 
 void tst_VerifyExceptionThrown::testFailMyException() const
 {
-    QVERIFY_EXCEPTION_THROWN(throw std::logic_error("logic error"), MyBaseException);
+    QVERIFY_THROWS_EXCEPTION(MyBaseException, throw std::logic_error("logic error"));
 }
 
 void tst_VerifyExceptionThrown::testFailMyDerivedException() const
 {
-    QVERIFY_EXCEPTION_THROWN(throw MyDerivedException(), std::runtime_error);
+    QVERIFY_THROWS_EXCEPTION(std::runtime_error, throw MyDerivedException());
 }
 
 void tst_VerifyExceptionThrown::testFailNoException() const
 {
-    QVERIFY_EXCEPTION_THROWN(doSomething(), std::exception);
+    QVERIFY_THROWS_EXCEPTION(std::exception, doSomething());
 }
 
 #endif // !QT_NO_EXCEPTIONS