tests/corelib: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b).

- Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer).
- Replace Q[TRY]_VERIFY(smartPointer == 0)  by
          Q[TRY]_VERIFY(smartPointer.isNull()).
- Replace Q[TRY]_VERIFY(a == b) by  Q[TRY]_COMPARE(a, b) and
  add casts where necessary. The values will then be logged
  should a test fail.

Tests from corelib/tools were omitted in this change.

Change-Id: I4c8786d33fcf429d11b2b624c7cd89c28cadb518
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

13 files changed, 134 insertions, 134 deletions

diff --git a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
index 060ef99d65..cecc02bf25 100644
--- a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
+++ b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
@@ -447,14 +447,14 @@ public slots:
     void threadProgress(int v)
     {
         ++count;
-        QVERIFY(v == count);
+        QCOMPARE(v, count);
 
         QCoreApplication::postEvent(this, new QEvent(QEvent::MaxUser), -1);
     }
 
     void threadFinished()
     {
-        QVERIFY(count == 7);
+        QCOMPARE(count, 7);
         count = 0;
         thread->deleteLater();
 
@@ -927,7 +927,7 @@ void tst_QCoreApplication::addRemoveLibPaths()
     QStringList replace;
     replace << currentDir << paths[0];
     QCoreApplication::setLibraryPaths(replace);
-    QVERIFY(QCoreApplication::libraryPaths() == replace);
+    QCOMPARE(QCoreApplication::libraryPaths(), replace);
 }
 
 static void createQObjectOnDestruction()
diff --git a/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp b/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
index cf3ff04aa4..8d5d34d10d 100644
--- a/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
+++ b/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
@@ -599,8 +599,8 @@ void tst_QMetaMethod::method()
     QFETCH(QMetaMethod::MethodType, methodType);
     QFETCH(QMetaMethod::Access, access);
 
-    QVERIFY(parameterTypes.size() == parameterTypeNames.size());
-    QVERIFY(parameterTypes.size() == parameterNames.size());
+    QCOMPARE(parameterTypes.size(), parameterTypeNames.size());
+    QCOMPARE(parameterTypes.size(), parameterNames.size());
 
     const QMetaObject *mo = &MethodTestObject::staticMetaObject;
     int index = (methodType == QMetaMethod::Constructor)
diff --git a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
index 7c19bfb89c..0a84a019d0 100644
--- a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
+++ b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
@@ -811,7 +811,7 @@ void tst_QMetaObject::invokeBlockingQueuedMetaMember()
 
 void tst_QMetaObject::qtMetaObjectInheritance()
 {
-    QVERIFY(QObject::staticMetaObject.superClass() == 0);
+    QVERIFY(!QObject::staticMetaObject.superClass());
     QCOMPARE(QSortFilterProxyModel::staticMetaObject.indexOfEnumerator("Qt::CaseSensitivity"), -1);
     QCOMPARE(QSortFilterProxyModel::staticMetaObject.indexOfEnumerator("CaseSensitivity"), -1);
     int indexOfSortCaseSensitivity = QSortFilterProxyModel::staticMetaObject.indexOfProperty("sortCaseSensitivity");
@@ -878,7 +878,7 @@ void tst_QMetaObject::invokeMetaConstructor()
     const QMetaObject *mo = &QtTestObject::staticMetaObject;
     {
         QObject *obj = mo->newInstance();
-        QVERIFY(obj == 0);
+        QVERIFY(!obj);
     }
     {
         QtTestObject obj;
diff --git a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
index 74fcde2e71..6cf45bed1e 100644
--- a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
+++ b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
@@ -138,14 +138,14 @@ void tst_QMetaObjectBuilder::create()
 {
     QMetaObjectBuilder builder;
     QVERIFY(builder.className().isEmpty());
-    QVERIFY(builder.superClass() == &QObject::staticMetaObject);
+    QCOMPARE(builder.superClass(), &QObject::staticMetaObject);
     QCOMPARE(builder.methodCount(), 0);
     QCOMPARE(builder.constructorCount(), 0);
     QCOMPARE(builder.propertyCount(), 0);
     QCOMPARE(builder.enumeratorCount(), 0);
     QCOMPARE(builder.classInfoCount(), 0);
     QCOMPARE(builder.relatedMetaObjectCount(), 0);
-    QVERIFY(builder.staticMetacallFunction() == 0);
+    QVERIFY(!builder.staticMetacallFunction());
 }
 
 void tst_QMetaObjectBuilder::className()
@@ -174,17 +174,17 @@ void tst_QMetaObjectBuilder::superClass()
 
     // Change the super class.
     builder.setSuperClass(&QObject::staticMetaObject);
-    QVERIFY(builder.superClass() == &QObject::staticMetaObject);
+    QCOMPARE(builder.superClass(), &QObject::staticMetaObject);
 
     // Change it again.
     builder.setSuperClass(&staticMetaObject);
-    QVERIFY(builder.superClass() == &staticMetaObject);
+    QCOMPARE(builder.superClass(), &staticMetaObject);
 
     // Clone the super class off a static QMetaObject.
     builder.addMetaObject(&QObject::staticMetaObject, QMetaObjectBuilder::SuperClass);
-    QVERIFY(builder.superClass() == 0);
+    QVERIFY(!builder.superClass());
     builder.addMetaObject(&staticMetaObject, QMetaObjectBuilder::SuperClass);
-    QVERIFY(builder.superClass() == staticMetaObject.superClass());
+    QCOMPARE(builder.superClass(), staticMetaObject.superClass());
 
     // Check that nothing else changed.
     QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::SuperClass));
@@ -195,11 +195,11 @@ void tst_QMetaObjectBuilder::flags()
     QMetaObjectBuilder builder;
 
     // Check default
