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>

1 files changed, 44 insertions, 6 deletions

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