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>

tests/auto/corelib/animation/qparallelanimationgroup/tst_qparallelanimationgroup.cpp

@@ -491,7 +491,7 @@ void tst_QParallelAnimationGroup::deleteChildrenWithRunningGroup()
     QVERIFY(group.currentLoopTime() > 0);
 
     delete anim1;
-    QVERIFY(group.animationCount() == 0);
+    QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.duration(), 0);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
     QCOMPARE(group.currentLoopTime(), 0); //that's the invariant

tests/auto/corelib/animation/qpauseanimation/tst_qpauseanimation.cpp

@@ -114,10 +114,10 @@ void tst_QPauseAnimation::changeDirectionWhileRunning()
     animation.setDuration(400);
     animation.start();
     QTest::qWait(100);
-    QVERIFY(animation.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation.state(), QAbstractAnimation::Running);
     animation.setDirection(QAbstractAnimation::Backward);
     QTest::qWait(animation.totalDuration() + 50);
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
 }
 
 void tst_QPauseAnimation::noTimerUpdates_data()
@@ -149,7 +149,7 @@ void tst_QPauseAnimation::noTimerUpdates()
         QEXPECT_FAIL("", timerError, Abort);
 #endif
 
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
     const int expectedLoopCount = 1 + loopCount;
 
 #ifdef BAD_TIMER_RESOLUTION
@@ -177,13 +177,13 @@ void tst_QPauseAnimation::multiplePauseAnimations()
     if (animation.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (animation2.state() != QAbstractAnimation::Running)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(animation2.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation2.state(), QAbstractAnimation::Running);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (animation.m_updateCurrentTimeCount != 2)
@@ -203,7 +203,7 @@ void tst_QPauseAnimation::multiplePauseAnimations()
     if (animation2.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation2.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (animation2.m_updateCurrentTimeCount != 3)
@@ -230,8 +230,8 @@ void tst_QPauseAnimation::pauseAndPropertyAnimations()
     QTest::qWait(100);
     animation.start();
 
-    QVERIFY(animation.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation.state(), QAbstractAnimation::Running);
-    QVERIFY(pause.state() == QAbstractAnimation::Running);
+    QCOMPARE(pause.state(), QAbstractAnimation::Running);
     QCOMPARE(pause.m_updateCurrentTimeCount, 2);
 
     QTest::qWait(animation.totalDuration() + 100);
@@ -240,8 +240,8 @@ void tst_QPauseAnimation::pauseAndPropertyAnimations()
     if (animation.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
-    QVERIFY(pause.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(pause.state(), QAbstractAnimation::Stopped);
     QVERIFY(pause.m_updateCurrentTimeCount > 3);
 }
 
@@ -250,10 +250,10 @@ void tst_QPauseAnimation::pauseResume()
     TestablePauseAnimation animation;
     animation.setDuration(400);
     animation.start();
-    QVERIFY(animation.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation.state(), QAbstractAnimation::Running);
     QTest::qWait(200);
     animation.pause();
-    QVERIFY(animation.state() == QAbstractAnimation::Paused);
+    QCOMPARE(animation.state(), QAbstractAnimation::Paused);
     animation.start();
     QTRY_COMPARE(animation.state(), QAbstractAnimation::Stopped);
 
@@ -281,39 +281,39 @@ void tst_QPauseAnimation::sequentialPauseGroup()
     QCOMPARE(animation2.m_updateCurrentTimeCount, 0);
     QCOMPARE(animation3.m_updateCurrentTimeCount, 0);
 
-    QVERIFY(group.state() == QAbstractAnimation::Running);
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
-    QVERIFY(animation1.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation1.state(), QAbstractAnimation::Running);
-    QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation2.state(), QAbstractAnimation::Stopped);
-    QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation3.state(), QAbstractAnimation::Stopped);
 
     group.setCurrentTime(250);
     QCOMPARE(animation1.m_updateCurrentTimeCount, 2);
     QCOMPARE(animation2.m_updateCurrentTimeCount, 1);
     QCOMPARE(animation3.m_updateCurrentTimeCount, 0);
 
-    QVERIFY(group.state() == QAbstractAnimation::Running);
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
-    QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation1.state(), QAbstractAnimation::Stopped);
     QCOMPARE((QAbstractAnimation*)&animation2, group.currentAnimation());
-    QVERIFY(animation2.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation2.state(), QAbstractAnimation::Running);
-    QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation3.state(), QAbstractAnimation::Stopped);
 
     group.setCurrentTime(500);
     QCOMPARE(animation1.m_updateCurrentTimeCount, 2);
     QCOMPARE(animation2.m_updateCurrentTimeCount, 2);
     QCOMPARE(animation3.m_updateCurrentTimeCount, 1);
 
-    QVERIFY(group.state() == QAbstractAnimation::Running);
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
-    QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation1.state(), QAbstractAnimation::Stopped);
-    QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation2.state(), QAbstractAnimation::Stopped);
     QCOMPARE((QAbstractAnimation*)&animation3, group.currentAnimation());
-    QVERIFY(animation3.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation3.state(), QAbstractAnimation::Running);
 
     group.setCurrentTime(750);
 
-    QVERIFY(group.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(group.state(), QAbstractAnimation::Stopped);
-    QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation1.state(), QAbstractAnimation::Stopped);
-    QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation2.state(), QAbstractAnimation::Stopped);
-    QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation3.state(), QAbstractAnimation::Stopped);
 
     QCOMPARE(animation1.m_updateCurrentTimeCount, 2);
     QCOMPARE(animation2.m_updateCurrentTimeCount, 2);
@@ -334,22 +334,22 @@ void tst_QPauseAnimation::sequentialGroupWithPause()
 
     group.start();
 
-    QVERIFY(group.state() == QAbstractAnimation::Running);
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
-    QVERIFY(animation.state() == QAbstractAnimation::Running);
+    QCOMPARE(animation.state(), QAbstractAnimation::Running);
-    QVERIFY(pause.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(pause.state(), QAbstractAnimation::Stopped);
 
     group.setCurrentTime(300);
 
-    QVERIFY(group.state() == QAbstractAnimation::Running);
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
     QCOMPARE((QAbstractAnimation*)&pause, group.currentAnimation());
-    QVERIFY(pause.state() == QAbstractAnimation::Running);
+    QCOMPARE(pause.state(), QAbstractAnimation::Running);
 
     group.setCurrentTime(600);
 
-    QVERIFY(group.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(group.state(), QAbstractAnimation::Stopped);
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
-    QVERIFY(pause.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(pause.state(), QAbstractAnimation::Stopped);
 
     QCOMPARE(pause.m_updateCurrentTimeCount, 2);
 }
@@ -401,11 +401,11 @@ void tst_QPauseAnimation::multipleSequentialGroups()
 
     group.start();
 
-    QVERIFY(group.state() == QAbstractAnimation::Running);
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
-    QVERIFY(subgroup1.state() == QAbstractAnimation::Running);
+    QCOMPARE(subgroup1.state(), QAbstractAnimation::Running);
-    QVERIFY(subgroup2.state() == QAbstractAnimation::Running);
+    QCOMPARE(subgroup2.state(), QAbstractAnimation::Running);
-    QVERIFY(subgroup3.state() == QAbstractAnimation::Running);
+    QCOMPARE(subgroup3.state(), QAbstractAnimation::Running);
-    QVERIFY(subgroup4.state() == QAbstractAnimation::Running);
+    QCOMPARE(subgroup4.state(), QAbstractAnimation::Running);
 
     // This is a pretty long animation so it tends to get rather out of sync
     // when using the consistent timer, so run for an extra half second for good
@@ -416,31 +416,31 @@ void tst_QPauseAnimation::multipleSequentialGroups()
     if (group.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(group.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(group.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (subgroup1.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(subgroup1.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(subgroup1.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (subgroup2.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(subgroup2.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(subgroup2.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (subgroup3.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(subgroup3.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(subgroup3.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (subgroup4.state() != QAbstractAnimation::Stopped)
         QEXPECT_FAIL("", timerError, Abort);
 #endif
-    QVERIFY(subgroup4.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(subgroup4.state(), QAbstractAnimation::Stopped);
 
 #ifdef BAD_TIMER_RESOLUTION
     if (pause5.m_updateCurrentTimeCount != 4)
@@ -455,7 +455,7 @@ void tst_QPauseAnimation::zeroDuration()
     animation.setDuration(0);
     animation.start();
     QTest::qWait(animation.totalDuration() + 100);
-    QVERIFY(animation.state() == QAbstractAnimation::Stopped);
+    QCOMPARE(animation.state(), QAbstractAnimation::Stopped);
     QCOMPARE(animation.m_updateCurrentTimeCount, 1);
 }
 

tests/auto/corelib/animation/qpropertyanimation/tst_qpropertyanimation.cpp

@@ -369,7 +369,7 @@ void tst_QPropertyAnimation::deletion2()
     QTimer::singleShot(0, object, SLOT(deleteLater()));
     QTest::qWait(50);
 
-    QVERIFY(anim->targetObject() == 0);
+    QVERIFY(!anim->targetObject());
 }
 
 void tst_QPropertyAnimation::deletion3()

tests/auto/corelib/animation/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp

@@ -916,7 +916,7 @@ void tst_QSequentialAnimationGroup::startDelay()
     QTest::qWait(500);
 
     QTRY_COMPARE(group.state(), QAnimationGroup::Stopped);
-    QVERIFY(group.currentLoopTime() == 375);
+    QCOMPARE(group.currentLoopTime(), 375);
 }
 
 void tst_QSequentialAnimationGroup::clearGroup()
@@ -1518,7 +1518,7 @@ void tst_QSequentialAnimationGroup::addRemoveAnimation()
 void tst_QSequentialAnimationGroup::currentAnimation()
 {
     QSequentialAnimationGroup group;
-    QVERIFY(group.currentAnimation() == 0);
+    QVERIFY(!group.currentAnimation());
 
     QPropertyAnimation anim;
     anim.setDuration(0);
@@ -1529,7 +1529,7 @@ void tst_QSequentialAnimationGroup::currentAnimation()
 void tst_QSequentialAnimationGroup::currentAnimationWithZeroDuration()
 {
     QSequentialAnimationGroup group;
-    QVERIFY(group.currentAnimation() == 0);
+    QVERIFY(!group.currentAnimation());
 
     QPropertyAnimation zero1;
     zero1.setDuration(0);

tests/auto/corelib/animation/qvariantanimation/tst_qvariantanimation.cpp

@@ -77,9 +77,9 @@ void tst_QVariantAnimation::currentValue()
 void tst_QVariantAnimation::easingCurve()
 {
     TestableQVariantAnimation anim;
-    QVERIFY(anim.easingCurve() == QEasingCurve::Linear);
+    QCOMPARE(anim.easingCurve().type(), QEasingCurve::Linear);
     anim.setEasingCurve(QEasingCurve::InQuad);
-    QVERIFY(anim.easingCurve() == QEasingCurve::InQuad);
+    QCOMPARE(anim.easingCurve().type(), QEasingCurve::InQuad);
 }
 
 void tst_QVariantAnimation::endValue()

tests/auto/corelib/codecs/qtextcodec/tst_qtextcodec.cpp

@@ -156,7 +156,7 @@ void tst_QTextCodec::codecForName()
 
     QTextCodec *codec = QTextCodec::codecForName(hint.toLatin1());
     if (actualCodecName.isEmpty()) {
-        QVERIFY(codec == 0);
+        QVERIFY(!codec);
     } else {
         QVERIFY(codec != 0);
         QCOMPARE(QString(codec->name()), actualCodecName);
@@ -2075,7 +2075,7 @@ void tst_QTextCodec::codecForUtfText()
     if (detected)
         QCOMPARE(codec->mibEnum(), mib);
     else
-        QVERIFY(codec == 0);
+        QVERIFY(!codec);
 }
 
 #if defined(Q_OS_UNIX)

tests/auto/corelib/global/qgetputenv/tst_qgetputenv.cpp

@@ -80,7 +80,7 @@ void tst_QGetPutEnv::getSetCheck()
     QCOMPARE(qEnvironmentVariableIntValue(varName, &ok), 0);
     QVERIFY(!ok);
     result = qgetenv(varName);
-    QVERIFY(result == "supervalue");
+    QCOMPARE(result, QByteArrayLiteral("supervalue"));
 
     qputenv(varName,QByteArray());
 

tests/auto/corelib/io/qbuffer/tst_qbuffer.cpp

@@ -378,7 +378,7 @@ void tst_QBuffer::read_rawdata()
     for (int i = 0; i < (int)sizeof(mydata); ++i) {
         QVERIFY(!buffer.atEnd());
         in >> ch;
-        QVERIFY(ch == (quint8)mydata[i]);
+        QCOMPARE(ch, (quint8)mydata[i]);
     }
     QVERIFY(buffer.atEnd());
 }

tests/auto/corelib/io/qdatastream/tst_qdatastream.cpp

@@ -527,7 +527,7 @@ void tst_QDataStream::readQRegExp(QDataStream *s)
     *s >> R;
     QCOMPARE(R, test);
     *s >> V;
-    QVERIFY(V.type() == QVariant::RegExp);
+    QCOMPARE(V.type(), QVariant::RegExp);
     QCOMPARE(V.toRegExp(), test);
 }
 
@@ -795,7 +795,7 @@ void tst_QDataStream::readbool(QDataStream *s)
 
     bool d1;
     *s >> d1;
-    QVERIFY(d1 == expected);
+    QCOMPARE(d1, expected);
 }
 
 // ************************************
@@ -858,7 +858,7 @@ void tst_QDataStream::readQBitArray(QDataStream *s)
 
     QBitArray d1;
     *s >> d1;
-    QVERIFY(d1 == expected);
+    QCOMPARE(d1, expected);
 }
 
 // ************************************
@@ -917,7 +917,7 @@ void tst_QDataStream::readQBrush(QDataStream *s)
     *s >> d2;
 
     QBrush brush = qBrushData(dataIndex(QTest::currentDataTag()));
-    QVERIFY(d2 == brush);
+    QCOMPARE(d2, brush);
 }
 
 // ************************************
@@ -959,7 +959,7 @@ void tst_QDataStream::readQColor(QDataStream *s)
     QColor test(QColorData(dataIndex(QTest::currentDataTag())));
     QColor d3;
     *s >> d3;
-    QVERIFY(d3 == test);
+    QCOMPARE(d3, test);
 }
 
 
@@ -1055,7 +1055,7 @@ void tst_QDataStream::readQCursor(QDataStream *s)
     *s >> d5;
 
     QVERIFY(d5.shape() == test.shape()); //## lacks operator==
-    QVERIFY(d5.hotSpot() == test.hotSpot());
+    QCOMPARE(d5.hotSpot(), test.hotSpot());
     QVERIFY((d5.bitmap() != 0 && test.bitmap() != 0) || (d5.bitmap() == 0 && test.bitmap() == 0));
     if (d5.bitmap() != 0) {
         QPixmap actual = *(d5.bitmap());
@@ -1118,7 +1118,7 @@ void tst_QDataStream::readQDate(QDataStream *s)
     QDate test(qDateData(dataIndex(QTest::currentDataTag())));
     QDate d6;
     *s >> d6;
-    QVERIFY(d6 == test);
+    QCOMPARE(d6, test);
 }
 
 // ************************************
@@ -1212,7 +1212,7 @@ void tst_QDataStream::readQTime(QDataStream *s)
     QTime test = qTimeData(dataIndex(QTest::currentDataTag()));
     QTime d7;
     *s >> d7;
-    QVERIFY(d7 == test);
+    QCOMPARE(d7, test);
 }
 
 // ************************************
@@ -1262,7 +1262,7 @@ void tst_QDataStream::readQDateTime(QDataStream *s)
     QDateTime test(qDateTimeData(dataIndex(QTest::currentDataTag())));
     QDateTime d8;
     *s >> d8;
-    QVERIFY(d8 == test);
+    QCOMPARE(d8, test);
 }
 
 // ************************************
@@ -1413,16 +1413,16 @@ void tst_QDataStream::readQImage(QDataStream *s)
 
     QImage d12;
     *s >> d12;
-    QVERIFY(d12 == ref);
+    QCOMPARE(d12, ref);
 
     // do some extra neurotic tests
-    QVERIFY(d12.size() == ref.size());
+    QCOMPARE(d12.size(), ref.size());
-    QVERIFY(d12.isNull() == ref.isNull());
+    QCOMPARE(d12.isNull(), ref.isNull());
-    QVERIFY(d12.width() == ref.width());
+    QCOMPARE(d12.width(), ref.width());
-    QVERIFY(d12.height() == ref.height());
+    QCOMPARE(d12.height(), ref.height());
-    QVERIFY(d12.depth() == ref.depth());
+    QCOMPARE(d12.depth(), ref.depth());
-    QVERIFY(d12.colorCount() == ref.colorCount());
+    QCOMPARE(d12.colorCount(), ref.colorCount());
-    QVERIFY(d12.hasAlphaChannel() == ref.hasAlphaChannel());
+    QCOMPARE(d12.hasAlphaChannel(), ref.hasAlphaChannel());
 }
 
 // ************************************
@@ -1516,9 +1516,9 @@ void tst_QDataStream::readQPen(QDataStream *s)
     QCOMPARE(d15.style(), origPen.style());
     QCOMPARE(d15.width(), origPen.width());
     QCOMPARE(d15.color(), origPen.color());
-    QVERIFY(d15.capStyle() == origPen.capStyle());
+    QCOMPARE(d15.capStyle(), origPen.capStyle());
-    QVERIFY(d15.joinStyle() == origPen.joinStyle());
+    QCOMPARE(d15.joinStyle(), origPen.joinStyle());
-    QVERIFY(d15 == origPen);
+    QCOMPARE(d15, origPen);
 }
 
 // ************************************
@@ -1566,11 +1566,11 @@ void tst_QDataStream::readQPixmap(QDataStream *s)
     QPixmap d16;
     *s >> d16;
     QVERIFY(!d16.isNull() && !pm.isNull());
-    QVERIFY(d16.width() == pm.width());
+    QCOMPARE(d16.width(), pm.width());
-    QVERIFY(d16.height() == pm.height());
+    QCOMPARE(d16.height(), pm.height());
-    QVERIFY(d16.size() == pm.size());
+    QCOMPARE(d16.size(), pm.size());
-    QVERIFY(d16.rect() == pm.rect());
+    QCOMPARE(d16.rect(), pm.rect());
-    QVERIFY(d16.depth() == pm.depth());
+    QCOMPARE(d16.depth(), pm.depth());
 }
 
 void tst_QDataStream::writeQIcon(QDataStream *s)
@@ -1637,11 +1637,11 @@ void tst_QDataStream::readQPoint(QDataStream *s)
     QPoint ref(qPointData(dataIndex(QTest::currentDataTag())));
     QPoint d17;
     *s >> d17;
-    QVERIFY(d17 == ref);
+    QCOMPARE(d17, ref);
 
     QPointF d17f;
     *s >> d17f;
-    QVERIFY(d17f == QPointF(ref));
+    QCOMPARE(d17f, QPointF(ref));
 }
 
 // ************************************
@@ -1689,11 +1689,11 @@ void tst_QDataStream::readQRect(QDataStream *s)
     QRect ref(qRectData(dataIndex(QTest::currentDataTag())));
     QRect d18;
     *s >> d18;
-    QVERIFY(d18 == ref);
+    QCOMPARE(d18, ref);
 
     QRectF d18f;
     *s >> d18f;
-    QVERIFY(d18f == QRectF(ref));
+    QCOMPARE(d18f, QRectF(ref));
 }
 
 // ************************************
@@ -1802,11 +1802,11 @@ void tst_QDataStream::readQPolygon(QDataStream *s)
     QPolygon ref(qPolygonData(dataIndex(QTest::currentDataTag())));
     QPolygon d19;
     *s >> d19;
-    QVERIFY(d19 == ref);
+    QCOMPARE(d19, ref);
 
     QPolygonF d19f;
     *s >> d19f;
-    QVERIFY(d19f == QPolygonF(ref));
+    QCOMPARE(d19f, QPolygonF(ref));
 }
 
 // ************************************