-    QVERIFY(builder.flags() == 0);
+    QCOMPARE(builder.flags(), 0);
 
     // Set flags
     builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
-    QVERIFY(builder.flags() == QMetaObjectBuilder::DynamicMetaObject);
+    QCOMPARE(builder.flags(), QMetaObjectBuilder::DynamicMetaObject);
 }
 
 void tst_QMetaObjectBuilder::method()
@@ -209,12 +209,12 @@ void tst_QMetaObjectBuilder::method()
     // Check null method
     QMetaMethodBuilder nullMethod;
     QCOMPARE(nullMethod.signature(), QByteArray());
-    QVERIFY(nullMethod.methodType() == QMetaMethod::Method);
+    QCOMPARE(nullMethod.methodType(), QMetaMethod::Method);
     QVERIFY(nullMethod.returnType().isEmpty());
     QVERIFY(nullMethod.parameterTypes().isEmpty());
     QVERIFY(nullMethod.parameterNames().isEmpty());
     QVERIFY(nullMethod.tag().isEmpty());
-    QVERIFY(nullMethod.access() == QMetaMethod::Public);
+    QCOMPARE(nullMethod.access(), QMetaMethod::Public);
     QCOMPARE(nullMethod.attributes(), 0);
     QCOMPARE(nullMethod.revision(), 0);
     QCOMPARE(nullMethod.index(), 0);
@@ -222,12 +222,12 @@ void tst_QMetaObjectBuilder::method()
     // Add a method and check its attributes.
     QMetaMethodBuilder method1 = builder.addMethod("foo(const QString&, int)");
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(method1.methodType() == QMetaMethod::Method);
+    QCOMPARE(method1.methodType(), QMetaMethod::Method);
     QCOMPARE(method1.returnType(), QByteArray("void"));
     QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(method1.parameterNames().isEmpty());
     QVERIFY(method1.tag().isEmpty());
-    QVERIFY(method1.access() == QMetaMethod::Public);
+    QCOMPARE(method1.access(), QMetaMethod::Public);
     QCOMPARE(method1.attributes(), 0);
     QCOMPARE(method1.revision(), 0);
     QCOMPARE(method1.index(), 0);
@@ -236,12 +236,12 @@ void tst_QMetaObjectBuilder::method()
     // Add another method and check again.
     QMetaMethodBuilder method2 = builder.addMethod("bar(QString)", "int");
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(method2.methodType() == QMetaMethod::Method);
+    QCOMPARE(method2.methodType(), QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("int"));
     QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
-    QVERIFY(method2.access() == QMetaMethod::Public);
+    QCOMPARE(method2.access(), QMetaMethod::Public);
     QCOMPARE(method2.attributes(), 0);
     QCOMPARE(method2.revision(), 0);
     QCOMPARE(method2.index(), 1);
@@ -262,22 +262,22 @@ void tst_QMetaObjectBuilder::method()
 
     // Check that method1 is changed, but method2 is not.
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(method1.methodType() == QMetaMethod::Method);
+    QCOMPARE(method1.methodType(), QMetaMethod::Method);
     QCOMPARE(method1.returnType(), QByteArray("int"));
     QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(method1.tag(), QByteArray("tag"));
-    QVERIFY(method1.access() == QMetaMethod::Private);
+    QCOMPARE(method1.access(), QMetaMethod::Private);
     QCOMPARE(method1.attributes(), 42);
     QCOMPARE(method1.revision(), 123);
     QCOMPARE(method1.index(), 0);
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(method2.methodType() == QMetaMethod::Method);
+    QCOMPARE(method2.methodType(), QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("int"));
     QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
-    QVERIFY(method2.access() == QMetaMethod::Public);
+    QCOMPARE(method2.access(), QMetaMethod::Public);
     QCOMPARE(method2.attributes(), 0);
     QCOMPARE(method2.revision(), 0);
     QCOMPARE(method2.index(), 1);
@@ -293,22 +293,22 @@ void tst_QMetaObjectBuilder::method()
 
     // This time check that only method2 changed.
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(method1.methodType() == QMetaMethod::Method);
+    QCOMPARE(method1.methodType(), QMetaMethod::Method);
     QCOMPARE(method1.returnType(), QByteArray("int"));
     QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(method1.tag(), QByteArray("tag"));
-    QVERIFY(method1.access() == QMetaMethod::Private);
+    QCOMPARE(method1.access(), QMetaMethod::Private);
     QCOMPARE(method1.attributes(), 42);
     QCOMPARE(method1.revision(), 123);
     QCOMPARE(method1.index(), 0);
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(method2.methodType() == QMetaMethod::Method);
+    QCOMPARE(method2.methodType(), QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("QString"));
     QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(method2.tag(), QByteArray("Q_FOO"));
-    QVERIFY(method2.access() == QMetaMethod::Protected);
+    QCOMPARE(method2.access(), QMetaMethod::Protected);
     QCOMPARE(method2.attributes(), 24);
     QCOMPARE(method2.revision(), 321);
     QCOMPARE(method2.index(), 1);
@@ -319,12 +319,12 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(builder.methodCount(), 1);
     method2 = builder.method(0);
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(method2.methodType() == QMetaMethod::Method);
+    QCOMPARE(method2.methodType(), QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("QString"));
     QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(method2.tag(), QByteArray("Q_FOO"));
-    QVERIFY(method2.access() == QMetaMethod::Protected);
+    QCOMPARE(method2.access(), QMetaMethod::Protected);
     QCOMPARE(method2.attributes(), 24);
     QCOMPARE(method2.revision(), 321);
     QCOMPARE(method2.index(), 0);