@@ -1866,7 +1866,7 @@ void tst_QDataStream::readQRegion(QDataStream *s)
     QRegion ref(qRegionData(dataIndex(QTest::currentDataTag())));
     QRegion r;
     *s >> r;
-    QVERIFY(r == ref);
+    QCOMPARE(r, ref);
 }
 
 // ************************************
@@ -1914,11 +1914,11 @@ void tst_QDataStream::readQSize(QDataStream *s)
     QSize ref(qSizeData(dataIndex(QTest::currentDataTag())));
     QSize d21;
     *s >> d21;
-    QVERIFY(d21 == ref);
+    QCOMPARE(d21, ref);
 
     QSizeF d21f;
     *s >> d21f;
-    QVERIFY(d21f == QSizeF(ref));
+    QCOMPARE(d21f, QSizeF(ref));
 }
 
 // *********************** atEnd ******************************
@@ -2094,13 +2094,13 @@ void tst_QDataStream::setVersion()
         QDataStream in(&ba1, QIODevice::ReadOnly);
         in.setVersion(vers);
         in >> keyseq1 >> keyseq2 >> deadbeef;
-        QVERIFY(keyseq1 == QKeySequence(Qt::Key_A));
+        QCOMPARE(keyseq1, QKeySequence(Qt::Key_A));
         if (vers >= 5) {
             QVERIFY(keyseq2 == QKeySequence(Qt::Key_B, Qt::Key_C));
         } else {
-            QVERIFY(keyseq2 == QKeySequence(Qt::Key_B));
+            QCOMPARE(keyseq2, QKeySequence(Qt::Key_B));
         }
-        QVERIFY(deadbeef == 0xDEADBEEF);
+        QCOMPARE(deadbeef, 0xDEADBEEF);
     }
 
     /*
@@ -2109,7 +2109,7 @@ void tst_QDataStream::setVersion()
 
     // revise the test if new color roles or color groups are added
     QVERIFY(QPalette::NColorRoles == QPalette::ToolTipText + 1);
-    QVERIFY(QPalette::NColorGroups == 3);
+    QCOMPARE(int(QPalette::NColorGroups), 3);
 
     QByteArray ba2;
     QPalette pal1, pal2;
@@ -2174,8 +2174,8 @@ void tst_QDataStream::setVersion()
                     }
                 }
             }
-            QVERIFY(pal1 == inPal1);
+            QCOMPARE(pal1, inPal1);
-            QVERIFY(pal2 == inPal2);
+            QCOMPARE(pal2, inPal2);
         }
     }
 }
@@ -3060,9 +3060,9 @@ void tst_QDataStream::compatibility_Qt3()
             in >> in_palette;
             in >> in_brush;
         }
-        QVERIFY(in_brush.style() == Qt::NoBrush);
+        QCOMPARE(in_brush.style(), Qt::NoBrush);
-        QVERIFY(in_palette.brush(QPalette::Button).style() == Qt::NoBrush);
+        QCOMPARE(in_palette.brush(QPalette::Button).style(), Qt::NoBrush);
-        QVERIFY(in_palette.color(QPalette::Light) == Qt::green);
+        QCOMPARE(in_palette.color(QPalette::Light), QColor(Qt::green));
     }
 }
 
@@ -3092,9 +3092,9 @@ void tst_QDataStream::compatibility_Qt2()
         in >> in_palette;
         in >> in_brush;
     }
-    QVERIFY(in_brush.style() == Qt::NoBrush);
+    QCOMPARE(in_brush.style(), Qt::NoBrush);
-    QVERIFY(in_palette.brush(QPalette::Button).style() == Qt::NoBrush);
+    QCOMPARE(in_palette.brush(QPalette::Button).style(), Qt::NoBrush);
-    QVERIFY(in_palette.color(QPalette::Light) == Qt::green);
+    QCOMPARE(in_palette.color(QPalette::Light), QColor(Qt::green));
 }
 
 void tst_QDataStream::floatingPointNaN()

tests/auto/corelib/io/qdir/tst_qdir.cpp

@@ -611,7 +611,7 @@ void tst_QDir::compare()
     dir.makeAbsolute();
     QVERIFY(dir == QDir::currentPath());
 
-    QVERIFY(QDir() == QDir(QDir::currentPath()));
+    QCOMPARE(QDir(), QDir(QDir::currentPath()));
     QVERIFY(QDir("../") == QDir(QDir::currentPath() + "/.."));
 }
 
@@ -1041,7 +1041,7 @@ void tst_QDir::current()
     if (!path.isEmpty()) {
         bool b = QDir::setCurrent(path);
         // If path is non existent, then setCurrent should be false (currentDir is empty in testData)
-        QVERIFY(b == !currentDir.isEmpty());
+        QCOMPARE(b, !currentDir.isEmpty());
     }
     if (!currentDir.isEmpty()) {
         QDir newCurrent = QDir::current();
@@ -1678,7 +1678,7 @@ void tst_QDir::searchPaths()
         QDir::setSearchPaths(searchPathPrefixList.at(i), searchPathsList.at(i).split(","));
     }
     for (int i = 0; i < searchPathPrefixList.count(); ++i) {
-        QVERIFY(QDir::searchPaths(searchPathPrefixList.at(i)) == searchPathsList.at(i).split(","));
+        QCOMPARE(QDir::searchPaths(searchPathPrefixList.at(i)), searchPathsList.at(i).split(","));
     }
 
     QCOMPARE(QFile(filename).exists(), exists);
@@ -1701,7 +1701,7 @@ void tst_QDir::searchPaths()
         }
     }
     for (int i = 0; i < searchPathPrefixList.count(); ++i) {
-        QVERIFY(QDir::searchPaths(searchPathPrefixList.at(i)) == searchPathsList.at(i).split(","));
+        QCOMPARE(QDir::searchPaths(searchPathPrefixList.at(i)), searchPathsList.at(i).split(","));
     }
 
     QCOMPARE(QFile(filename).exists(), exists);

tests/auto/corelib/io/qdiriterator/tst_qdiriterator.cpp

@@ -538,7 +538,7 @@ void tst_QDirIterator::recurseWithFilters() const
     QVERIFY(it.hasNext());
     it.next();
     actualEntries.insert(it.fileInfo().filePath());
-    QVERIFY(actualEntries == expectedEntries);
+    QCOMPARE(actualEntries, expectedEntries);
 
     QVERIFY(!it.hasNext());
 }

tests/auto/corelib/io/qfile/tst_qfile.cpp

@@ -823,7 +823,7 @@ void tst_QFile::readAll()
 
     QByteArray a = file.readAll();
     file.reset();
-    QVERIFY(file.pos() == 0);
+    QCOMPARE(file.pos(), 0);
 
     QVERIFY(file.bytesAvailable() > 7);
     QByteArray b = file.read(1);
@@ -1145,7 +1145,7 @@ void tst_QFile::append()
     f.close();
 
     QVERIFY(f.open(QIODevice::Append));
-    QVERIFY(f.pos() == 1);
+    QCOMPARE(f.pos(), 1);
     f.putChar('a');
     f.close();
     QCOMPARE(int(f.size()), 2);
@@ -2171,7 +2171,7 @@ void tst_QFile::removeOpenFile()
         QVERIFY(removed);
         QVERIFY(!f.isOpen());
         QVERIFY(!f.exists());
-        QVERIFY(f.error() == QFile::NoError);
+        QCOMPARE(f.error(), QFile::NoError);
     }
 
     {
@@ -2198,7 +2198,7 @@ void tst_QFile::removeOpenFile()
         QVERIFY(removed);
         QVERIFY(!f.isOpen());
         QVERIFY(!f.exists());
-        QVERIFY(f.error() == QFile::NoError);
+        QCOMPARE(f.error(), QFile::NoError);
     }
 }
 
@@ -2765,13 +2765,13 @@ void tst_QFile::readEof()
         char buf[10];
         int ret = file.read(buf, sizeof buf);
         QCOMPARE(ret, 0);
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
 
         // Do it again to ensure that we get the same result
         ret = file.read(buf, sizeof buf);
         QCOMPARE(ret, 0);
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
     }
 
@@ -2786,13 +2786,13 @@ void tst_QFile::readEof()
 
         QByteArray ret = file.read(10);
         QVERIFY(ret.isEmpty());
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
 
         // Do it again to ensure that we get the same result
         ret = file.read(10);
         QVERIFY(ret.isEmpty());
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
     }
 
@@ -2808,13 +2808,13 @@ void tst_QFile::readEof()
         char buf[10];
         int ret = file.readLine(buf, sizeof buf);
         QCOMPARE(ret, -1);
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
 
         // Do it again to ensure that we get the same result
         ret = file.readLine(buf, sizeof buf);
         QCOMPARE(ret, -1);
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
     }
 
@@ -2829,13 +2829,13 @@ void tst_QFile::readEof()
 
         QByteArray ret = file.readLine();
         QVERIFY(ret.isNull());
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
 
         // Do it again to ensure that we get the same result
         ret = file.readLine();
         QVERIFY(ret.isNull());
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
     }
 
@@ -2850,12 +2850,12 @@ void tst_QFile::readEof()
 
         char c;
         QVERIFY(!file.getChar(&c));
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
 
         // Do it again to ensure that we get the same result
         QVERIFY(!file.getChar(&c));
-        QVERIFY(file.error() == QFile::NoError);
+        QCOMPARE(file.error(), QFile::NoError);
         QVERIFY(file.atEnd());
     }
 }
@@ -2943,7 +2943,7 @@ void tst_QFile::map()
     memory = file.map(offset, size);
     QCOMPARE(file.error(), QFile::NoError);
     QVERIFY(memory);
-    QVERIFY(memory[0] == 'Q');
+    QCOMPARE(memory[0], uchar('Q'));
     QVERIFY(file.unmap(memory));
     QCOMPARE(file.error(), QFile::NoError);
 

tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp

@@ -1397,7 +1397,7 @@ void tst_QFileInfo::refresh()
 
     QCOMPARE(file.write("JOJOJO"), qint64(6));
     file.flush();
-    QVERIFY(info.lastModified() == lastModified);
+    QCOMPARE(info.lastModified(), lastModified);
 
     QCOMPARE(info.size(), qint64(7));
 #if defined(Q_OS_WIN) || defined(Q_OS_WINCE)

tests/auto/corelib/io/qprocess/tst_qprocess.cpp

@@ -851,11 +851,11 @@ void tst_QProcess::openModes()
 {
     QProcess proc;
     QVERIFY(!proc.isOpen());
-    QVERIFY(proc.openMode() == QProcess::NotOpen);
+    QCOMPARE(proc.openMode(), QProcess::NotOpen);
     proc.start("testProcessEcho3/testProcessEcho3");
     QVERIFY(proc.waitForStarted(5000));
     QVERIFY(proc.isOpen());
-    QVERIFY(proc.openMode() == QProcess::ReadWrite);
+    QCOMPARE(proc.openMode(), QProcess::ReadWrite);
     QVERIFY(proc.isReadable());
     QVERIFY(proc.isWritable());
 
@@ -864,7 +864,7 @@ void tst_QProcess::openModes()
     proc.closeWriteChannel();
 
     QVERIFY(proc.isWritable());
-    QVERIFY(proc.openMode() == QProcess::ReadWrite);
+    QCOMPARE(proc.openMode(), QProcess::ReadWrite);
 
     while (proc.bytesAvailable() < 4 && proc.waitForReadyRead(5000))
     { }
@@ -873,12 +873,12 @@ void tst_QProcess::openModes()
 
     proc.closeReadChannel(QProcess::StandardOutput);
 
-    QVERIFY(proc.openMode() == QProcess::ReadWrite);
+    QCOMPARE(proc.openMode(), QProcess::ReadWrite);
     QVERIFY(proc.isReadable());
 
     proc.closeReadChannel(QProcess::StandardError);
 
-    QVERIFY(proc.openMode() == QProcess::ReadWrite);
+    QCOMPARE(proc.openMode(), QProcess::ReadWrite);
     QVERIFY(proc.isReadable());
 
     proc.close();

tests/auto/corelib/io/qprocessenvironment/tst_qprocessenvironment.cpp

@@ -57,25 +57,25 @@ private slots:
 void tst_QProcessEnvironment::operator_eq()
 {
     QProcessEnvironment e1;
-    QVERIFY(e1 == e1);
+    QCOMPARE(e1, e1);
     e1.clear();
-    QVERIFY(e1 == e1);
+    QCOMPARE(e1, e1);
 
     e1 = QProcessEnvironment();
     QProcessEnvironment e2;
-    QVERIFY(e1 == e2);
+    QCOMPARE(e1, e2);
 
     e1.clear();
-    QVERIFY(e1 == e2);
+    QCOMPARE(e1, e2);
 
     e2.clear();
-    QVERIFY(e1 == e2);
+    QCOMPARE(e1, e2);
 
     e1.insert("FOO", "bar");
     QVERIFY(e1 != e2);
 
     e2.insert("FOO", "bar");
-    QVERIFY(e1 == e2);
+    QCOMPARE(e1, e2);
 
     e2.insert("FOO", "baz");
     QVERIFY(e1 != e2);
@@ -212,7 +212,7 @@ void tst_QProcessEnvironment::insertEnv()
 
     e3.insert(e3); // mustn't deadlock
 
-    QVERIFY(e3 == e2);
+    QCOMPARE(e3, e2);
 }
 
 void tst_QProcessEnvironment::caseSensitivity()

tests/auto/corelib/io/qsettings/tst_qsettings.cpp

@@ -291,8 +291,8 @@ void tst_QSettings::initTestCase()
                                                           , Qt::CaseInsensitive
 #endif
                                                           );
-    QVERIFY(custom1 == QSettings::CustomFormat1);
+    QCOMPARE(custom1, QSettings::CustomFormat1);
-    QVERIFY(custom2 == QSettings::CustomFormat2);
+    QCOMPARE(custom2, QSettings::CustomFormat2);
 }
 
 void tst_QSettings::init()
@@ -391,27 +391,27 @@ void tst_QSettings::ctor()
         QSettings settings8(format, QSettings::SystemScope, "software.org");
 
         // test QSettings::format() while we're at it
-        QVERIFY(settings1.format() == format);
+        QCOMPARE(settings1.format(), format);
-        QVERIFY(settings2.format() == format);
+        QCOMPARE(settings2.format(), format);
-        QVERIFY(settings3.format() == format);
+        QCOMPARE(settings3.format(), format);
-        QVERIFY(settings4.format() == format);
+        QCOMPARE(settings4.format(), format);
 
         // test QSettings::scope() while we're at it
-        QVERIFY(settings1.scope() == QSettings::UserScope);
+        QCOMPARE(settings1.scope(), QSettings::UserScope);
-        QVERIFY(settings2.scope() == QSettings::UserScope);
+        QCOMPARE(settings2.scope(), QSettings::UserScope);
-        QVERIFY(settings3.scope() == QSettings::SystemScope);
+        QCOMPARE(settings3.scope(), QSettings::SystemScope);
-        QVERIFY(settings4.scope() == QSettings::SystemScope);
+        QCOMPARE(settings4.scope(), QSettings::SystemScope);
 
         // test QSettings::organizationName() while we're at it
-        QVERIFY(settings1.organizationName() == "software.org");
+        QCOMPARE(settings1.organizationName(), QLatin1String("software.org"));
-        QVERIFY(settings2.organizationName() == "software.org");
+        QCOMPARE(settings2.organizationName(), QLatin1String("software.org"));
-        QVERIFY(settings3.organizationName() == "software.org");
+        QCOMPARE(settings3.organizationName(), QLatin1String("software.org"));
-        QVERIFY(settings4.organizationName() == "software.org");
+        QCOMPARE(settings4.organizationName(), QLatin1String("software.org"));
 
         // test QSettings::applicationName() while we're at it
         QCOMPARE(settings1.applicationName(), QString("KillerAPP"));
         QVERIFY(settings2.applicationName().isEmpty());
-        QVERIFY(settings3.applicationName() == "KillerAPP");
+        QCOMPARE(settings3.applicationName(), QLatin1String("KillerAPP"));
         QVERIFY(settings4.applicationName().isEmpty());
 
 #if !defined(Q_OS_BLACKBERRY)
@@ -587,7 +587,7 @@ void tst_QSettings::ctor()
         settings1.endGroup();
 
         // test QSettings::scope() while we're at it
-        QVERIFY(settings1.scope() == QSettings::UserScope);
+        QCOMPARE(settings1.scope(), QSettings::UserScope);
 
         // test QSettings::organizationName() while we're at it
         QVERIFY(settings1.organizationName().isEmpty());
@@ -662,20 +662,20 @@ void tst_QSettings::ctor()
         QCOMPARE(settings2.status(), QSettings::NoError);
 
         // test QSettings::format() while we're at it
-        QVERIFY(settings.format() == format);
+        QCOMPARE(settings.format(), format);
-        QVERIFY(settings2.format() == format);
+        QCOMPARE(settings2.format(), format);
 
         // test QSettings::scope() while we're at it
-        QVERIFY(settings.scope() == QSettings::UserScope);
+        QCOMPARE(settings.scope(), QSettings::UserScope);
-        QVERIFY(settings2.scope() == QSettings::UserScope);
+        QCOMPARE(settings2.scope(), QSettings::UserScope);
 
         // test QSettings::organizationName() while we're at it
         QVERIFY(settings.organizationName().isEmpty());
-        QVERIFY(settings2.organizationName() == "software.org");
+        QCOMPARE(settings2.organizationName(), QLatin1String("software.org"));
 
         // test QSettings::applicationName() while we're at it
         QVERIFY(settings.applicationName().isEmpty());
-        QVERIFY(settings2.applicationName() == "KillerAPP");
+        QCOMPARE(settings2.applicationName(), QLatin1String("KillerAPP"));
     }
 }
 
@@ -1533,7 +1533,7 @@ void tst_QSettings::contains()
     }
 
     settings1.endGroup();
-    QVERIFY(settings1.group() == "alpha");
+    QCOMPARE(settings1.group(), QLatin1String("alpha"));
     keys = settings1.allKeys();
     QCOMPARE(keys.size(), expectedResult.size() + 3);
     for (i = 0; i < keys.size(); ++i) {
@@ -1825,26 +1825,26 @@ void tst_QSettings::testUpdateRequestEvent()
 
     QSettings settings1("foo", QSettings::IniFormat);
     QVERIFY(!QFile::exists("foo"));
-    QVERIFY(QFileInfo("foo").size() == 0);
+    QCOMPARE(QFileInfo("foo").size(), qint64(0));
     settings1.setValue("key1", 1);
-    QVERIFY(QFileInfo("foo").size() == 0);
+    QCOMPARE(QFileInfo("foo").size(), qint64(0));
 
     QTRY_VERIFY(QFileInfo("foo").size() > 0);
 
     settings1.remove("key1");
     QVERIFY(QFileInfo("foo").size() > 0);
 
-    QTRY_VERIFY(QFileInfo("foo").size() == 0);
+    QTRY_COMPARE(QFileInfo("foo").size(), qint64(0));
 
     settings1.setValue("key2", 2);
-    QVERIFY(QFileInfo("foo").size() == 0);
+    QCOMPARE(QFileInfo("foo").size(), qint64(0));
 
     QTRY_VERIFY(QFileInfo("foo").size() > 0);
 
     settings1.clear();
     QVERIFY(QFileInfo("foo").size() > 0);
 
-    QTRY_VERIFY(QFileInfo("foo").size() == 0);
+    QTRY_COMPARE(QFileInfo("foo").size(), qint64(0));
 
 #ifdef Q_OS_WINRT
     QDir::setCurrent(oldCur);
@@ -1991,7 +1991,7 @@ void tst_QSettings::testEmptyData()
         settings.setValue("vList", vList);
         settings.setValue("vList2", vList2);
         settings.setValue("vList3", vList3);
-        QVERIFY(settings.status() == QSettings::NoError);
+        QCOMPARE(settings.status(), QSettings::NoError);
     }
     {
         QSettings settings(filename, QSettings::IniFormat);
@@ -2004,7 +2004,7 @@ void tst_QSettings::testEmptyData()
         QCOMPARE(settings.value("vList").toList(), vList);
         QCOMPARE(settings.value("vList2").toList(), vList2);
         QCOMPARE(settings.value("vList3").toList(), vList3);
-        QVERIFY(settings.status() == QSettings::NoError);
+        QCOMPARE(settings.status(), QSettings::NoError);
     }
 
     {
@@ -2018,7 +2018,7 @@ void tst_QSettings::testEmptyData()
         settings.setValue("vList", vList);
         settings.setValue("vList2", vList2);
         settings.setValue("vList3", vList3);
-        QVERIFY(settings.status() == QSettings::NoError);
+        QCOMPARE(settings.status(), QSettings::NoError);
     }
     {
         QSettings settings("QtProject", "tst_qsettings");
@@ -2031,7 +2031,7 @@ void tst_QSettings::testEmptyData()
         QCOMPARE(settings.value("vList").toList(), vList);
         QCOMPARE(settings.value("vList2").toList(), vList2);
         QCOMPARE(settings.value("vList3").toList(), vList3);
-        QVERIFY(settings.status() == QSettings::NoError);
+        QCOMPARE(settings.status(), QSettings::NoError);
     }
     QFile::remove(filename);
 }
@@ -2049,17 +2049,17 @@ void tst_QSettings::testEmptyKey()
 void tst_QSettings::testResourceFiles()
 {
     QSettings settings(":/resourcefile.ini", QSettings::IniFormat);
-    QVERIFY(settings.status() == QSettings::NoError);
+    QCOMPARE(settings.status(), QSettings::NoError);
     QVERIFY(!settings.isWritable());
     QCOMPARE(settings.value("Field 1/Bottom").toInt(), 89);
     settings.setValue("Field 1/Bottom", 90);
 
     // the next two lines check the statu quo; another behavior would be possible
-    QVERIFY(settings.status() == QSettings::NoError);
+    QCOMPARE(settings.status(), QSettings::NoError);
     QCOMPARE(settings.value("Field 1/Bottom").toInt(), 90);
 
     settings.sync();
-    QVERIFY(settings.status() == QSettings::AccessError);
+    QCOMPARE(settings.status(), QSettings::AccessError);
     QCOMPARE(settings.value("Field 1/Bottom").toInt(), 90);
 }
 
@@ -3164,7 +3164,7 @@ void tst_QSettings::registerFormat()
     // so we can test error handling
 
     QSettings::Format custom3 = QSettings::registerFormat("custom3", readCustom3File, writeCustom3File);
-    QVERIFY(custom3 == QSettings::CustomFormat3);
+    QCOMPARE(custom3, QSettings::CustomFormat3);
 
     QDir dir(settingsPath());
     QVERIFY(dir.mkpath("someDir"));
@@ -3256,23 +3256,23 @@ void tst_QSettings::setPath()
 
 void tst_QSettings::setDefaultFormat()
 {
-    QVERIFY(QSettings::defaultFormat() == QSettings::NativeFormat);
+    QCOMPARE(QSettings::defaultFormat(), QSettings::NativeFormat);
 
     QSettings::setDefaultFormat(QSettings::CustomFormat1);
     QSettings settings1("org", "app");
     QSettings settings2(QSettings::SystemScope, "org", "app");
     QSettings settings3;
 
-    QVERIFY(settings1.format() == QSettings::NativeFormat);
+    QCOMPARE(settings1.format(), QSettings::NativeFormat);
-    QVERIFY(settings2.format() == QSettings::NativeFormat);
+    QCOMPARE(settings2.format(), QSettings::NativeFormat);
-    QVERIFY(settings3.format() == QSettings::CustomFormat1);
+    QCOMPARE(settings3.format(), QSettings::CustomFormat1);
 
     QSettings::setDefaultFormat(QSettings::NativeFormat);
-    QVERIFY(QSettings::defaultFormat() == QSettings::NativeFormat);
+    QCOMPARE(QSettings::defaultFormat(), QSettings::NativeFormat);
 
-    QVERIFY(settings1.format() == QSettings::NativeFormat);
+    QCOMPARE(settings1.format(), QSettings::NativeFormat);
-    QVERIFY(settings2.format() == QSettings::NativeFormat);
+    QCOMPARE(settings2.format(), QSettings::NativeFormat);
-    QVERIFY(settings3.format() == QSettings::CustomFormat1);
+    QCOMPARE(settings3.format(), QSettings::CustomFormat1);
 }
 
 void tst_QSettings::dontCreateNeedlessPaths()
@@ -3333,7 +3333,7 @@ void tst_QSettings::dontReorderIniKeysNeedlessly()
     outFile.close();
 
     QSettings settings(outFileName, QSettings::IniFormat);
-    QVERIFY(settings.status() == QSettings::NoError);
+    QCOMPARE(settings.status(), QSettings::NoError);
     QVERIFY(settings.isWritable());
 
     settings.setValue("Field 1/Bottom", 90);

tests/auto/corelib/io/qstorageinfo/tst_qstorageinfo.cpp

@@ -61,9 +61,9 @@ void tst_QStorageInfo::defaultValues()
     QVERIFY(!storage.isRoot());
     QVERIFY(storage.device().isEmpty());
     QVERIFY(storage.fileSystemType().isEmpty());
-    QVERIFY(storage.bytesTotal() == -1);
+    QCOMPARE(storage.bytesTotal(), -1);
-    QVERIFY(storage.bytesFree() == -1);
+    QCOMPARE(storage.bytesFree(), -1);
-    QVERIFY(storage.bytesAvailable() == -1);
+    QCOMPARE(storage.bytesAvailable(), -1);
 }
 
 void tst_QStorageInfo::operatorEqual()
@@ -71,19 +71,19 @@ void tst_QStorageInfo::operatorEqual()
     {
         QStorageInfo storage1 = QStorageInfo::root();
         QStorageInfo storage2(QDir::rootPath());
-        QVERIFY(storage1 == storage2);
+        QCOMPARE(storage1, storage2);
     }
 
     {
         QStorageInfo storage1(QCoreApplication::applicationDirPath());
         QStorageInfo storage2(QCoreApplication::applicationFilePath());
-        QVERIFY(storage1 == storage2);
+        QCOMPARE(storage1, storage2);
     }
 
     {
         QStorageInfo storage1;
         QStorageInfo storage2;
-        QVERIFY(storage1 == storage2);
+        QCOMPARE(storage1, storage2);
     }
 }
 
@@ -184,15 +184,15 @@ void tst_QStorageInfo::caching()
 
     qint64 free = storage1.bytesFree();
     QStorageInfo storage2(storage1);
-    QVERIFY(free == storage2.bytesFree());
+    QCOMPARE(free, storage2.bytesFree());
 
     file.write(QByteArray(1024*1024, '\0'));
     file.flush();
 
-    QVERIFY(free == storage1.bytesFree());
+    QCOMPARE(free, storage1.bytesFree());
-    QVERIFY(free == storage2.bytesFree());
+    QCOMPARE(free, storage2.bytesFree());
     storage2.refresh();
-    QVERIFY(storage1 == storage2);
+    QCOMPARE(storage1, storage2);
     QVERIFY(free != storage2.bytesFree());
 }
 #endif

tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp

@@ -697,7 +697,7 @@ void tst_QTemporaryFile::createNativeFile()
         f.seek(currentPos);
     }
     QTemporaryFile *tempFile = QTemporaryFile::createNativeFile(f);
-    QVERIFY(valid == (bool)tempFile);
+    QCOMPARE(valid, (bool)tempFile);
     if (currentPos != -1)
         QCOMPARE(currentPos, f.pos());
     if (valid) {

tests/auto/corelib/io/qurl/tst_qurl.cpp

@@ -226,7 +226,7 @@ void tst_QUrl::constructing()
     QVERIFY(url.isEmpty());
     QCOMPARE(url.port(), -1);
     QCOMPARE(url.toString(), QString());
-    QVERIFY(url == url);
+    QCOMPARE(url, url);
     QVERIFY(!(url < url));
 
     QUrl fromLocal = QUrl::fromLocalFile(QString());
@@ -254,7 +254,7 @@ void tst_QUrl::hashInPath()
     QCOMPARE(withHashInPath.toDisplayString(QUrl::PreferLocalFile), QString("hi%23mum.txt"));
 
     QUrl fromHashInPath = QUrl::fromEncoded(withHashInPath.toEncoded());
-    QVERIFY(withHashInPath == fromHashInPath);
+    QCOMPARE(withHashInPath, fromHashInPath);
 
     const QUrl localWithHash = QUrl::fromLocalFile("/hi#mum.txt");
     QCOMPARE(localWithHash.path(), QString::fromLatin1("/hi#mum.txt"));
@@ -284,7 +284,7 @@ void tst_QUrl::assignment()
     QUrl copy;
     copy = url;
 
-    QVERIFY(url == copy);
+    QCOMPARE(url, copy);
 }
 
 void tst_QUrl::comparison()
@@ -295,7 +295,7 @@ void tst_QUrl::comparison()
     QUrl url2("http://qt-project.org/");
     QVERIFY(url2.isValid());
 
-    QVERIFY(url1 == url2);
+    QCOMPARE(url1, url2);
     QVERIFY(!(url1 < url2));
     QVERIFY(!(url2 < url1));
     QVERIFY(url1.matches(url2, QUrl::None));
@@ -329,7 +329,7 @@ void tst_QUrl::comparison()
     url5.setEncodedQuery("a=%2a");
     QUrl url6;
     url6.setEncodedQuery("a=%2A");
-    QVERIFY(url5 == url6);
+    QCOMPARE(url5, url6);
 
     QUrl url7;
     url7.setEncodedQuery("a=C");
@@ -366,7 +366,7 @@ void tst_QUrl::comparison()
 
     QUrl hostUrl1("file:/foo");
     QUrl hostUrl2("file:///foo");
-    QVERIFY(hostUrl1 == hostUrl2);
+    QCOMPARE(hostUrl1, hostUrl2);
     QVERIFY(hostUrl1.matches(hostUrl2, QUrl::None));
     QVERIFY(hostUrl1.matches(hostUrl2, QUrl::RemoveAuthority));
 
@@ -460,7 +460,7 @@ void tst_QUrl::copying()
 
     QUrl copy(url);
 
-    QVERIFY(url == copy);
+    QCOMPARE(url, copy);
 }
 
 void tst_QUrl::setUrl()
@@ -1635,9 +1635,9 @@ void tst_QUrl::percentEncoding()
     QFETCH(QByteArray, encoded);
 
     QCOMPARE(QUrl(original).toEncoded().constData(), encoded.constData());
-    QVERIFY(QUrl::fromEncoded(QUrl(original).toEncoded()) == QUrl(original));
+    QCOMPARE(QUrl::fromEncoded(QUrl(original).toEncoded()), QUrl(original));
     QCOMPARE(QUrl::fromEncoded(QUrl(original).toEncoded()).toString(), original);
-    QVERIFY(QUrl::fromEncoded(encoded) == QUrl(original));
+    QCOMPARE(QUrl::fromEncoded(encoded), QUrl(original));
     QCOMPARE(QUrl(QUrl(original).toString()).toString(), original);
 }
 
@@ -3167,7 +3167,7 @@ void tst_QUrl::acceptEmptyAuthoritySegments()
     // However, file:/bar is the same as file:///bar
     QString file_triple_bar("file:///bar"), file_uni_bar("file:/bar");
 
-    QVERIFY(QUrl(file_triple_bar) == QUrl(file_uni_bar));
+    QCOMPARE(QUrl(file_triple_bar), QUrl(file_uni_bar));
 
     QCOMPARE(QUrl(file_uni_bar).toString(), file_triple_bar);
     QCOMPARE(QUrl(file_uni_bar, QUrl::StrictMode).toString(), file_triple_bar);

tests/auto/corelib/io/qurlquery/tst_qurlquery.cpp

@@ -176,20 +176,20 @@ void tst_QUrlQuery::constructing()
         QUrlQuery copy(empty);
         QVERIFY(copy.isEmpty());
         QVERIFY(!copy.isDetached());
-        QVERIFY(copy == empty);
+        QCOMPARE(copy, empty);
         QCOMPARE(qHash(copy), qHash(empty));
         QVERIFY(!(copy != empty));
 
         copy = empty;
-        QVERIFY(copy == empty);
+        QCOMPARE(copy, empty);
 
         copy = QUrlQuery();
-        QVERIFY(copy == empty);
+        QCOMPARE(copy, empty);
         QCOMPARE(qHash(copy), qHash(empty));
     }
     {
         QUrlQuery copy(emptyQuery());
-        QVERIFY(copy == empty);
+        QCOMPARE(copy, empty);
     }
 
     QVERIFY(!empty.hasQueryItem("a"));
@@ -214,7 +214,7 @@ void tst_QUrlQuery::constructing()
     QVERIFY(!(other == empty));
 
     QUrlQuery copy(other);
-    QVERIFY(copy == other);
+    QCOMPARE(copy, other);
 
     copy.clear();
     QVERIFY(copy.isEmpty());
@@ -222,7 +222,7 @@ void tst_QUrlQuery::constructing()
 
     copy = other;
     QVERIFY(!copy.isEmpty());
-    QVERIFY(copy == other);
+    QCOMPARE(copy, other);
 
     copy = QUrlQuery();
     QVERIFY(copy.isEmpty());
@@ -298,7 +298,7 @@ void tst_QUrlQuery::addRemove()
         QCOMPARE(allItems.at(0).first, QString("a"));
         QCOMPARE(allItems.at(0).second, QString("b"));
 
-        QVERIFY(query == original);
+        QCOMPARE(query, original);
         QVERIFY(!(query != original));
         QCOMPARE(qHash(query), qHash(original));
     }
@@ -346,7 +346,7 @@ void tst_QUrlQuery::multiAddRemove()
         QVERIFY(query.hasQueryItem("a"));
 
         // returns the first one
-        QVERIFY(query.queryItemValue("a") == "b");
+        QCOMPARE(query.queryItemValue("a"), QLatin1String("b"));
 
         // order is the order we set them in
         QVERIFY(query.allQueryItemValues("a") == QStringList() << "b" << "c");
@@ -359,9 +359,9 @@ void tst_QUrlQuery::multiAddRemove()
         QVERIFY(query.hasQueryItem("A"));
         QVERIFY(query.hasQueryItem("a"));
 
-        QVERIFY(query.queryItemValue("a") == "b");
+        QCOMPARE(query.queryItemValue("a"), QLatin1String("b"));
         QVERIFY(query.allQueryItemValues("a") == QStringList() << "b" << "c");
-        QVERIFY(query.queryItemValue("A") == "B");
+        QCOMPARE(query.queryItemValue("A"), QLatin1String("B"));
         QVERIFY(query.allQueryItemValues("A") == QStringList() << "B" << "C");
     }
 
@@ -371,7 +371,7 @@ void tst_QUrlQuery::multiAddRemove()
         QVERIFY(query.hasQueryItem("a"));
 
         // it must have removed the first one
-        QVERIFY(query.queryItemValue("a") == "c");
+        QCOMPARE(query.queryItemValue("a"), QLatin1String("c"));
     }
 
     {
@@ -720,7 +720,7 @@ void tst_QUrlQuery::old_queryItems()
     QVERIFY(!url.isEmpty());
 
     QList<QPair<QString, QString> > setItems = url.queryItems();
-    QVERIFY(newItems == setItems);
+    QCOMPARE(newItems, setItems);
 
     url.addQueryItem("1", "z");
 

tests/auto/corelib/io/qwinoverlappedionotifier/tst_qwinoverlappedionotifier.cpp

@@ -199,7 +199,7 @@ void tst_QWinOverlappedIoNotifier::waitForAnyNotified()
                               NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
     notifier.setHandle(hFile);
     notifier.setEnabled(true);
-    QVERIFY(notifier.waitForAnyNotified(100) == 0);
+    QVERIFY(!notifier.waitForAnyNotified(100));
 
     OVERLAPPED overlapped1;
     ZeroMemory(&overlapped1, sizeof(OVERLAPPED));
@@ -224,7 +224,7 @@ void tst_QWinOverlappedIoNotifier::waitForAnyNotified()
 
     CloseHandle(hFile);
     QVERIFY(overlappedObjects.isEmpty());
-    QVERIFY(notifier.waitForAnyNotified(100) == 0);
+    QVERIFY(!notifier.waitForAnyNotified(100));
 }
 
 void tst_QWinOverlappedIoNotifier::brokenPipe()

tests/auto/corelib/itemmodels/qabstractitemmodel/tst_qabstractitemmodel.cpp

@@ -1699,8 +1699,8 @@ void tst_QAbstractItemModel::testMoveToDescendants()
             moveCommand->setDestRow(row);
             moveCommand->doCommand();
 
-            QVERIFY(beforeSpy.size() == 0);
+            QCOMPARE(beforeSpy.size(), 0);
-            QVERIFY(afterSpy.size() == 0);
+            QCOMPARE(afterSpy.size(), 0);
         }
     }
 }
@@ -1757,8 +1757,8 @@ void tst_QAbstractItemModel::testMoveWithinOwnRange()
     moveCommand->setDestRow(destRow);
     moveCommand->doCommand();
 
-    QVERIFY(beforeSpy.size() == 0);
+    QCOMPARE(beforeSpy.size(), 0);
-    QVERIFY(afterSpy.size() == 0);
+    QCOMPARE(afterSpy.size(), 0);
 }
 
 class ListenerObject : public QObject
@@ -1823,7 +1823,7 @@ void ListenerObject::slotAboutToBeReset()
     // Nothing has been changed yet. All indexes should be the same.
     for (int i = 0; i < m_persistentIndexes.size(); ++i) {
         QModelIndex idx = m_persistentIndexes.at(i);
-        QVERIFY(idx == m_nonPersistentIndexes.at(i));
+        QCOMPARE(idx, m_nonPersistentIndexes.at(i));
         QVERIFY(m_model->mapToSource(idx).isValid());
     }
 }
@@ -1859,13 +1859,13 @@ void tst_QAbstractItemModel::testReset()
     resetCommand->doCommand();
 
     // Verify that the correct signals were emitted
-    QVERIFY(beforeResetSpy.size() == 1);
+    QCOMPARE(beforeResetSpy.size(), 1);
-    QVERIFY(afterResetSpy.size() == 1);
+    QCOMPARE(afterResetSpy.size(), 1);
 
     // Verify that the move actually happened.
-    QVERIFY(m_model->rowCount() == 9);
+    QCOMPARE(m_model->rowCount(), 9);
     QModelIndex destIndex = m_model->index(4, 0);
-    QVERIFY(m_model->rowCount(destIndex) == 11);
+    QCOMPARE(m_model->rowCount(destIndex), 11);
 
     // Delete it because its slots test things which are not true after this point.
     delete listener;
@@ -1877,14 +1877,14 @@ void tst_QAbstractItemModel::testReset()
     QCOMPARE(nullProxy->roleNames().value(Qt::UserRole + 1), QByteArray());
 
     nullProxy->setSourceModel(new ModelWithCustomRole(this));
-    QVERIFY(proxyBeforeResetSpy.size() == 1);
+    QCOMPARE(proxyBeforeResetSpy.size(), 1);
-    QVERIFY(proxyAfterResetSpy.size() == 1);
+    QCOMPARE(proxyAfterResetSpy.size(), 1);
 
     QCOMPARE(nullProxy->roleNames().value(Qt::UserRole + 1), QByteArray("custom"));
 
     nullProxy->setSourceModel(m_model);
-    QVERIFY(proxyBeforeResetSpy.size() == 2);
+    QCOMPARE(proxyBeforeResetSpy.size(), 2);
-    QVERIFY(proxyAfterResetSpy.size() == 2);
+    QCOMPARE(proxyAfterResetSpy.size(), 2);
 
     // After being reset the proxy must be queried again.
     QCOMPARE(nullProxy->roleNames().value(Qt::UserRole + 1), QByteArray());
@@ -2055,10 +2055,10 @@ void tst_QAbstractItemModel::testChildrenLayoutsChanged()
         QVERIFY(afterParents.contains(p2));
 
         // The first will be the last, and the lest will be the first.
-        QVERIFY(p1FirstPersistent.row() == 1);
+        QCOMPARE(p1FirstPersistent.row(), 1);
-        QVERIFY(p1LastPersistent.row() == 0);
+        QCOMPARE(p1LastPersistent.row(), 0);
-        QVERIFY(p2FirstPersistent.row() == 9);
+        QCOMPARE(p2FirstPersistent.row(), 9);
-        QVERIFY(p2LastPersistent.row() == 8);
+        QCOMPARE(p2LastPersistent.row(), 8);
     }
 
     insertCommand = new ModelInsertCommand(&model, this);
@@ -2115,8 +2115,8 @@ void tst_QAbstractItemModel::testChildrenLayoutsChanged()
         QCOMPARE(beforeSignal.size(), 2);
         QCOMPARE(afterSignal.size(), 2);
 
-        QVERIFY(p1FirstPersistent.row() == 1);
+        QCOMPARE(p1FirstPersistent.row(), 1);
-        QVERIFY(p1LastPersistent.row() == 0);
+        QCOMPARE(p1LastPersistent.row(), 0);
         QCOMPARE(p2FirstPersistent.row(), 9);
         QCOMPARE(p2LastPersistent.row(), 8);
     }

tests/auto/corelib/itemmodels/qabstractproxymodel/tst_qabstractproxymodel.cpp

@@ -351,7 +351,7 @@ static void verifySubSetOf(const QHash<int, QByteArray> &superSet, const QHash<i
     const QHash<int, QByteArray>::const_iterator end = subSet.constEnd();
     for ( ; it != end; ++it ) {
         QVERIFY(superSet.contains(it.key()));
-        QVERIFY(it.value() == superSet.value(it.key()));
+        QCOMPARE(it.value(), superSet.value(it.key()));
     }
 }
 

tests/auto/corelib/itemmodels/qidentityproxymodel/tst_qidentityproxymodel.cpp

@@ -111,25 +111,25 @@ void tst_QIdentityProxyModel::verifyIdentity(QAbstractItemModel *model, const QM
     const int columns = model->columnCount(parent);
     const QModelIndex proxyParent = m_proxy->mapFromSource(parent);
 
-    QVERIFY(m_proxy->mapToSource(proxyParent) == parent);
+    QCOMPARE(m_proxy->mapToSource(proxyParent), parent);
-    QVERIFY(rows == m_proxy->rowCount(proxyParent));
+    QCOMPARE(rows, m_proxy->rowCount(proxyParent));
-    QVERIFY(columns == m_proxy->columnCount(proxyParent));
+    QCOMPARE(columns, m_proxy->columnCount(proxyParent));
 
     for (int row = 0; row < rows; ++row) {
         for (int column = 0; column < columns; ++column) {
             const QModelIndex idx = model->index(row, column, parent);
             const QModelIndex proxyIdx = m_proxy->mapFromSource(idx);
-            QVERIFY(proxyIdx.model() == m_proxy);
+            QCOMPARE(proxyIdx.model(), m_proxy);
-            QVERIFY(m_proxy->mapToSource(proxyIdx) == idx);
+            QCOMPARE(m_proxy->mapToSource(proxyIdx), idx);
             QVERIFY(proxyIdx.isValid());
-            QVERIFY(proxyIdx.row() == row);
+            QCOMPARE(proxyIdx.row(), row);
-            QVERIFY(proxyIdx.column() == column);
+            QCOMPARE(proxyIdx.column(), column);
-            QVERIFY(proxyIdx.parent() == proxyParent);
+            QCOMPARE(proxyIdx.parent(), proxyParent);
-            QVERIFY(proxyIdx.data() == idx.data());
+            QCOMPARE(proxyIdx.data(), idx.data());
-            QVERIFY(proxyIdx.flags() == idx.flags());
+            QCOMPARE(proxyIdx.flags(), idx.flags());
             const int childCount = m_proxy->rowCount(proxyIdx);
             const bool hasChildren = m_proxy->hasChildren(proxyIdx);
-            QVERIFY(model->hasChildren(idx) == hasChildren);
+            QCOMPARE(model->hasChildren(idx), hasChildren);
             QVERIFY((childCount > 0) == hasChildren);
 
             if (hasChildren)
@@ -171,13 +171,13 @@ void tst_QIdentityProxyModel::insertRows()
     QVERIFY(modelBeforeSpy.size() == 1 && 1 == proxyBeforeSpy.size());
     QVERIFY(modelAfterSpy.size() == 1 && 1 == proxyAfterSpy.size());
 
-    QVERIFY(modelBeforeSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
+    QCOMPARE(modelBeforeSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
-    QVERIFY(modelBeforeSpy.first().at(1) == proxyBeforeSpy.first().at(1));
+    QCOMPARE(modelBeforeSpy.first().at(1), proxyBeforeSpy.first().at(1));
-    QVERIFY(modelBeforeSpy.first().at(2) == proxyBeforeSpy.first().at(2));
+    QCOMPARE(modelBeforeSpy.first().at(2), proxyBeforeSpy.first().at(2));
 
-    QVERIFY(modelAfterSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
+    QCOMPARE(modelAfterSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
-    QVERIFY(modelAfterSpy.first().at(1) == proxyAfterSpy.first().at(1));
+    QCOMPARE(modelAfterSpy.first().at(1), proxyAfterSpy.first().at(1));
-    QVERIFY(modelAfterSpy.first().at(2) == proxyAfterSpy.first().at(2));
+    QCOMPARE(modelAfterSpy.first().at(2), proxyAfterSpy.first().at(2));
 
     verifyIdentity(m_model);
 }
@@ -216,13 +216,13 @@ void tst_QIdentityProxyModel::removeRows()
     QVERIFY(modelBeforeSpy.size() == 1 && 1 == proxyBeforeSpy.size());
     QVERIFY(modelAfterSpy.size() == 1 && 1 == proxyAfterSpy.size());
 
-    QVERIFY(modelBeforeSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
+    QCOMPARE(modelBeforeSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
-    QVERIFY(modelBeforeSpy.first().at(1) == proxyBeforeSpy.first().at(1));
+    QCOMPARE(modelBeforeSpy.first().at(1), proxyBeforeSpy.first().at(1));
-    QVERIFY(modelBeforeSpy.first().at(2) == proxyBeforeSpy.first().at(2));
+    QCOMPARE(modelBeforeSpy.first().at(2), proxyBeforeSpy.first().at(2));
 
-    QVERIFY(modelAfterSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
+    QCOMPARE(modelAfterSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
-    QVERIFY(modelAfterSpy.first().at(1) == proxyAfterSpy.first().at(1));
+    QCOMPARE(modelAfterSpy.first().at(1), proxyAfterSpy.first().at(1));
-    QVERIFY(modelAfterSpy.first().at(2) == proxyAfterSpy.first().at(2));
+    QCOMPARE(modelAfterSpy.first().at(2), proxyAfterSpy.first().at(2));
 
     verifyIdentity(m_model);
 }
@@ -271,17 +271,17 @@ void tst_QIdentityProxyModel::moveRows()
     QVERIFY(modelBeforeSpy.size() == 1 && 1 == proxyBeforeSpy.size());
     QVERIFY(modelAfterSpy.size() == 1 && 1 == proxyAfterSpy.size());
 
-    QVERIFY(modelBeforeSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
+    QCOMPARE(modelBeforeSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
-    QVERIFY(modelBeforeSpy.first().at(1) == proxyBeforeSpy.first().at(1));
+    QCOMPARE(modelBeforeSpy.first().at(1), proxyBeforeSpy.first().at(1));
-    QVERIFY(modelBeforeSpy.first().at(2) == proxyBeforeSpy.first().at(2));
+    QCOMPARE(modelBeforeSpy.first().at(2), proxyBeforeSpy.first().at(2));
-    QVERIFY(modelBeforeSpy.first().at(3).value<QModelIndex>() == m_proxy->mapToSource(proxyBeforeSpy.first().at(3).value<QModelIndex>()));
+    QCOMPARE(modelBeforeSpy.first().at(3).value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().at(3).value<QModelIndex>()));
-    QVERIFY(modelBeforeSpy.first().at(4) == proxyBeforeSpy.first().at(4));
+    QCOMPARE(modelBeforeSpy.first().at(4), proxyBeforeSpy.first().at(4));
 
-    QVERIFY(modelAfterSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
+    QCOMPARE(modelAfterSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
-    QVERIFY(modelAfterSpy.first().at(1) == proxyAfterSpy.first().at(1));
+    QCOMPARE(modelAfterSpy.first().at(1), proxyAfterSpy.first().at(1));
-    QVERIFY(modelAfterSpy.first().at(2) == proxyAfterSpy.first().at(2));
+    QCOMPARE(modelAfterSpy.first().at(2), proxyAfterSpy.first().at(2));
-    QVERIFY(modelAfterSpy.first().at(3).value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().at(3).value<QModelIndex>()));
+    QCOMPARE(modelAfterSpy.first().at(3).value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().at(3).value<QModelIndex>()));
-    QVERIFY(modelAfterSpy.first().at(4) == proxyAfterSpy.first().at(4));
+    QCOMPARE(modelAfterSpy.first().at(4), proxyAfterSpy.first().at(4));
 
     verifyIdentity(&model);
 
@@ -352,7 +352,7 @@ void tst_QIdentityProxyModel::dataChanged()
     model.changeData();
 
     QCOMPARE(modelSpy.first().at(2).value<QVector<int> >(), QVector<int>() << 1);
-    QVERIFY(modelSpy.first().at(2) == proxySpy.first().at(2));
+    QCOMPARE(modelSpy.first().at(2), proxySpy.first().at(2));
 
     verifyIdentity(&model);
     m_proxy->setSourceModel(0);

tests/auto/corelib/itemmodels/qitemmodel/tst_qitemmodel.cpp

@@ -351,7 +351,7 @@ void tst_QItemModel::index()
     // Make sure that the same index is always returned
     QModelIndex a = currentModel->index(0,0);
     QModelIndex b = currentModel->index(0,0);
-    QVERIFY(a == b);
+    QCOMPARE(a, b);
 
     // index is tested more extensivly more later in checkChildren(),
     // but this catches the big mistakes
@@ -415,7 +415,7 @@ void checkChildren(QAbstractItemModel *currentModel, const QModelIndex &parent,
             // Make sure we get the same index if we request it twice in a row
             QModelIndex a = currentModel->index(r, c, parent);
             QModelIndex b = currentModel->index(r, c, parent);
-            QVERIFY(a == b);
+            QCOMPARE(a, b);
 
             {
                 const QModelIndex sibling = currentModel->sibling( r, c, topLeftChild );
@@ -427,7 +427,7 @@ void checkChildren(QAbstractItemModel *currentModel, const QModelIndex &parent,
             }
 
             // Some basic checking on the index that is returned
-            QVERIFY(index.model() == currentModel);
+            QCOMPARE(index.model(), currentModel);
             QCOMPARE(index.row(), r);
             QCOMPARE(index.column(), c);
             QCOMPARE(currentModel->data(index, Qt::DisplayRole).isValid(), true);

tests/auto/corelib/itemmodels/qitemselectionmodel/tst_qitemselectionmodel.cpp

@@ -1757,7 +1757,7 @@ void tst_QItemSelectionModel::modelLayoutChanged()
     // verify that selection is as expected
     QItemSelection selection = selectionModel.selection();
     QCOMPARE(selection.count(), expectedSelectedRanges.count());
-    QVERIFY(selectionModel.hasSelection() == !expectedSelectedRanges.isEmpty());
+    QCOMPARE(selectionModel.hasSelection(), !expectedSelectedRanges.isEmpty());
 
     for (int i = 0; i < expectedSelectedRanges.count(); ++i) {
         IntPairPair expectedRange = expectedSelectedRanges.at(i);
@@ -2214,7 +2214,7 @@ void tst_QItemSelectionModel::childrenDeselectionSignal()
     QSignalSpy deselectSpy(&selectionModel, &QItemSelectionModel::selectionChanged);
     QVERIFY(deselectSpy.isValid());
     model.removeRows(0, 1, root);
-    QVERIFY(deselectSpy.count() == 1);
+    QCOMPARE(deselectSpy.count(), 1);
 
     // More testing stress for the patch.
     model.clear();
@@ -2242,7 +2242,7 @@ void tst_QItemSelectionModel::childrenDeselectionSignal()
     QVERIFY(selectionModel.selection().contains(sel2));
     deselectSpy.clear();
     model.removeRow(0, model.index(0, 0));
-    QVERIFY(deselectSpy.count() == 1);
+    QCOMPARE(deselectSpy.count(), 1);
     QVERIFY(!selectionModel.selection().contains(sel));
     QVERIFY(selectionModel.selection().contains(sel2));
 }
@@ -2372,7 +2372,7 @@ public slots:
         foreach(const QModelIndex &index, deselected.indexes()) {
             QVERIFY(!m_itemSelectionModel->selection().contains(index));
         }
-        QVERIFY(m_itemSelectionModel->selection().size() == 2);
+        QCOMPARE(m_itemSelectionModel->selection().size(), 2);
     }
 };
 
@@ -2390,7 +2390,7 @@ void tst_QItemSelectionModel::deselectRemovedMiddleRange()
 
     selModel.select(QItemSelection(model.index(3, 0), model.index(6, 0)), QItemSelectionModel::Select);
 
-    QVERIFY(selModel.selection().size() == 1);
+    QCOMPARE(selModel.selection().size(), 1);
 
     RemovalObserver ro(&selModel);
 
@@ -2399,7 +2399,7 @@ void tst_QItemSelectionModel::deselectRemovedMiddleRange()
     bool ok = model.removeRows(4, 2);
 
     QVERIFY(ok);
-    QVERIFY(spy.size() == 1);
+    QCOMPARE(spy.size(), 1);
 }
 
 static QStandardItemModel* getModel(QObject *parent)
@@ -2710,8 +2710,8 @@ void tst_QItemSelectionModel::testChainedSelectionClear()
         QModelIndexList selectedIndexes = selectionModel.selection().indexes();
         QModelIndexList duplicatedIndexes = duplicate.selection().indexes();
 
-        QVERIFY(selectedIndexes.size() == duplicatedIndexes.size());
+        QCOMPARE(selectedIndexes.size(), duplicatedIndexes.size());
-        QVERIFY(selectedIndexes.size() == 1);
+        QCOMPARE(selectedIndexes.size(), 1);
         QVERIFY(selectedIndexes.first() == model.index(0, 0));
     }
 
@@ -2721,18 +2721,18 @@ void tst_QItemSelectionModel::testChainedSelectionClear()
         QModelIndexList selectedIndexes = selectionModel.selection().indexes();
         QModelIndexList duplicatedIndexes = duplicate.selection().indexes();
 
-        QVERIFY(selectedIndexes.size() == duplicatedIndexes.size());
+        QCOMPARE(selectedIndexes.size(), duplicatedIndexes.size());
-        QVERIFY(selectedIndexes.size() == 0);
+        QCOMPARE(selectedIndexes.size(), 0);
     }
 
     duplicate.setCurrentIndex(model.index(0, 0), QItemSelectionModel::NoUpdate);
 
-    QVERIFY(selectionModel.currentIndex() == duplicate.currentIndex());
+    QCOMPARE(selectionModel.currentIndex(), duplicate.currentIndex());
 
     duplicate.clearCurrentIndex();
 
     QVERIFY(!duplicate.currentIndex().isValid());
-    QVERIFY(selectionModel.currentIndex() == duplicate.currentIndex());
+    QCOMPARE(selectionModel.currentIndex(), duplicate.currentIndex());
 }
 
 void tst_QItemSelectionModel::testClearCurrentIndex()
@@ -2747,13 +2747,13 @@ void tst_QItemSelectionModel::testClearCurrentIndex()
     QModelIndex firstIndex = model.index(0, 0);
     QVERIFY(firstIndex.isValid());
     selectionModel.setCurrentIndex(firstIndex, QItemSelectionModel::NoUpdate);
-    QVERIFY(selectionModel.currentIndex() == firstIndex);
+    QCOMPARE(selectionModel.currentIndex(), firstIndex);
-    QVERIFY(currentIndexSpy.size() == 1);
+    QCOMPARE(currentIndexSpy.size(), 1);
 
     selectionModel.clearCurrentIndex();
 
-    QVERIFY(selectionModel.currentIndex() == QModelIndex());
+    QCOMPARE(selectionModel.currentIndex(), QModelIndex());
-    QVERIFY(currentIndexSpy.size() == 2);
+    QCOMPARE(currentIndexSpy.size(), 2);
 }
 
 QTEST_MAIN(tst_QItemSelectionModel)

tests/auto/corelib/itemmodels/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp

@@ -1663,16 +1663,16 @@ void tst_QSortFilterProxyModel::removeSourceRows()
     QCOMPARE(aboutToRemoveSpy.count(), expectedRemovedProxyIntervals.count());
     for (int i = 0; i < aboutToRemoveSpy.count(); ++i) {
         QList<QVariant> args = aboutToRemoveSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), expectedRemovedProxyIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), expectedRemovedProxyIntervals.at(i).second);
     }
     QCOMPARE(removeSpy.count(), expectedRemovedProxyIntervals.count());
     for (int i = 0; i < removeSpy.count(); ++i) {
         QList<QVariant> args = removeSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), expectedRemovedProxyIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), expectedRemovedProxyIntervals.at(i).second);
     }
@@ -1841,8 +1841,8 @@ void tst_QSortFilterProxyModel::changeFilter()
     QCOMPARE(initialInsertSpy.count(), 0);
     for (int i = 0; i < initialRemoveSpy.count(); ++i) {
         QList<QVariant> args = initialRemoveSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), initialRemoveIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), initialRemoveIntervals.at(i).second);
     }
@@ -1864,8 +1864,8 @@ void tst_QSortFilterProxyModel::changeFilter()
     QCOMPARE(finalRemoveSpy.count(), finalRemoveIntervals.count());
     for (int i = 0; i < finalRemoveSpy.count(); ++i) {
         QList<QVariant> args = finalRemoveSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), finalRemoveIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), finalRemoveIntervals.at(i).second);
     }
@@ -1876,8 +1876,8 @@ void tst_QSortFilterProxyModel::changeFilter()
     QCOMPARE(finalInsertSpy.count(), insertIntervals.count());
     for (int i = 0; i < finalInsertSpy.count(); ++i) {
         QList<QVariant> args = finalInsertSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), insertIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), insertIntervals.at(i).second);
     }
@@ -2018,8 +2018,8 @@ void tst_QSortFilterProxyModel::changeSourceData()
     QCOMPARE(removeSpy.count(), removeIntervals.count());
     for (int i = 0; i < removeSpy.count(); ++i) {
         QList<QVariant> args = removeSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), removeIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), removeIntervals.at(i).second);
     }
@@ -2027,8 +2027,8 @@ void tst_QSortFilterProxyModel::changeSourceData()
     QCOMPARE(insertSpy.count(), insertIntervals.count());
     for (int i = 0; i < insertSpy.count(); ++i) {
         QList<QVariant> args = insertSpy.at(i);
-        QVERIFY(args.at(1).type() == QVariant::Int);
+        QCOMPARE(args.at(1).type(), QVariant::Int);
-        QVERIFY(args.at(2).type() == QVariant::Int);
+        QCOMPARE(args.at(2).type(), QVariant::Int);
         QCOMPARE(args.at(1).toInt(), insertIntervals.at(i).first);
         QCOMPARE(args.at(2).toInt(), insertIntervals.at(i).second);
     }
@@ -3205,7 +3205,7 @@ void tst_QSortFilterProxyModel::mapSelectionFromSource()
     proxy.setSourceModel(&model);
 
     // Only "delta" remains.
-    QVERIFY(proxy.rowCount() == 1);
+    QCOMPARE(proxy.rowCount(), 1);
 
     QItemSelection selection;
     QModelIndex charlie = model.index(1, 0);
@@ -3220,7 +3220,7 @@ void tst_QSortFilterProxyModel::mapSelectionFromSource()
     QItemSelection proxiedSelection = proxy.mapSelectionFromSource(selection);
 
     // Only "delta" is in the mapped result.
-    QVERIFY(proxiedSelection.size() == 1);
+    QCOMPARE(proxiedSelection.size(), 1);
     QVERIFY(isValid(proxiedSelection));
 }
 

tests/auto/corelib/json/tst_qtjson.cpp

@@ -741,7 +741,7 @@ void tst_QtJson::testObjectIteration()
 
     {
         QJsonObject object2 = object;
-        QVERIFY(object == object2);
+        QCOMPARE(object, object2);
 
         QJsonValue val = *object2.begin();
         object2.erase(object2.begin());
@@ -757,7 +757,7 @@ void tst_QtJson::testObjectIteration()
 
     {
         QJsonObject object2 = object;
-        QVERIFY(object == object2);
+        QCOMPARE(object, object2);
 
         QJsonObject::iterator it = object2.find(QString::number(5));
         object2.erase(it);
@@ -793,7 +793,7 @@ void tst_QtJson::testObjectIteration()
     while (!object.isEmpty())
         it = object.erase(it);
     QCOMPARE(object.size() , 0);
-    QVERIFY(it == object.end());
+    QCOMPARE(it, object.end());
 }
 
 void tst_QtJson::testArrayIteration()
@@ -814,7 +814,7 @@ void tst_QtJson::testArrayIteration()
 
     {
         QJsonArray array2 = array;
-        QVERIFY(array == array2);
+        QCOMPARE(array, array2);
 
         QJsonValue val = *array2.begin();
         array2.erase(array2.begin());
@@ -856,7 +856,7 @@ void tst_QtJson::testArrayIteration()
     while (!array.isEmpty())
         it = array.erase(it);
     QCOMPARE(array.size() , 0);
-    QVERIFY(it == array.end());
+    QCOMPARE(it, array.end());
 }
 
 void tst_QtJson::testObjectFind()
@@ -870,14 +870,14 @@ void tst_QtJson::testObjectFind()
     QJsonObject::iterator it = object.find(QLatin1String("1"));
     QCOMPARE((*it).toDouble(), 1.);
     it = object.find(QLatin1String("11"));
-    QVERIFY((*it).type() == QJsonValue::Undefined);
+    QCOMPARE((*it).type(), QJsonValue::Undefined);
-    QVERIFY(it == object.end());
+    QCOMPARE(it, object.end());
 
     QJsonObject::const_iterator cit = object.constFind(QLatin1String("1"));
     QCOMPARE((*cit).toDouble(), 1.);
     cit = object.constFind(QLatin1String("11"));
-    QVERIFY((*it).type() == QJsonValue::Undefined);
+    QCOMPARE((*it).type(), QJsonValue::Undefined);
-    QVERIFY(it == object.end());
+    QCOMPARE(it, object.end());
 }
 
 void tst_QtJson::testDocument()
@@ -898,8 +898,8 @@ void tst_QtJson::testDocument()
     QCOMPARE(doc.isEmpty(), false);
     QCOMPARE(doc.isArray(), false);
     QCOMPARE(doc.isObject(), true);
-    QVERIFY(doc.object() == object);
+    QCOMPARE(doc.object(), object);
-    QVERIFY(doc.array() == QJsonArray());
+    QCOMPARE(doc.array(), QJsonArray());
 
     doc = QJsonDocument();
     QCOMPARE(doc.isEmpty(), true);
@@ -917,8 +917,8 @@ void tst_QtJson::testDocument()
     QCOMPARE(doc.isEmpty(), false);
     QCOMPARE(doc.isArray(), true);
     QCOMPARE(doc.isObject(), false);
-    QVERIFY(doc.array() == array);
+    QCOMPARE(doc.array(), array);
-    QVERIFY(doc.object() == QJsonObject());
+    QCOMPARE(doc.object(), QJsonObject());
 
     QJsonObject outer;
     outer.insert(QLatin1String("outerKey"), 22);
@@ -1740,7 +1740,7 @@ void tst_QtJson::fromBinary()
     QJsonDocument doc = QJsonDocument::fromJson(testJson);
     QJsonDocument outdoc = QJsonDocument::fromBinaryData(doc.toBinaryData());
     QVERIFY(!outdoc.isNull());
-    QVERIFY(doc == outdoc);
+    QCOMPARE(doc, outdoc);
 
     QFile bfile(testDataDir + "/test.bjson");
     bfile.open(QFile::ReadOnly);
@@ -1748,8 +1748,8 @@ void tst_QtJson::fromBinary()
 
     QJsonDocument bdoc = QJsonDocument::fromBinaryData(binary);
     QVERIFY(!bdoc.isNull());
-    QVERIFY(doc.toVariant() == bdoc.toVariant());
+    QCOMPARE(doc.toVariant(), bdoc.toVariant());
-    QVERIFY(doc == bdoc);
+    QCOMPARE(doc, bdoc);
 }
 
 void tst_QtJson::toAndFromBinary_data()
@@ -1770,7 +1770,7 @@ void tst_QtJson::toAndFromBinary()
     QVERIFY(!doc.isNull());
     QJsonDocument outdoc = QJsonDocument::fromBinaryData(doc.toBinaryData());
     QVERIFY(!outdoc.isNull());
-    QVERIFY(doc == outdoc);
+    QCOMPARE(doc, outdoc);
 }
 
 void tst_QtJson::parseNumbers()
@@ -2086,7 +2086,7 @@ void tst_QtJson::assignToDocument()
         QJsonDocument innerDoc(inner.toObject());
 
         QVERIFY(innerDoc != doc);
-        QVERIFY(innerDoc.object() == inner.toObject());
+        QCOMPARE(innerDoc.object(), inner.toObject());
     }
     {
         const char *json = "[ [ true ] ]";
@@ -2098,7 +2098,7 @@ void tst_QtJson::assignToDocument()
         QJsonDocument innerDoc(inner.toArray());
 
         QVERIFY(innerDoc != doc);
-        QVERIFY(innerDoc.array() == inner.toArray());
+        QCOMPARE(innerDoc.array(), inner.toArray());
     }
 }
 
@@ -2129,7 +2129,7 @@ void tst_QtJson::testCompaction()
     QVERIFY(!doc.isEmpty());
     QCOMPARE(doc.isArray(), false);
     QCOMPARE(doc.isObject(), true);
-    QVERIFY(doc.object() == obj);
+    QCOMPARE(doc.object(), obj);
 }
 
 void tst_QtJson::testDebugStream()
@@ -2328,14 +2328,14 @@ void tst_QtJson::testDetachBug()
 
 void tst_QtJson::valueEquals()
 {
-    QVERIFY(QJsonValue() == QJsonValue());
+    QCOMPARE(QJsonValue(), QJsonValue());
     QVERIFY(QJsonValue() != QJsonValue(QJsonValue::Undefined));
     QVERIFY(QJsonValue() != QJsonValue(true));
     QVERIFY(QJsonValue() != QJsonValue(1.));
     QVERIFY(QJsonValue() != QJsonValue(QJsonArray()));
     QVERIFY(QJsonValue() != QJsonValue(QJsonObject()));
 
-    QVERIFY(QJsonValue(true) == QJsonValue(true));
+    QCOMPARE(QJsonValue(true), QJsonValue(true));
     QVERIFY(QJsonValue(true) != QJsonValue(false));
     QVERIFY(QJsonValue(true) != QJsonValue(QJsonValue::Undefined));
     QVERIFY(QJsonValue(true) != QJsonValue());
@@ -2343,9 +2343,9 @@ void tst_QtJson::valueEquals()
     QVERIFY(QJsonValue(true) != QJsonValue(QJsonArray()));
     QVERIFY(QJsonValue(true) != QJsonValue(QJsonObject()));
 
-    QVERIFY(QJsonValue(1) == QJsonValue(1));
+    QCOMPARE(QJsonValue(1), QJsonValue(1));
     QVERIFY(QJsonValue(1) != QJsonValue(2));
-    QVERIFY(QJsonValue(1) == QJsonValue(1.));
+    QCOMPARE(QJsonValue(1), QJsonValue(1.));
     QVERIFY(QJsonValue(1) != QJsonValue(1.1));
     QVERIFY(QJsonValue(1) != QJsonValue(QJsonValue::Undefined));
     QVERIFY(QJsonValue(1) != QJsonValue());
@@ -2353,7 +2353,7 @@ void tst_QtJson::valueEquals()
     QVERIFY(QJsonValue(1) != QJsonValue(QJsonArray()));
     QVERIFY(QJsonValue(1) != QJsonValue(QJsonObject()));
 
-    QVERIFY(QJsonValue(1.) == QJsonValue(1.));
+    QCOMPARE(QJsonValue(1.), QJsonValue(1.));
     QVERIFY(QJsonValue(1.) != QJsonValue(2.));
     QVERIFY(QJsonValue(1.) != QJsonValue(QJsonValue::Undefined));
     QVERIFY(QJsonValue(1.) != QJsonValue());
@@ -2361,7 +2361,7 @@ void tst_QtJson::valueEquals()
     QVERIFY(QJsonValue(1.) != QJsonValue(QJsonArray()));
     QVERIFY(QJsonValue(1.) != QJsonValue(QJsonObject()));
 
-    QVERIFY(QJsonValue(QJsonArray()) == QJsonValue(QJsonArray()));
+    QCOMPARE(QJsonValue(QJsonArray()), QJsonValue(QJsonArray()));
     QJsonArray nonEmptyArray;
     nonEmptyArray.append(true);
     QVERIFY(QJsonValue(QJsonArray()) != nonEmptyArray);
@@ -2371,7 +2371,7 @@ void tst_QtJson::valueEquals()
     QVERIFY(QJsonValue(QJsonArray()) != QJsonValue(1.));
     QVERIFY(QJsonValue(QJsonArray()) != QJsonValue(QJsonObject()));
 
-    QVERIFY(QJsonValue(QJsonObject()) == QJsonValue(QJsonObject()));
+    QCOMPARE(QJsonValue(QJsonObject()), QJsonValue(QJsonObject()));
     QJsonObject nonEmptyObject;
     nonEmptyObject.insert("Key", true);
     QVERIFY(QJsonValue(QJsonObject()) != nonEmptyObject);
@@ -2381,13 +2381,13 @@ void tst_QtJson::valueEquals()
     QVERIFY(QJsonValue(QJsonObject()) != QJsonValue(1.));
     QVERIFY(QJsonValue(QJsonObject()) != QJsonValue(QJsonArray()));
 
-    QVERIFY(QJsonValue("foo") == QJsonValue(QLatin1String("foo")));
+    QCOMPARE(QJsonValue("foo"), QJsonValue(QLatin1String("foo")));
-    QVERIFY(QJsonValue("foo") == QJsonValue(QString("foo")));
+    QCOMPARE(QJsonValue("foo"), QJsonValue(QString("foo")));
-    QVERIFY(QJsonValue("\x66\x6f\x6f") == QJsonValue(QString("foo")));
+    QCOMPARE(QJsonValue("\x66\x6f\x6f"), QJsonValue(QString("foo")));
-    QVERIFY(QJsonValue("\x62\x61\x72") == QJsonValue("bar"));
+    QCOMPARE(QJsonValue("\x62\x61\x72"), QJsonValue("bar"));
-    QVERIFY(QJsonValue(UNICODE_NON_CHARACTER) == QJsonValue(QString(UNICODE_NON_CHARACTER)));
+    QCOMPARE(QJsonValue(UNICODE_NON_CHARACTER), QJsonValue(QString(UNICODE_NON_CHARACTER)));
-    QVERIFY(QJsonValue(UNICODE_DJE) == QJsonValue(QString(UNICODE_DJE)));
+    QCOMPARE(QJsonValue(UNICODE_DJE), QJsonValue(QString(UNICODE_DJE)));
-    QVERIFY(QJsonValue("\xc3\xa9") == QJsonValue(QString("\xc3\xa9")));
+    QCOMPARE(QJsonValue("\xc3\xa9"), QJsonValue(QString("\xc3\xa9")));
 }
 
 void tst_QtJson::objectEquals_data()
@@ -2521,7 +2521,7 @@ void tst_QtJson::bom()
     QJsonDocument doc = QJsonDocument::fromJson(json, &error);
 
     QVERIFY(!doc.isNull());
-    QVERIFY(error.error == QJsonParseError::NoError);
+    QCOMPARE(error.error, QJsonParseError::NoError);
 }
 
 void tst_QtJson::nesting()
@@ -2553,14 +2553,14 @@ void tst_QtJson::nesting()
     QJsonDocument doc = QJsonDocument::fromJson(json, &error);
 
     QVERIFY(!doc.isNull());
-    QVERIFY(error.error == QJsonParseError::NoError);
+    QCOMPARE(error.error, QJsonParseError::NoError);
 
     json.prepend("[");
     json.append("]");
     doc = QJsonDocument::fromJson(json, &error);
 
     QVERIFY(doc.isNull());
-    QVERIFY(error.error == QJsonParseError::DeepNesting);
+    QCOMPARE(error.error, QJsonParseError::DeepNesting);
 
     json = QByteArray("true ");
 
@@ -2572,14 +2572,14 @@ void tst_QtJson::nesting()
     doc = QJsonDocument::fromJson(json, &error);
 
     QVERIFY(!doc.isNull());
-    QVERIFY(error.error == QJsonParseError::NoError);
+    QCOMPARE(error.error, QJsonParseError::NoError);
 
     json.prepend("[");
     json.append("]");
     doc = QJsonDocument::fromJson(json, &error);
 
     QVERIFY(doc.isNull());
-    QVERIFY(error.error == QJsonParseError::DeepNesting);
+    QCOMPARE(error.error, QJsonParseError::DeepNesting);
 
 }
 
@@ -2603,7 +2603,7 @@ void tst_QtJson::longStrings()
         QJsonDocument d2 = QJsonDocument::fromJson(a1);
         /* ... and a QByteArray from the QJsonDocument */
         QByteArray a2 = d2.toJson();