@@ -347,12 +347,12 @@ void tst_QMetaObjectBuilder::slot()
     // Add a slot and check its attributes.
     QMetaMethodBuilder method1 = builder.addSlot("foo(const QString&, int)");
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(method1.methodType() == QMetaMethod::Slot);
+    QCOMPARE(method1.methodType(), QMetaMethod::Slot);
     QCOMPARE(method1.returnType(), QByteArray("void"));
     QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(method1.parameterNames().isEmpty());
     QVERIFY(method1.tag().isEmpty());
-    QVERIFY(method1.access() == QMetaMethod::Public);
+    QCOMPARE(method1.access(), QMetaMethod::Public);
     QCOMPARE(method1.attributes(), 0);
     QCOMPARE(method1.index(), 0);
     QCOMPARE(builder.methodCount(), 1);
@@ -360,12 +360,12 @@ void tst_QMetaObjectBuilder::slot()
     // Add another slot and check again.
     QMetaMethodBuilder method2 = builder.addSlot("bar(QString)");
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(method2.methodType() == QMetaMethod::Slot);
+    QCOMPARE(method2.methodType(), QMetaMethod::Slot);
     QCOMPARE(method2.returnType(), QByteArray("void"));
     QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
-    QVERIFY(method2.access() == QMetaMethod::Public);
+    QCOMPARE(method2.access(), QMetaMethod::Public);
     QCOMPARE(method2.attributes(), 0);
     QCOMPARE(method2.index(), 1);
     QCOMPARE(builder.methodCount(), 2);
@@ -386,12 +386,12 @@ void tst_QMetaObjectBuilder::signal()
     // Add a signal and check its attributes.
     QMetaMethodBuilder method1 = builder.addSignal("foo(const QString&, int)");
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(method1.methodType() == QMetaMethod::Signal);
+    QCOMPARE(method1.methodType(), QMetaMethod::Signal);
     QCOMPARE(method1.returnType(), QByteArray("void"));
     QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(method1.parameterNames().isEmpty());
     QVERIFY(method1.tag().isEmpty());
-    QVERIFY(method1.access() == QMetaMethod::Public);
+    QCOMPARE(method1.access(), QMetaMethod::Public);
     QCOMPARE(method1.attributes(), 0);
     QCOMPARE(method1.index(), 0);
     QCOMPARE(builder.methodCount(), 1);
@@ -399,12 +399,12 @@ void tst_QMetaObjectBuilder::signal()
     // Add another signal and check again.
     QMetaMethodBuilder method2 = builder.addSignal("bar(QString)");
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(method2.methodType() == QMetaMethod::Signal);
+    QCOMPARE(method2.methodType(), QMetaMethod::Signal);
     QCOMPARE(method2.returnType(), QByteArray("void"));
     QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
-    QVERIFY(method2.access() == QMetaMethod::Public);
+    QCOMPARE(method2.access(), QMetaMethod::Public);
     QCOMPARE(method2.attributes(), 0);
     QCOMPARE(method2.index(), 1);
     QCOMPARE(builder.methodCount(), 2);
@@ -425,12 +425,12 @@ void tst_QMetaObjectBuilder::constructor()
     // Add a constructor and check its attributes.
     QMetaMethodBuilder ctor1 = builder.addConstructor("foo(const QString&, int)");
     QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor1.methodType(), QMetaMethod::Constructor);
     QVERIFY(ctor1.returnType().isEmpty());
     QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(ctor1.parameterNames().isEmpty());
     QVERIFY(ctor1.tag().isEmpty());
-    QVERIFY(ctor1.access() == QMetaMethod::Public);
+    QCOMPARE(ctor1.access(), QMetaMethod::Public);
     QCOMPARE(ctor1.attributes(), 0);
     QCOMPARE(ctor1.index(), 0);
     QCOMPARE(builder.constructorCount(), 1);
@@ -438,12 +438,12 @@ void tst_QMetaObjectBuilder::constructor()
     // Add another constructor and check again.
     QMetaMethodBuilder ctor2 = builder.addConstructor("bar(QString)");
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
     QVERIFY(ctor2.returnType().isEmpty());
     QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(ctor2.parameterNames().isEmpty());
     QVERIFY(ctor2.tag().isEmpty());
-    QVERIFY(ctor2.access() == QMetaMethod::Public);
+    QCOMPARE(ctor2.access(), QMetaMethod::Public);
     QCOMPARE(ctor2.attributes(), 0);
     QCOMPARE(ctor2.index(), 1);
     QCOMPARE(builder.constructorCount(), 2);
@@ -464,21 +464,21 @@ void tst_QMetaObjectBuilder::constructor()
 
     // Check that ctor1 is changed, but ctor2 is not.
     QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor1.methodType(), QMetaMethod::Constructor);
     QCOMPARE(ctor1.returnType(), QByteArray("int"));
     QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(ctor1.tag(), QByteArray("tag"));
-    QVERIFY(ctor1.access() == QMetaMethod::Private);
+    QCOMPARE(ctor1.access(), QMetaMethod::Private);
     QCOMPARE(ctor1.attributes(), 42);
     QCOMPARE(ctor1.index(), 0);
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
     QVERIFY(ctor2.returnType().isEmpty());
     QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(ctor2.parameterNames().isEmpty());
     QVERIFY(ctor2.tag().isEmpty());
-    QVERIFY(ctor2.access() == QMetaMethod::Public);
+    QCOMPARE(ctor2.access(), QMetaMethod::Public);
     QCOMPARE(ctor2.attributes(), 0);
     QCOMPARE(ctor2.index(), 1);
     QCOMPARE(builder.constructorCount(), 2);
@@ -492,21 +492,21 @@ void tst_QMetaObjectBuilder::constructor()
 
     // This time check that only ctor2 changed.
     QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
-    QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor1.methodType(), QMetaMethod::Constructor);
     QCOMPARE(ctor1.returnType(), QByteArray("int"));
     QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(ctor1.tag(), QByteArray("tag"));