-        QVERIFY(a1 == a2);
+        QCOMPARE(a1, a2);
     }
 
     s = QString(0xfff0, 'a');
@@ -2622,7 +2622,7 @@ void tst_QtJson::longStrings()
         QJsonDocument d2 = QJsonDocument::fromJson(a1);
         /* ... and a QByteArray from the QJsonDocument */
         QByteArray a2 = d2.toJson();
-        QVERIFY(a1 == a2);
+        QCOMPARE(a1, a2);
     }
 }
 
@@ -2755,7 +2755,7 @@ void tst_QtJson::unicodeKeys()
 
     QJsonParseError error;
     QJsonDocument doc = QJsonDocument::fromJson(json, &error);
-    QVERIFY(error.error == QJsonParseError::NoError);
+    QCOMPARE(error.error, QJsonParseError::NoError);
     QJsonObject o = doc.object();
 
     QCOMPARE(o.keys().size(), 5);
@@ -2769,12 +2769,12 @@ void tst_QtJson::garbageAtEnd()
 {
     QJsonParseError error;
     QJsonDocument doc = QJsonDocument::fromJson("{},", &error);
-    QVERIFY(error.error == QJsonParseError::GarbageAtEnd);
+    QCOMPARE(error.error, QJsonParseError::GarbageAtEnd);
-    QVERIFY(error.offset == 2);
+    QCOMPARE(error.offset, 2);
     QVERIFY(doc.isEmpty());
 
     doc = QJsonDocument::fromJson("{}    ", &error);
-    QVERIFY(error.error == QJsonParseError::NoError);
+    QCOMPARE(error.error, QJsonParseError::NoError);
     QVERIFY(!doc.isEmpty());
 }
 

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

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());
+    QCOMPARE(parameterTypes.size(), parameterTypeNames.size());
-    QVERIFY(parameterTypes.size() == parameterNames.size());
+    QCOMPARE(parameterTypes.size(), parameterNames.size());
 
     const QMetaObject *mo = &MethodTestObject::staticMetaObject;
     int index = (methodType == QMetaMethod::Constructor)

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;

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);
+    QCOMPARE(builder.relatedMetaObject(0), &QObject::staticMetaObject);
-    QVERIFY(builder.relatedMetaObject(1) == &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);
 

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);
+    QCOMPARE(variant100, variant100x);
-    QVERIFY(variant100 == variant100);
+    QCOMPARE(variant100, variant100);
 
     // compare always fails
     QVERIFY(!(variant50 < variant50));

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

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);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Protected);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Protected);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Private);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Method);
-    QVERIFY(m.access() == QMetaMethod::Private);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Signal);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    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);
+    QCOMPARE(m.methodType(), QMetaMethod::Slot);
-    QVERIFY(m.access() == QMetaMethod::Public);
+    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);
+    QCOMPARE(v.userType(), int(QMetaType::Float));
-    QVERIFY(qvariant_cast<float>(v) == 128.0f);
+    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
 }

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());
+    QCOMPARE(sm.errorString(), QString());
-    QVERIFY(sm.data() == 0);
+    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.data());
-        QVERIFY(sm.size() == 0);
+        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());

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);
+    QCOMPARE(target.id, 2);
-    QVERIFY(target.str == "two");
+    QCOMPARE(target.str, QLatin1String("two"));
 
     src3.emit_mysignal(20);
-    QVERIFY(target.id == 2);
+    QCOMPARE(target.id, 2);
-    QVERIFY(target.str == "three");
+    QCOMPARE(target.str, QLatin1String("three"));
 }
 
 QTEST_MAIN(tst_QSignalMapper)

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);
+    QCOMPARE(readEnd1.state(), QAbstractSocket::ConnectedState);
-    QVERIFY(readEnd2.state() == QAbstractSocket::ConnectedState);
+    QCOMPARE(readEnd2.state(), QAbstractSocket::ConnectedState);
 
     QCOMPARE(tester.sequence, 2);
 

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
 }
 

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

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);
+    QCOMPARE(variant1, variant1);
-    QVERIFY(variant2 == variant2);
+    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);

tests/auto/corelib/plugin/quuid/tst_quuid.cpp

@@ -223,11 +223,11 @@ void tst_QUuid::equal()
     QVERIFY( !(uuidA == uuidB) );
 
     QUuid copy(uuidA);
-    QVERIFY(uuidA == copy);
+    QCOMPARE(uuidA, copy);
 
     QUuid assigned;
     assigned = uuidA;
-    QVERIFY(uuidA == assigned);
+    QCOMPARE(uuidA, assigned);
 }
 
 

tests/auto/corelib/statemachine/qstatemachine/tst_qstatemachine.cpp