-    QVERIFY(ctor1.access() == QMetaMethod::Private);
+    QCOMPARE(ctor1.access(), QMetaMethod::Private);
     QCOMPARE(ctor1.attributes(), 42);
     QCOMPARE(ctor1.index(), 0);
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
     QCOMPARE(ctor2.returnType(), QByteArray("QString"));
     QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));
-    QVERIFY(ctor2.access() == QMetaMethod::Protected);
+    QCOMPARE(ctor2.access(), QMetaMethod::Protected);
     QCOMPARE(ctor2.attributes(), 24);
     QCOMPARE(ctor2.index(), 1);
     QCOMPARE(builder.constructorCount(), 2);
@@ -516,12 +516,12 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(builder.constructorCount(), 1);
     ctor2 = builder.constructor(0);
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
-    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
     QCOMPARE(ctor2.returnType(), QByteArray("QString"));
     QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));
-    QVERIFY(ctor2.access() == QMetaMethod::Protected);
+    QCOMPARE(ctor2.access(), QMetaMethod::Protected);
     QCOMPARE(ctor2.attributes(), 24);
     QCOMPARE(ctor2.index(), 0);
 
@@ -536,10 +536,10 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(builder.constructorCount(), 2);
 
     QCOMPARE(prototypeConstructor.signature(), QByteArray("SomethingOfEverything()"));
-    QVERIFY(prototypeConstructor.methodType() == QMetaMethod::Constructor);
+    QCOMPARE(prototypeConstructor.methodType(), QMetaMethod::Constructor);
     QCOMPARE(prototypeConstructor.returnType(), QByteArray());
     QVERIFY(prototypeConstructor.parameterTypes().isEmpty());
-    QVERIFY(prototypeConstructor.access() == QMetaMethod::Public);
+    QCOMPARE(prototypeConstructor.access(), QMetaMethod::Public);
     QCOMPARE(prototypeConstructor.index(), 1);
 
     // Check that nothing else changed.
@@ -967,13 +967,13 @@ void tst_QMetaObjectBuilder::relatedMetaObject()
     // Add two related meta objects and check their attributes.
     QCOMPARE(builder.addRelatedMetaObject(&QObject::staticMetaObject), 0);
     QCOMPARE(builder.addRelatedMetaObject(&staticMetaObject), 1);
-    QVERIFY(builder.relatedMetaObject(0) == &QObject::staticMetaObject);
-    QVERIFY(builder.relatedMetaObject(1) == &staticMetaObject);
+    QCOMPARE(builder.relatedMetaObject(0), &QObject::staticMetaObject);
+    QCOMPARE(builder.relatedMetaObject(1), &staticMetaObject);
     QCOMPARE(builder.relatedMetaObjectCount(), 2);
 
     // Remove the first one and check again.
     builder.removeRelatedMetaObject(0);
-    QVERIFY(builder.relatedMetaObject(0) == &staticMetaObject);
+    QCOMPARE(builder.relatedMetaObject(0), &staticMetaObject);
     QCOMPARE(builder.relatedMetaObjectCount(), 1);
 
     // Check that nothing else changed.
@@ -1617,7 +1617,7 @@ void tst_QMetaObjectBuilder::usage_slot()
     QVERIFY(index != -1);
     QMetaMethod voidSlotInt = testObject->metaObject()->method(index);
 
-    QVERIFY(testObject->voidSlotIntArgument() == -1);
+    QCOMPARE(testObject->voidSlotIntArgument(), -1);
     QVERIFY(voidSlotInt.invoke(testObject.data(), Q_ARG(int, 123)));
     QCOMPARE(testObject->voidSlotIntArgument(), 123);
 }
@@ -1658,7 +1658,7 @@ void tst_QMetaObjectBuilder::usage_connect()
     QVERIFY(QObject::connect(testObject.data(), SIGNAL(intPropChanged(int)),
                              testObject.data(), SLOT(voidSlotInt(int))));
 
-    QVERIFY(testObject->voidSlotIntArgument() == -1);
+    QCOMPARE(testObject->voidSlotIntArgument(), -1);
     testObject->setProperty("intProp", 123);
     QCOMPARE(testObject->voidSlotIntArgument(), 123);
 
@@ -1674,7 +1674,7 @@ void tst_QMetaObjectBuilder::usage_templateConnect()
                                                    testObject.data(), &TestObject::voidSlotInt);
     QVERIFY(con);
 
-    QVERIFY(testObject->voidSlotIntArgument() == -1);
+    QCOMPARE(testObject->voidSlotIntArgument(), -1);
     testObject->setProperty("intProp", 123);
     QCOMPARE(testObject->voidSlotIntArgument(), 123);
 
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index 9cdb1f47f8..e64a113c10 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -2394,8 +2394,8 @@ void tst_QMetaType::compareCustomEqualOnlyType()
     QVERIFY(variant50 != variant100x);
     QVERIFY(variant100 != variant50);
     QVERIFY(variant100x != variant50);
-    QVERIFY(variant100 == variant100x);
-    QVERIFY(variant100 == variant100);
+    QCOMPARE(variant100, variant100x);
+    QCOMPARE(variant100, variant100);
 
     // compare always fails
     QVERIFY(!(variant50 < variant50));
diff --git a/tests/auto/corelib/kernel/qmimedata/tst_qmimedata.cpp b/tests/auto/corelib/kernel/qmimedata/tst_qmimedata.cpp
index d368d9961b..4f88dc2a76 100644
--- a/tests/auto/corelib/kernel/qmimedata/tst_qmimedata.cpp
+++ b/tests/auto/corelib/kernel/qmimedata/tst_qmimedata.cpp
@@ -101,7 +101,7 @@ void tst_QMimeData::data() const
     // set text, verify
     mimeData.setData("text/plain", "pirates");
     QCOMPARE(mimeData.data("text/plain"), QByteArray("pirates"));