@@ -3035,7 +3035,7 @@ void tst_QStateMachine::graphicsSceneEventTransitions()
     QVERIFY(runningSpy.isValid());
     machine.start();
     QTRY_COMPARE(startedSpy.count(), 1);
-    QVERIFY(finishedSpy.count() == 0);
+    QCOMPARE(finishedSpy.count(), 0);
     TEST_RUNNING_CHANGED(true);
     QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
     scene.sendEvent(textItem, &mouseEvent);
@@ -6157,26 +6157,26 @@ void tst_QStateMachine::childModeConstructor()
     {
         QStateMachine machine(QState::ExclusiveStates);
         QCOMPARE(machine.childMode(), QState::ExclusiveStates);
-        QVERIFY(machine.parent() == 0);
+        QVERIFY(!machine.parent());
-        QVERIFY(machine.parentState() == 0);
+        QVERIFY(!machine.parentState());
     }
     {
         QStateMachine machine(QState::ParallelStates);
         QCOMPARE(machine.childMode(), QState::ParallelStates);
-        QVERIFY(machine.parent() == 0);
+        QVERIFY(!machine.parent());
-        QVERIFY(machine.parentState() == 0);
+        QVERIFY(!machine.parentState());
     }
     {
         QStateMachine machine(QState::ExclusiveStates, this);
         QCOMPARE(machine.childMode(), QState::ExclusiveStates);
         QCOMPARE(machine.parent(), static_cast<QObject *>(this));
-        QVERIFY(machine.parentState() == 0);
+        QVERIFY(!machine.parentState());
     }
     {
         QStateMachine machine(QState::ParallelStates, this);
         QCOMPARE(machine.childMode(), QState::ParallelStates);
         QCOMPARE(machine.parent(), static_cast<QObject *>(this));
-        QVERIFY(machine.parentState() == 0);
+        QVERIFY(!machine.parentState());
     }
     QState state;
     {

tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp

@@ -123,15 +123,15 @@ void tst_QAtomicPointer::constructor()
 {
     void *one = this;
     QAtomicPointer<void> atomic1 = one;
-    QVERIFY(atomic1.load() == one);
+    QCOMPARE(atomic1.load(), one);
 
     void *two = &one;
     QAtomicPointer<void> atomic2 = two;
-    QVERIFY(atomic2.load() == two);
+    QCOMPARE(atomic2.load(), two);
 
     void *three = &two;
     QAtomicPointer<void> atomic3 = three;
-    QVERIFY(atomic3.load() == three);
+    QCOMPARE(atomic3.load(), three);
 }
 
 void tst_QAtomicPointer::copy_constructor()
@@ -139,19 +139,19 @@ void tst_QAtomicPointer::copy_constructor()
     void *one = this;
     QAtomicPointer<void> atomic1 = one;
     QAtomicPointer<void> atomic1_copy = atomic1;
-    QVERIFY(atomic1_copy.load() == one);
+    QCOMPARE(atomic1_copy.load(), one);
     QCOMPARE(atomic1_copy.load(), atomic1.load());
 
     void *two = &one;
     QAtomicPointer<void> atomic2 = two;
     QAtomicPointer<void> atomic2_copy = atomic2;
-    QVERIFY(atomic2_copy.load() == two);
+    QCOMPARE(atomic2_copy.load(), two);
     QCOMPARE(atomic2_copy.load(), atomic2.load());
 
     void *three = &two;
     QAtomicPointer<void> atomic3 = three;
     QAtomicPointer<void> atomic3_copy = atomic3;
-    QVERIFY(atomic3_copy.load() == three);
+    QCOMPARE(atomic3_copy.load(), three);
     QCOMPARE(atomic3_copy.load(), atomic3.load());
 }
 
@@ -165,17 +165,17 @@ void tst_QAtomicPointer::assignment_operator()
     QAtomicPointer<void> atomic2 = two;
     QAtomicPointer<void> atomic3 = three;
 
-    QVERIFY(atomic1.load() == one);
+    QCOMPARE(atomic1.load(), one);
-    QVERIFY(atomic2.load() == two);
+    QCOMPARE(atomic2.load(), two);
-    QVERIFY(atomic3.load() == three);
+    QCOMPARE(atomic3.load(), three);
 
     atomic1 = two;
     atomic2 = three;
     atomic3 = one;
 
-    QVERIFY(atomic1.load() == two);
+    QCOMPARE(atomic1.load(), two);
-    QVERIFY(atomic2.load() == three);
+    QCOMPARE(atomic2.load(), three);
-    QVERIFY(atomic3.load() == one);
+    QCOMPARE(atomic3.load(), one);
 }
 
 void tst_QAtomicPointer::isTestAndSetNative()
@@ -240,15 +240,15 @@ void tst_QAtomicPointer::testAndSet()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QVERIFY(atomic1.testAndSetRelaxed(one, two));
         QVERIFY(atomic2.testAndSetRelaxed(two, three));
         QVERIFY(atomic3.testAndSetRelaxed(three, one));
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 
     {
@@ -258,15 +258,15 @@ void tst_QAtomicPointer::testAndSet()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QVERIFY(atomic1.testAndSetAcquire(one, two));
         QVERIFY(atomic2.testAndSetAcquire(two, three));
         QVERIFY(atomic3.testAndSetAcquire(three, one));
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 
     {
@@ -276,15 +276,15 @@ void tst_QAtomicPointer::testAndSet()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QVERIFY(atomic1.testAndSetRelease(one, two));
         QVERIFY(atomic2.testAndSetRelease(two, three));
         QVERIFY(atomic3.testAndSetRelease(three, one));
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 
     {
@@ -294,15 +294,15 @@ void tst_QAtomicPointer::testAndSet()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QVERIFY(atomic1.testAndSetOrdered(one, two));
         QVERIFY(atomic2.testAndSetOrdered(two, three));
         QVERIFY(atomic3.testAndSetOrdered(three, one));
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 }
 
@@ -368,15 +368,15 @@ void tst_QAtomicPointer::fetchAndStore()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QCOMPARE(atomic1.fetchAndStoreRelaxed(two), one);
         QCOMPARE(atomic2.fetchAndStoreRelaxed(three), two);
         QCOMPARE(atomic3.fetchAndStoreRelaxed(one), three);
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 
     {
@@ -386,15 +386,15 @@ void tst_QAtomicPointer::fetchAndStore()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QCOMPARE(atomic1.fetchAndStoreAcquire(two), one);
         QCOMPARE(atomic2.fetchAndStoreAcquire(three), two);
         QCOMPARE(atomic3.fetchAndStoreAcquire(one), three);
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 
     {
@@ -404,15 +404,15 @@ void tst_QAtomicPointer::fetchAndStore()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QCOMPARE(atomic1.fetchAndStoreRelease(two), one);
         QCOMPARE(atomic2.fetchAndStoreRelease(three), two);
         QCOMPARE(atomic3.fetchAndStoreRelease(one), three);
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 
     {
@@ -422,15 +422,15 @@ void tst_QAtomicPointer::fetchAndStore()
 
         QCOMPARE(atomic1.load(), one);
         QCOMPARE(atomic2.load(), two);
-        QVERIFY(atomic3.load() == three);
+        QCOMPARE(atomic3.load(), three);
 
         QCOMPARE(atomic1.fetchAndStoreOrdered(two), one);
         QCOMPARE(atomic2.fetchAndStoreOrdered(three), two);
         QCOMPARE(atomic3.fetchAndStoreOrdered(one), three);
 
-        QVERIFY(atomic1.load() == two);
+        QCOMPARE(atomic1.load(), two);
-        QVERIFY(atomic2.load() == three);
+        QCOMPARE(atomic2.load(), three);
-        QVERIFY(atomic3.load() == one);
+        QCOMPARE(atomic3.load(), one);
     }
 }
 

tests/auto/corelib/thread/qfuture/tst_qfuture.cpp

@@ -84,9 +84,9 @@ void tst_QFuture::resultStore()
 
     {
         QtPrivate::ResultStore<int> store;
-        QVERIFY(store.begin() == store.end());
+        QCOMPARE(store.begin(), store.end());
-        QVERIFY(store.resultAt(0) == store.end());
+        QCOMPARE(store.resultAt(0), store.end());
-        QVERIFY(store.resultAt(1) == store.end());
+        QCOMPARE(store.resultAt(1), store.end());
     }
 
 
@@ -118,7 +118,7 @@ void tst_QFuture::resultStore()
         store.addResults(-1, &vec1, 2, 2);
         QtPrivate::ResultIteratorBase it = store.begin();
         QCOMPARE(it.resultIndex(), 0);
-        QVERIFY(it == store.begin());
+        QCOMPARE(it, store.begin());
         QVERIFY(it != store.end());
 
         ++it;
@@ -133,7 +133,7 @@ void tst_QFuture::resultStore()
         QCOMPARE(it.resultIndex(), 3);
 
         ++it;
-        QVERIFY(it == store.end());
+        QCOMPARE(it, store.end());
     }
     {
         QtPrivate::ResultStoreBase store;
@@ -1012,14 +1012,14 @@ void tst_QFuture::iterators()
         QFuture<int>::const_iterator i1 = f.begin(), i2 = i1 + 1;
         QFuture<int>::const_iterator c1 = i1, c2 = c1 + 1;
 
-        QVERIFY(i1 == i1);
+        QCOMPARE(i1, i1);
-        QVERIFY(i1 == c1);
+        QCOMPARE(i1, c1);
-        QVERIFY(c1 == i1);
+        QCOMPARE(c1, i1);
-        QVERIFY(c1 == c1);
+        QCOMPARE(c1, c1);
-        QVERIFY(i2 == i2);
+        QCOMPARE(i2, i2);
-        QVERIFY(i2 == c2);
+        QCOMPARE(i2, c2);
-        QVERIFY(c2 == i2);
+        QCOMPARE(c2, i2);
-        QVERIFY(c2 == c2);
+        QCOMPARE(c2, c2);
 
         QVERIFY(i1 != i2);
         QVERIFY(i1 != c2);
@@ -1061,14 +1061,14 @@ void tst_QFuture::iterators()
         QFuture<QString>::const_iterator i1 = f.begin(), i2 = i1 + 1;
         QFuture<QString>::const_iterator c1 = i1, c2 = c1 + 1;
 
-        QVERIFY(i1 == i1);
+        QCOMPARE(i1, i1);
-        QVERIFY(i1 == c1);
+        QCOMPARE(i1, c1);
-        QVERIFY(c1 == i1);
+        QCOMPARE(c1, i1);
-        QVERIFY(c1 == c1);
+        QCOMPARE(c1, c1);
-        QVERIFY(i2 == i2);
+        QCOMPARE(i2, i2);
-        QVERIFY(i2 == c2);
+        QCOMPARE(i2, c2);
-        QVERIFY(c2 == i2);
+        QCOMPARE(c2, i2);
-        QVERIFY(c2 == c2);
+        QCOMPARE(c2, c2);
 
         QVERIFY(i1 != i2);
         QVERIFY(i1 != c2);

tests/auto/corelib/thread/qresultstore/tst_qresultstore.cpp

@@ -80,9 +80,9 @@ void tst_QtConcurrentResultStore::iterators()
 {
     {
         ResultStore<int> store;
-        QVERIFY(store.begin() == store.end());
+        QCOMPARE(store.begin(), store.end());
-        QVERIFY(store.resultAt(0) == store.end());
+        QCOMPARE(store.resultAt(0), store.end());
-        QVERIFY(store.resultAt(1) == store.end());
+        QCOMPARE(store.resultAt(1), store.end());
     }
     {
         ResultStoreBase storebase;
@@ -90,7 +90,7 @@ void tst_QtConcurrentResultStore::iterators()
         storebase.addResult(1, &int1);  // ResultStoreBase does not take ownership, only ResultStore<> does.
         ResultIteratorBase it = storebase.begin();
         QCOMPARE(it.resultIndex(), 0);
-        QVERIFY(it == storebase.begin());
+        QCOMPARE(it, storebase.begin());
         QVERIFY(it != storebase.end());
 
         ++it;
@@ -100,7 +100,7 @@ void tst_QtConcurrentResultStore::iterators()
 
         ++it;
         QVERIFY(it != storebase.begin());
-        QVERIFY(it == storebase.end());
+        QCOMPARE(it, storebase.end());
     }
 }
 
@@ -160,7 +160,7 @@ void tst_QtConcurrentResultStore::addResults()
     store.addResults(-1, &vec1, 2, 2);
     ResultIteratorBase it = store.begin();
     QCOMPARE(it.resultIndex(), 0);
-    QVERIFY(it == store.begin());
+    QCOMPARE(it, store.begin());
     QVERIFY(it != store.end());
 
     ++it;
@@ -175,7 +175,7 @@ void tst_QtConcurrentResultStore::addResults()
     QCOMPARE(it.resultIndex(), 3);
 
     ++it;
-    QVERIFY(it == store.end());
+    QCOMPARE(it, store.end());
 }
 
 void tst_QtConcurrentResultStore::resultIndex()

tests/auto/corelib/thread/qthreadonce/tst_qthreadonce.cpp

@@ -163,7 +163,7 @@ void tst_QThreadOnce::nesting()
         }
     }
 