-    QVERIFY(mimeData.data("text/html").length() == 0);
+    QCOMPARE(mimeData.data("text/html").length(), 0);
 
     // html time
     mimeData.setData("text/html", "ninjas");
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index 4617ce5e74..3661db071b 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -2038,57 +2038,57 @@ void tst_QObject::metamethod()
 
     m = mobj->method(mobj->indexOfMethod("invoke1()"));
     QVERIFY(m.methodSignature() == "invoke1()");
-    QVERIFY(m.methodType() == QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
+    QCOMPARE(m.access(), QMetaMethod::Public);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("sinvoke1()"));
     QVERIFY(m.methodSignature() == "sinvoke1()");
-    QVERIFY(m.methodType() == QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
+    QCOMPARE(m.access(), QMetaMethod::Public);
     QVERIFY((m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("invoke2()"));
     QVERIFY(m.methodSignature() == "invoke2()");
-    QVERIFY(m.methodType() == QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Protected);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
+    QCOMPARE(m.access(), QMetaMethod::Protected);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY((m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("sinvoke2()"));
     QVERIFY(m.methodSignature() == "sinvoke2()");
-    QVERIFY(m.methodType() == QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Protected);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
+    QCOMPARE(m.access(), QMetaMethod::Protected);
     QVERIFY((m.attributes() & QMetaMethod::Scriptable));
     QVERIFY((m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("invoke3()"));
     QVERIFY(m.methodSignature() == "invoke3()");
-    QVERIFY(m.methodType() == QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Private);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
+    QCOMPARE(m.access(), QMetaMethod::Private);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("sinvoke3()"));
     QVERIFY(m.methodSignature() == "sinvoke3()");
-    QVERIFY(m.methodType() == QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Private);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
+    QCOMPARE(m.access(), QMetaMethod::Private);
     QVERIFY((m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("signal5()"));
     QVERIFY(m.methodSignature() == "signal5()");
-    QVERIFY(m.methodType() == QMetaMethod::Signal);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    QCOMPARE(m.methodType(), QMetaMethod::Signal);
+    QCOMPARE(m.access(), QMetaMethod::Public);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY((m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("aPublicSlot()"));
     QVERIFY(m.methodSignature() == "aPublicSlot()");
-    QVERIFY(m.methodType() == QMetaMethod::Slot);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    QCOMPARE(m.methodType(), QMetaMethod::Slot);
+    QCOMPARE(m.access(), QMetaMethod::Public);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
@@ -2360,7 +2360,7 @@ void tst_QObject::testUserData()
         int id = user_data_ids[i];
         CustomData *data = static_cast<CustomData *>(my_test_object.userData(id));
         QVERIFY(data != 0);
-        QVERIFY(data->id == id);
+        QCOMPARE(data->id, id);
     }
 }
 
@@ -2902,12 +2902,12 @@ void tst_QObject::floatProperty()
     QVERIFY(idx > 0);
     QMetaProperty prop = obj.metaObject()->property(idx);
     QVERIFY(prop.isValid());
-    QVERIFY(prop.type() == uint(QMetaType::type("float")));
+    QCOMPARE(int(prop.type()), QMetaType::type("float"));
     QVERIFY(!prop.write(&obj, QVariant("Hello")));
     QVERIFY(prop.write(&obj, QVariant::fromValue(128.0f)));
     QVariant v = prop.read(&obj);
-    QVERIFY(int(v.userType()) == QMetaType::Float);
-    QVERIFY(qvariant_cast<float>(v) == 128.0f);
+    QCOMPARE(v.userType(), int(QMetaType::Float));
+    QCOMPARE(qvariant_cast<float>(v), 128.0f);
 }
 
 void tst_QObject::qrealProperty()
@@ -2917,18 +2917,18 @@ void tst_QObject::qrealProperty()
     QVERIFY(idx > 0);
     QMetaProperty prop = obj.metaObject()->property(idx);
     QVERIFY(prop.isValid());
-    QVERIFY(prop.type() == uint(QMetaType::type("qreal")));
+    QCOMPARE(int(prop.type()), QMetaType::type("qreal"));
     QVERIFY(!prop.write(&obj, QVariant("Hello")));
 
     QVERIFY(prop.write(&obj, QVariant::fromValue(128.0f)));
     QVariant v = prop.read(&obj);
     QCOMPARE(v.userType(), qMetaTypeId<qreal>());
-    QVERIFY(qvariant_cast<qreal>(v) == 128.0);
+    QCOMPARE(qvariant_cast<qreal>(v), 128.0);
 
     QVERIFY(prop.write(&obj, QVariant::fromValue(double(127))));
     v = prop.read(&obj);
     QCOMPARE(v.userType(), qMetaTypeId<qreal>());
-    QVERIFY(qvariant_cast<qreal>(v) == 127.0);
+    QCOMPARE(qvariant_cast<qreal>(v), 127.0);
 }
 
 class DynamicPropertyObject : public PropertyObject
@@ -2994,7 +2994,7 @@ void tst_QObject::recursiveSignalEmission()
     proc.start(path);
     QVERIFY2(proc.waitForStarted(), qPrintable(QString::fromLatin1("Cannot start '%1': %2").arg(path, proc.errorString())));
     QVERIFY(proc.waitForFinished());
-    QVERIFY(proc.exitStatus() == QProcess::NormalExit);
+    QCOMPARE(proc.exitStatus(), QProcess::NormalExit);
     QCOMPARE(proc.exitCode(), 0);
 #endif
 }
diff --git a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
index 26bb70fc66..dbac689ebb 100644
--- a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
+++ b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
@@ -145,7 +145,7 @@ void tst_QSharedMemory::init()
 {
     existingSharedMemory = new QSharedMemory(EXISTING_SHARE);
     if (!existingSharedMemory->create(EXISTING_SIZE)) {
-        QVERIFY(existingSharedMemory->error() == QSharedMemory::AlreadyExists);
+        QCOMPARE(existingSharedMemory->error(), QSharedMemory::AlreadyExists);
     }
 }
 
@@ -244,10 +244,10 @@ void tst_QSharedMemory::constructor()
     QSharedMemory sm;
     QCOMPARE(sm.key(), QString());
     QVERIFY(!sm.isAttached());
-    QVERIFY(sm.data() == 0);
+    QVERIFY(!sm.data());
     QCOMPARE(sm.size(), 0);
     QCOMPARE(sm.error(), QSharedMemory::NoError);
-    QVERIFY(sm.errorString() == QString());
+    QCOMPARE(sm.errorString(), QString());
 }
 
 void tst_QSharedMemory::key_data()
@@ -288,8 +288,8 @@ void tst_QSharedMemory::key()
     QCOMPARE(sm.isAttached(), false);
 
     QCOMPARE(sm.error(), QSharedMemory::NoError);
-    QVERIFY(sm.errorString() == QString());
-    QVERIFY(sm.data() == 0);
+    QCOMPARE(sm.errorString(), QString());
+    QVERIFY(!sm.data());
     QCOMPARE(sm.size(), 0);
 
     QCOMPARE(sm.detach(), false);
@@ -328,11 +328,11 @@ void tst_QSharedMemory::create()
         qDebug() << sm.errorString();
     QCOMPARE(sm.key(), key);
     if (canCreate) {
-        QVERIFY(sm.errorString() == QString());
+        QCOMPARE(sm.errorString(), QString());
         QVERIFY(sm.data() != 0);
         QVERIFY(sm.size() != 0);
     } else {
-        QVERIFY(sm.data() == 0);
+        QVERIFY(!sm.data());
         QVERIFY(sm.errorString() != QString());
     }
 }
@@ -377,10 +377,10 @@ void tst_QSharedMemory::attach()
         QVERIFY(sm.size() != 0);
         QVERIFY(sm.detach());
         QCOMPARE(sm.size(), 0);
-        QVERIFY(sm.data() == 0);
+        QVERIFY(!sm.data());
     } else {
-        QVERIFY(sm.data() == 0);
-        QVERIFY(sm.size() == 0);
+        QVERIFY(!sm.data());
+        QCOMPARE(sm.size(), 0);
         QVERIFY(sm.errorString() != QString());
         QVERIFY(!sm.detach());
     }
@@ -498,7 +498,7 @@ void tst_QSharedMemory::useTooMuchMemory()
             QVERIFY(!sm->isAttached());
             QCOMPARE(sm->key(), key);
             QCOMPARE(sm->size(), 0);
-            QVERIFY(sm->data() == 0);
+            QVERIFY(!sm->data());
             if (sm->error() != QSharedMemory::OutOfResources)
                 qDebug() << sm->error() << sm->errorString();
             // ### Linux won't return OutOfResources if there are not enough semaphores to use.
@@ -535,7 +535,7 @@ void tst_QSharedMemory::attachTooMuch()
             QVERIFY(!war->isAttached());
             QCOMPARE(war->key(), government.key());
             QCOMPARE(war->size(), 0);
-            QVERIFY(war->data() == 0);
+            QVERIFY(!war->data());
             QCOMPARE(war->error(), QSharedMemory::OutOfResources);
             QVERIFY(war->errorString() != QString());
             QVERIFY(!war->detach());
diff --git a/tests/auto/corelib/kernel/qsignalmapper/tst_qsignalmapper.cpp b/tests/auto/corelib/kernel/qsignalmapper/tst_qsignalmapper.cpp
index 579aa78ac4..8a5275e032 100644
--- a/tests/auto/corelib/kernel/qsignalmapper/tst_qsignalmapper.cpp
+++ b/tests/auto/corelib/kernel/qsignalmapper/tst_qsignalmapper.cpp
@@ -97,16 +97,16 @@ void tst_QSignalMapper::mapped()
     connect(&mapper, SIGNAL(mapped(QString)), &target, SLOT(myslot(QString)));
 
     src1.emit_mysignal(20);
-    QVERIFY(target.id == 1);
+    QCOMPARE(target.id, 1);
     QVERIFY(target.str.isEmpty());
 
     src2.emit_mysignal(20);
-    QVERIFY(target.id == 2);
-    QVERIFY(target.str == "two");
+    QCOMPARE(target.id, 2);
+    QCOMPARE(target.str, QLatin1String("two"));
 
     src3.emit_mysignal(20);
-    QVERIFY(target.id == 2);
-    QVERIFY(target.str == "three");
+    QCOMPARE(target.id, 2);
+    QCOMPARE(target.str, QLatin1String("three"));
 }
 
 QTEST_MAIN(tst_QSignalMapper)
diff --git a/tests/auto/corelib/kernel/qsocketnotifier/tst_qsocketnotifier.cpp b/tests/auto/corelib/kernel/qsocketnotifier/tst_qsocketnotifier.cpp
index 930a17c3a9..d0eb10d3aa 100644
--- a/tests/auto/corelib/kernel/qsocketnotifier/tst_qsocketnotifier.cpp
+++ b/tests/auto/corelib/kernel/qsocketnotifier/tst_qsocketnotifier.cpp
@@ -129,7 +129,7 @@ void tst_QSocketNotifier::unexpectedDisconnection()
     readEnd1.initialize(QAbstractSocket::TcpSocket);
     readEnd1.connectToHost(server.serverAddress(), server.serverPort());
     QVERIFY(readEnd1.waitForWrite());