-    QVERIFY(variable == 1);
+    QCOMPARE(variable, 1);
 }
 
 static void reentrant(int control, int &counter)

tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp

@@ -877,13 +877,13 @@ void tst_QXmlStream::testFalsePrematureError() const
         while (!xml.atEnd()) {
             xml.readNext();
         }
-        QVERIFY(xml.error() == QXmlStreamReader::PrematureEndOfDocumentError);
+        QCOMPARE(xml.error(), QXmlStreamReader::PrematureEndOfDocumentError);
         QCOMPARE(xml.errorString(), QLatin1String("Premature end of document."));
         xml.addData(legal_start);
         while (!xml.atEnd()) {
             xml.readNext();
         }
-        QVERIFY(xml.error() == QXmlStreamReader::PrematureEndOfDocumentError);
+        QCOMPARE(xml.error(), QXmlStreamReader::PrematureEndOfDocumentError);
         QCOMPARE(xml.errorString(), QLatin1String("Premature end of document."));
         xml.addData(end);
         while (!xml.atEnd()) {
@@ -898,7 +898,7 @@ void tst_QXmlStream::testFalsePrematureError() const
         }
         QVERIFY(xml.hasError());
         QCOMPARE(xml.errorString(), QLatin1String("Start tag expected."));
-        QVERIFY(xml.error() == QXmlStreamReader::NotWellFormedError);
+        QCOMPARE(xml.error(), QXmlStreamReader::NotWellFormedError);
     }
 }