-    QVERIFY(readEnd1.state() == QAbstractSocket::ConnectedState);
+    QCOMPARE(readEnd1.state(), QAbstractSocket::ConnectedState);
     QVERIFY(server.waitForNewConnection());
     QTcpSocket *writeEnd1 = server.nextPendingConnection();
     QVERIFY(writeEnd1 != 0);
@@ -138,7 +138,7 @@ void tst_QSocketNotifier::unexpectedDisconnection()
     readEnd2.initialize(QAbstractSocket::TcpSocket);
     readEnd2.connectToHost(server.serverAddress(), server.serverPort());
     QVERIFY(readEnd2.waitForWrite());
-    QVERIFY(readEnd2.state() == QAbstractSocket::ConnectedState);
+    QCOMPARE(readEnd2.state(), QAbstractSocket::ConnectedState);
     QVERIFY(server.waitForNewConnection());
     QTcpSocket *writeEnd2 = server.nextPendingConnection();
     QVERIFY(writeEnd2 != 0);
@@ -164,8 +164,8 @@ void tst_QSocketNotifier::unexpectedDisconnection()
         QVERIFY(timer.isActive()); //escape if test would hang
     }  while(tester.sequence <= 0);
 
-    QVERIFY(readEnd1.state() == QAbstractSocket::ConnectedState);
-    QVERIFY(readEnd2.state() == QAbstractSocket::ConnectedState);
+    QCOMPARE(readEnd1.state(), QAbstractSocket::ConnectedState);
+    QCOMPARE(readEnd2.state(), QAbstractSocket::ConnectedState);
 
     QCOMPARE(tester.sequence, 2);
 
diff --git a/tests/auto/corelib/kernel/qsystemsemaphore/test/tst_qsystemsemaphore.cpp b/tests/auto/corelib/kernel/qsystemsemaphore/test/tst_qsystemsemaphore.cpp
index 169a13aff2..0c0fdb8067 100644
--- a/tests/auto/corelib/kernel/qsystemsemaphore/test/tst_qsystemsemaphore.cpp
+++ b/tests/auto/corelib/kernel/qsystemsemaphore/test/tst_qsystemsemaphore.cpp
@@ -191,13 +191,13 @@ void tst_QSystemSemaphore::basicProcesses()
     acquire.start(m_helperBinary, QStringList("acquire"));
     QVERIFY2(acquire.waitForStarted(), "Could not start helper binary");
     acquire.waitForFinished(HELPERWAITTIME);
-    QVERIFY(acquire.state() == QProcess::Running);
+    QCOMPARE(acquire.state(), QProcess::Running);
     acquire.kill();
     release.start(m_helperBinary, QStringList("release"));
     QVERIFY2(release.waitForStarted(), "Could not start helper binary");
     acquire.waitForFinished(HELPERWAITTIME);
     release.waitForFinished(HELPERWAITTIME);
-    QVERIFY(acquire.state() == QProcess::NotRunning);
+    QCOMPARE(acquire.state(), QProcess::NotRunning);
 #endif
 }
 
diff --git a/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp b/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
index 1dc358bd97..064f780546 100644
--- a/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
+++ b/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
@@ -528,7 +528,7 @@ void tst_QTimer::restartedTimerFiresTooSoon()
 {
     RestartedTimerFiresTooSoonObject object;
     object.timerFired();
-    QVERIFY(object.eventLoop.exec() == 0);
+    QCOMPARE(object.eventLoop.exec(), 0);
 }
 
 class LongLastingSlotClass : public QObject
diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index 6da8f55e61..de53ab1fa3 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -351,13 +351,13 @@ void tst_QVariant::constructor_invalid()
         QTest::ignoreMessage(QtWarningMsg, QRegularExpression("^Trying to construct an instance of an invalid type, type id:"));
         QVariant variant(static_cast<QVariant::Type>(typeId));
         QVERIFY(!variant.isValid());
-        QVERIFY(variant.userType() == QMetaType::UnknownType);
+        QCOMPARE(variant.userType(), int(QMetaType::UnknownType));
     }
     {
         QTest::ignoreMessage(QtWarningMsg, QRegularExpression("^Trying to construct an instance of an invalid type, type id:"));
         QVariant variant(typeId, /* copy */ 0);
         QVERIFY(!variant.isValid());
-        QVERIFY(variant.userType() == QMetaType::UnknownType);
+        QCOMPARE(variant.userType(), int(QMetaType::UnknownType));
     }
 }
 
@@ -901,7 +901,7 @@ void tst_QVariant::toFloat()
     bool ok;
     float d = value.toFloat(&ok);
     QCOMPARE(d, result);
-    QVERIFY(ok == valueOK);
+    QCOMPARE(ok, valueOK);
 }
 
 void tst_QVariant::toLongLong_data()
@@ -1323,9 +1323,9 @@ void tst_QVariant::writeToReadFromDataStream()
                 // the uninitialized float can be NaN (observed on Windows Mobile 5 ARMv4i)
                 float readFloat = qvariant_cast<float>(readVariant);
                 float writtenFloat = qvariant_cast<float>(writeVariant);
-                QVERIFY(qIsNaN(readFloat) == qIsNaN(writtenFloat));
+                QCOMPARE(qIsNaN(readFloat), qIsNaN(writtenFloat));
                 if (!qIsNaN(readFloat))
-                    QVERIFY(readFloat == writtenFloat);
+                    QCOMPARE(readFloat, writtenFloat);
             }
             break;
         }
@@ -2115,7 +2115,7 @@ void tst_QVariant::userType()
             QVERIFY(!userVar.canConvert(QVariant::String));
 
             QVariant userVar2(userVar);
-            QVERIFY(userVar == userVar2);
+            QCOMPARE(userVar, userVar2);
 
             userVar2.setValue(data2);
             QVERIFY(userVar != userVar2);
@@ -2129,7 +2129,7 @@ void tst_QVariant::userType()
             userVar3.setValue(data2);
 
             userVar3 = userVar2;
-            QVERIFY(userVar2 == userVar3);
+            QCOMPARE(userVar2, userVar3);
         }
         // At this point all QVariants got destroyed but we have 2 MyType instances.
         QCOMPARE(instanceCount, 2);
@@ -2144,7 +2144,7 @@ void tst_QVariant::userType()
             QVERIFY(!userVar.canConvert(QVariant::String));
 
             QVariant userVar2(userVar);
-            QVERIFY(userVar == userVar2);
+            QCOMPARE(userVar, userVar2);
 
             userVar2.setValue(&data2);
             QVERIFY(userVar != userVar2);
@@ -2158,10 +2158,10 @@ void tst_QVariant::userType()
 
             /* This check is correct now. userVar2 contains a pointer to data2 and so
              * does userVar3. */
-            QVERIFY(userVar2 == userVar3);
+            QCOMPARE(userVar2, userVar3);
 
             userVar3 = userVar2;
-            QVERIFY(userVar2 == userVar3);
+            QCOMPARE(userVar2, userVar3);
         }
 
         QCOMPARE(instanceCount, 2);
@@ -2446,7 +2446,7 @@ void tst_QVariant::saveLoadCustomTypes()
     qRegisterMetaTypeStreamOperators<Blah>("Blah");
 
     QCOMPARE(v.userType(), tp);
-    QVERIFY(v.type() == QVariant::UserType);
+    QCOMPARE(v.type(), QVariant::UserType);
     {
         QDataStream stream(&data, QIODevice::WriteOnly);
         stream << v;
@@ -2610,7 +2610,7 @@ void tst_QVariant::qvariant_cast_QObject_derived()
     {
         CustomQObjectDerivedNoMetaType *object = new CustomQObjectDerivedNoMetaType(this);
         QVariant data = QVariant::fromValue(object);
-        QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerivedNoMetaType*>());
+        QCOMPARE(data.userType(), qMetaTypeId<CustomQObjectDerivedNoMetaType*>());
         QCOMPARE(data.value<QObject *>(), object);
         QCOMPARE(data.value<CustomQObjectDerivedNoMetaType *>(), object);
         QCOMPARE(data.value<CustomQObject *>(), object);
@@ -2619,7 +2619,7 @@ void tst_QVariant::qvariant_cast_QObject_derived()
         CustomQObjectDerived *object = new CustomQObjectDerived(this);
         QVariant data = QVariant::fromValue(object);
 
-        QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerived*>());
+        QCOMPARE(data.userType(), qMetaTypeId<CustomQObjectDerived*>());
 
         QCOMPARE(data.value<QObject *>(), object);
         QCOMPARE(data.value<CustomQObjectDerived *>(), object);
@@ -2886,10 +2886,10 @@ void tst_QVariant::voidStar() const
     QVariant v1, v2;
     v1 = QVariant::fromValue(p1);
     v2 = v1;
-    QVERIFY(v1 == v2);
+    QCOMPARE(v1, v2);
 
     v2 = QVariant::fromValue(p2);
-    QVERIFY(v1 == v2);
+    QCOMPARE(v1, v2);
 
     p2 = 0;
     v2 = QVariant::fromValue(p2);
@@ -2906,10 +2906,10 @@ void tst_QVariant::dataStar() const
     QCOMPARE(qvariant_cast<Data*>(v1), p1);
 
     QVariant v2 = v1;
-    QVERIFY(v1 == v2);
+    QCOMPARE(v1, v2);
 
     v2 = QVariant::fromValue(p1);
-    QVERIFY(v1 == v2);
+    QCOMPARE(v1, v2);
     delete p1;
 }
 
@@ -3081,8 +3081,8 @@ void tst_QVariant::compareCustomTypes() const
 
     /* We compare pointers. */
     QVERIFY(variant1 != variant2);
-    QVERIFY(variant1 == variant1);
-    QVERIFY(variant2 == variant2);
+    QCOMPARE(variant1, variant1);
+    QCOMPARE(variant2, variant2);
 }
 
 void tst_QVariant::timeToDateTime() const
@@ -3289,7 +3289,7 @@ void tst_QVariant::toIntFromQString() const
 void tst_QVariant::toIntFromDouble() const
 {
     double d = 2147483630;  // max int 2147483647
-    QVERIFY((int)d == 2147483630);
+    QCOMPARE((int)d, 2147483630);
 
     QVariant var(d);
     QVERIFY( var.canConvert( QVariant::Int ) );
@@ -4119,7 +4119,7 @@ void tst_QVariant::saveInvalid()
     QDataStream stream(&data, QIODevice::WriteOnly);
     stream.setVersion(version);
     stream << QVariant();
-    QVERIFY(stream.status() == QDataStream::Ok);
+    QCOMPARE(stream.status(), QDataStream::Ok);
     QVERIFY(data.size() >= 4);
     QCOMPARE(int(data.constData()[0]), 0);
     QCOMPARE(int(data.constData()[1]), 0);
@@ -4133,7 +4133,7 @@ void tst_QVariant::saveNewBuiltinWithOldStream()
     QDataStream stream(&data, QIODevice::WriteOnly);
     stream.setVersion(QDataStream::Qt_3_1);
     stream << QVariant::fromValue<QJsonValue>(123); // QJsonValue class was introduced in Qt5
-    QVERIFY(stream.status() == QDataStream::Ok);
+    QCOMPARE(stream.status(), QDataStream::Ok);
     QVERIFY(data.size() >= 4);
     QCOMPARE(int(data.constData()[0]), 0);
     QCOMPARE(int(data.constData()[1]), 0);