1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
- 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>
This commit is contained in:
Friedemann Kleint 2015-07-24 15:39:39 +02:00
parent 933745f36b
commit 752c0d7de0
48 changed files with 571 additions and 571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/auto/corelib/animation/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
View File

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

96
tests/auto/corelib/animation/qpauseanimation/tst_qpauseanimation.cpp
View File

@ -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);
QVERIFY(pause.state() == QAbstractAnimation::Running);
QCOMPARE(animation.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);
QVERIFY(pause.state() == QAbstractAnimation::Stopped);
QCOMPARE(animation.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);
QVERIFY(animation1.state() == QAbstractAnimation::Running);
QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Running);
QCOMPARE(animation1.state(), QAbstractAnimation::Running);
QCOMPARE(animation2.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);
QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Running);
QCOMPARE(animation1.state(), QAbstractAnimation::Stopped);
QCOMPARE((QAbstractAnimation*)&animation2, group.currentAnimation());
QVERIFY(animation2.state() == QAbstractAnimation::Running);
QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
QCOMPARE(animation2.state(), QAbstractAnimation::Running);
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);
QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Running);
QCOMPARE(animation1.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);
QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Stopped);
QCOMPARE(animation1.state(), QAbstractAnimation::Stopped);
QCOMPARE(animation2.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);
QVERIFY(animation.state() == QAbstractAnimation::Running);
QVERIFY(pause.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Running);
QCOMPARE(animation.state(), QAbstractAnimation::Running);
QCOMPARE(pause.state(), QAbstractAnimation::Stopped);
group.setCurrentTime(300);
QVERIFY(group.state() == QAbstractAnimation::Running);
QVERIFY(animation.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Running);
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);
QVERIFY(animation.state() == QAbstractAnimation::Stopped);
QVERIFY(pause.state() == QAbstractAnimation::Stopped);
QCOMPARE(group.state(), QAbstractAnimation::Stopped);
QCOMPARE(animation.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);
QVERIFY(subgroup1.state() == QAbstractAnimation::Running);
QVERIFY(subgroup2.state() == QAbstractAnimation::Running);
QVERIFY(subgroup3.state() == QAbstractAnimation::Running);
QVERIFY(subgroup4.state() == QAbstractAnimation::Running);
QCOMPARE(group.state(), QAbstractAnimation::Running);
QCOMPARE(subgroup1.state(), QAbstractAnimation::Running);
QCOMPARE(subgroup2.state(), QAbstractAnimation::Running);
QCOMPARE(subgroup3.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);
}

2
tests/auto/corelib/animation/qpropertyanimation/tst_qpropertyanimation.cpp
View File

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

6
tests/auto/corelib/animation/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
View File

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

4
tests/auto/corelib/animation/qvariantanimation/tst_qvariantanimation.cpp
View File

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

4
tests/auto/corelib/codecs/qtextcodec/tst_qtextcodec.cpp
View File

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

2
tests/auto/corelib/global/qgetputenv/tst_qgetputenv.cpp
View File

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

2
tests/auto/corelib/io/qbuffer/tst_qbuffer.cpp
View File

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

92
tests/auto/corelib/io/qdatastream/tst_qdatastream.cpp
View File

@ -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());
QVERIFY(d12.isNull() == ref.isNull());
QVERIFY(d12.width() == ref.width());
QVERIFY(d12.height() == ref.height());
QVERIFY(d12.depth() == ref.depth());
QVERIFY(d12.colorCount() == ref.colorCount());
QVERIFY(d12.hasAlphaChannel() == ref.hasAlphaChannel());
QCOMPARE(d12.size(), ref.size());
QCOMPARE(d12.isNull(), ref.isNull());
QCOMPARE(d12.width(), ref.width());
QCOMPARE(d12.height(), ref.height());
QCOMPARE(d12.depth(), ref.depth());
QCOMPARE(d12.colorCount(), ref.colorCount());
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());
QVERIFY(d15.joinStyle() == origPen.joinStyle());
QVERIFY(d15 == origPen);
QCOMPARE(d15.capStyle(), origPen.capStyle());
QCOMPARE(d15.joinStyle(), origPen.joinStyle());
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());
QVERIFY(d16.height() == pm.height());
QVERIFY(d16.size() == pm.size());
QVERIFY(d16.rect() == pm.rect());
QVERIFY(d16.depth() == pm.depth());
QCOMPARE(d16.width(), pm.width());
QCOMPARE(d16.height(), pm.height());
QCOMPARE(d16.size(), pm.size());
QCOMPARE(d16.rect(), pm.rect());
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);
QVERIFY(pal2 == inPal2);
QCOMPARE(pal1, inPal1);
QCOMPARE(pal2, inPal2);
}
}
}
@ -3060,9 +3060,9 @@ void tst_QDataStream::compatibility_Qt3()
in >> in_palette;
in >> in_brush;
}
QVERIFY(in_brush.style() == Qt::NoBrush);
QVERIFY(in_palette.brush(QPalette::Button).style() == Qt::NoBrush);
QVERIFY(in_palette.color(QPalette::Light) == Qt::green);
QCOMPARE(in_brush.style(), Qt::NoBrush);
QCOMPARE(in_palette.brush(QPalette::Button).style(), Qt::NoBrush);
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);
QVERIFY(in_palette.brush(QPalette::Button).style() == Qt::NoBrush);
QVERIFY(in_palette.color(QPalette::Light) == Qt::green);
QCOMPARE(in_brush.style(), Qt::NoBrush);
QCOMPARE(in_palette.brush(QPalette::Button).style(), Qt::NoBrush);
QCOMPARE(in_palette.color(QPalette::Light), QColor(Qt::green));
}
void tst_QDataStream::floatingPointNaN()

8
tests/auto/corelib/io/qdir/tst_qdir.cpp
View File

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

2
tests/auto/corelib/io/qdiriterator/tst_qdiriterator.cpp
View File

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

30
tests/auto/corelib/io/qfile/tst_qfile.cpp
View File

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

2
tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
View File

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

10
tests/auto/corelib/io/qprocess/tst_qprocess.cpp
View File

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

14
tests/auto/corelib/io/qprocessenvironment/tst_qprocessenvironment.cpp
View File

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

90
tests/auto/corelib/io/qsettings/tst_qsettings.cpp
View File

@ -291,8 +291,8 @@ void tst_QSettings::initTestCase()
, Qt::CaseInsensitive
#endif
);
QVERIFY(custom1 == QSettings::CustomFormat1);
QVERIFY(custom2 == QSettings::CustomFormat2);
QCOMPARE(custom1, QSettings::CustomFormat1);
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);
QVERIFY(settings2.format() == format);
QVERIFY(settings3.format() == format);
QVERIFY(settings4.format() == format);
QCOMPARE(settings1.format(), format);
QCOMPARE(settings2.format(), format);
QCOMPARE(settings3.format(), format);
QCOMPARE(settings4.format(), format);
// test QSettings::scope() while we're at it
QVERIFY(settings1.scope() == QSettings::UserScope);
QVERIFY(settings2.scope() == QSettings::UserScope);
QVERIFY(settings3.scope() == QSettings::SystemScope);
QVERIFY(settings4.scope() == QSettings::SystemScope);
QCOMPARE(settings1.scope(), QSettings::UserScope);
QCOMPARE(settings2.scope(), QSettings::UserScope);
QCOMPARE(settings3.scope(), QSettings::SystemScope);
QCOMPARE(settings4.scope(), QSettings::SystemScope);
// test QSettings::organizationName() while we're at it
QVERIFY(settings1.organizationName() == "software.org");
QVERIFY(settings2.organizationName() == "software.org");
QVERIFY(settings3.organizationName() == "software.org");
QVERIFY(settings4.organizationName() == "software.org");
QCOMPARE(settings1.organizationName(), QLatin1String("software.org"));
QCOMPARE(settings2.organizationName(), QLatin1String("software.org"));
QCOMPARE(settings3.organizationName(), QLatin1String("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);
QVERIFY(settings2.format() == format);
QCOMPARE(settings.format(), format);
QCOMPARE(settings2.format(), format);
// test QSettings::scope() while we're at it
QVERIFY(settings.scope() == QSettings::UserScope);
QVERIFY(settings2.scope() == QSettings::UserScope);
QCOMPARE(settings.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);
QVERIFY(settings2.format() == QSettings::NativeFormat);
QVERIFY(settings3.format() == QSettings::CustomFormat1);
QCOMPARE(settings1.format(), QSettings::NativeFormat);
QCOMPARE(settings2.format(), QSettings::NativeFormat);
QCOMPARE(settings3.format(), QSettings::CustomFormat1);
QSettings::setDefaultFormat(QSettings::NativeFormat);
QVERIFY(QSettings::defaultFormat() == QSettings::NativeFormat);
QCOMPARE(QSettings::defaultFormat(), QSettings::NativeFormat);
QVERIFY(settings1.format() == QSettings::NativeFormat);
QVERIFY(settings2.format() == QSettings::NativeFormat);
QVERIFY(settings3.format() == QSettings::CustomFormat1);
QCOMPARE(settings1.format(), QSettings::NativeFormat);
QCOMPARE(settings2.format(), QSettings::NativeFormat);
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);

20
tests/auto/corelib/io/qstorageinfo/tst_qstorageinfo.cpp
View File

@ -61,9 +61,9 @@ void tst_QStorageInfo::defaultValues()
QVERIFY(!storage.isRoot());
QVERIFY(storage.device().isEmpty());
QVERIFY(storage.fileSystemType().isEmpty());
QVERIFY(storage.bytesTotal() == -1);
QVERIFY(storage.bytesFree() == -1);
QVERIFY(storage.bytesAvailable() == -1);
QCOMPARE(storage.bytesTotal(), -1);
QCOMPARE(storage.bytesFree(), -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());
QVERIFY(free == storage2.bytesFree());
QCOMPARE(free, storage1.bytesFree());
QCOMPARE(free, storage2.bytesFree());
storage2.refresh();
QVERIFY(storage1 == storage2);
QCOMPARE(storage1, storage2);
QVERIFY(free != storage2.bytesFree());
}
#endif

2
tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
View File

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

20
tests/auto/corelib/io/qurl/tst_qurl.cpp
View File

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

24
tests/auto/corelib/io/qurlquery/tst_qurlquery.cpp
View File

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

4
tests/auto/corelib/io/qwinoverlappedionotifier/tst_qwinoverlappedionotifier.cpp
View File

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

38
tests/auto/corelib/itemmodels/qabstractitemmodel/tst_qabstractitemmodel.cpp
View File

@ -1699,8 +1699,8 @@ void tst_QAbstractItemModel::testMoveToDescendants()
moveCommand->setDestRow(row);
moveCommand->doCommand();
QVERIFY(beforeSpy.size() == 0);
QVERIFY(afterSpy.size() == 0);
QCOMPARE(beforeSpy.size(), 0);
QCOMPARE(afterSpy.size(), 0);
}
}
}
@ -1757,8 +1757,8 @@ void tst_QAbstractItemModel::testMoveWithinOwnRange()
moveCommand->setDestRow(destRow);
moveCommand->doCommand();
QVERIFY(beforeSpy.size() == 0);
QVERIFY(afterSpy.size() == 0);
QCOMPARE(beforeSpy.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);
QVERIFY(afterResetSpy.size() == 1);
QCOMPARE(beforeResetSpy.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);
QVERIFY(proxyAfterResetSpy.size() == 1);
QCOMPARE(proxyBeforeResetSpy.size(), 1);
QCOMPARE(proxyAfterResetSpy.size(), 1);
QCOMPARE(nullProxy->roleNames().value(Qt::UserRole + 1), QByteArray("custom"));
nullProxy->setSourceModel(m_model);
QVERIFY(proxyBeforeResetSpy.size() == 2);
QVERIFY(proxyAfterResetSpy.size() == 2);
QCOMPARE(proxyBeforeResetSpy.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);
QVERIFY(p1LastPersistent.row() == 0);
QVERIFY(p2FirstPersistent.row() == 9);
QVERIFY(p2LastPersistent.row() == 8);
QCOMPARE(p1FirstPersistent.row(), 1);
QCOMPARE(p1LastPersistent.row(), 0);
QCOMPARE(p2FirstPersistent.row(), 9);
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);
QVERIFY(p1LastPersistent.row() == 0);
QCOMPARE(p1FirstPersistent.row(), 1);
QCOMPARE(p1LastPersistent.row(), 0);
QCOMPARE(p2FirstPersistent.row(), 9);
QCOMPARE(p2LastPersistent.row(), 8);
}

2
tests/auto/corelib/itemmodels/qabstractproxymodel/tst_qabstractproxymodel.cpp
View File

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

68
tests/auto/corelib/itemmodels/qidentityproxymodel/tst_qidentityproxymodel.cpp
View File

@ -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);
QVERIFY(rows == m_proxy->rowCount(proxyParent));
QVERIFY(columns == m_proxy->columnCount(proxyParent));
QCOMPARE(m_proxy->mapToSource(proxyParent), parent);
QCOMPARE(rows, m_proxy->rowCount(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);
QVERIFY(m_proxy->mapToSource(proxyIdx) == idx);
QCOMPARE(proxyIdx.model(), m_proxy);
QCOMPARE(m_proxy->mapToSource(proxyIdx), idx);
QVERIFY(proxyIdx.isValid());
QVERIFY(proxyIdx.row() == row);
QVERIFY(proxyIdx.column() == column);
QVERIFY(proxyIdx.parent() == proxyParent);
QVERIFY(proxyIdx.data() == idx.data());
QVERIFY(proxyIdx.flags() == idx.flags());
QCOMPARE(proxyIdx.row(), row);
QCOMPARE(proxyIdx.column(), column);
QCOMPARE(proxyIdx.parent(), proxyParent);
QCOMPARE(proxyIdx.data(), idx.data());
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>()));
QVERIFY(modelBeforeSpy.first().at(1) == proxyBeforeSpy.first().at(1));
QVERIFY(modelBeforeSpy.first().at(2) == proxyBeforeSpy.first().at(2));
QCOMPARE(modelBeforeSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
QCOMPARE(modelBeforeSpy.first().at(1), proxyBeforeSpy.first().at(1));
QCOMPARE(modelBeforeSpy.first().at(2), proxyBeforeSpy.first().at(2));
QVERIFY(modelAfterSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
QVERIFY(modelAfterSpy.first().at(1) == proxyAfterSpy.first().at(1));
QVERIFY(modelAfterSpy.first().at(2) == proxyAfterSpy.first().at(2));
QCOMPARE(modelAfterSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
QCOMPARE(modelAfterSpy.first().at(1), proxyAfterSpy.first().at(1));
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>()));
QVERIFY(modelBeforeSpy.first().at(1) == proxyBeforeSpy.first().at(1));
QVERIFY(modelBeforeSpy.first().at(2) == proxyBeforeSpy.first().at(2));
QCOMPARE(modelBeforeSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
QCOMPARE(modelBeforeSpy.first().at(1), proxyBeforeSpy.first().at(1));
QCOMPARE(modelBeforeSpy.first().at(2), proxyBeforeSpy.first().at(2));
QVERIFY(modelAfterSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
QVERIFY(modelAfterSpy.first().at(1) == proxyAfterSpy.first().at(1));
QVERIFY(modelAfterSpy.first().at(2) == proxyAfterSpy.first().at(2));
QCOMPARE(modelAfterSpy.first().first().value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
QCOMPARE(modelAfterSpy.first().at(1), proxyAfterSpy.first().at(1));
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>()));
QVERIFY(modelBeforeSpy.first().at(1) == proxyBeforeSpy.first().at(1));
QVERIFY(modelBeforeSpy.first().at(2) == proxyBeforeSpy.first().at(2));
QVERIFY(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().first().value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().first().value<QModelIndex>()));
QCOMPARE(modelBeforeSpy.first().at(1), proxyBeforeSpy.first().at(1));
QCOMPARE(modelBeforeSpy.first().at(2), proxyBeforeSpy.first().at(2));
QCOMPARE(modelBeforeSpy.first().at(3).value<QModelIndex>(), m_proxy->mapToSource(proxyBeforeSpy.first().at(3).value<QModelIndex>()));
QCOMPARE(modelBeforeSpy.first().at(4), proxyBeforeSpy.first().at(4));
QVERIFY(modelAfterSpy.first().first().value<QModelIndex>() == m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
QVERIFY(modelAfterSpy.first().at(1) == proxyAfterSpy.first().at(1));
QVERIFY(modelAfterSpy.first().at(2) == proxyAfterSpy.first().at(2));
QVERIFY(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().first().value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().first().value<QModelIndex>()));
QCOMPARE(modelAfterSpy.first().at(1), proxyAfterSpy.first().at(1));
QCOMPARE(modelAfterSpy.first().at(2), proxyAfterSpy.first().at(2));
QCOMPARE(modelAfterSpy.first().at(3).value<QModelIndex>(), m_proxy->mapToSource(proxyAfterSpy.first().at(3).value<QModelIndex>()));
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);

6
tests/auto/corelib/itemmodels/qitemmodel/tst_qitemmodel.cpp
View File

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

32
tests/auto/corelib/itemmodels/qitemselectionmodel/tst_qitemselectionmodel.cpp
View File

@ -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());
QVERIFY(selectedIndexes.size() == 1);
QCOMPARE(selectedIndexes.size(), duplicatedIndexes.size());
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());
QVERIFY(selectedIndexes.size() == 0);
QCOMPARE(selectedIndexes.size(), duplicatedIndexes.size());
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);
QVERIFY(currentIndexSpy.size() == 1);
QCOMPARE(selectionModel.currentIndex(), firstIndex);
QCOMPARE(currentIndexSpy.size(), 1);
selectionModel.clearCurrentIndex();
QVERIFY(selectionModel.currentIndex() == QModelIndex());
QVERIFY(currentIndexSpy.size() == 2);
QCOMPARE(selectionModel.currentIndex(), QModelIndex());
QCOMPARE(currentIndexSpy.size(), 2);
}
QTEST_MAIN(tst_QItemSelectionModel)

32
tests/auto/corelib/itemmodels/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
View File

@ -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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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);
QVERIFY(args.at(2).type() == QVariant::Int);
QCOMPARE(args.at(1).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));
}

90
tests/auto/corelib/json/tst_qtjson.cpp
View File

@ -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);
QVERIFY(it == object.end());
QCOMPARE((*it).type(), QJsonValue::Undefined);
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);
QVERIFY(it == object.end());
QCOMPARE((*it).type(), QJsonValue::Undefined);
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);
QVERIFY(doc.array() == QJsonArray());
QCOMPARE(doc.object(), object);
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);
QVERIFY(doc.object() == QJsonObject());
QCOMPARE(doc.array(), array);
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());
QVERIFY(doc == bdoc);
QCOMPARE(doc.toVariant(), bdoc.toVariant());
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")));
QVERIFY(QJsonValue("foo") == QJsonValue(QString("foo")));
QVERIFY(QJsonValue("\x66\x6f\x6f") == QJsonValue(QString("foo")));
QVERIFY(QJsonValue("\x62\x61\x72") == QJsonValue("bar"));
QVERIFY(QJsonValue(UNICODE_NON_CHARACTER) == QJsonValue(QString(UNICODE_NON_CHARACTER)));
QVERIFY(QJsonValue(UNICODE_DJE) == QJsonValue(QString(UNICODE_DJE)));
QVERIFY(QJsonValue("\xc3\xa9") == QJsonValue(QString("\xc3\xa9")));
QCOMPARE(QJsonValue("foo"), QJsonValue(QLatin1String("foo")));
QCOMPARE(QJsonValue("foo"), QJsonValue(QString("foo")));
QCOMPARE(QJsonValue("\x66\x6f\x6f"), QJsonValue(QString("foo")));
QCOMPARE(QJsonValue("\x62\x61\x72"), QJsonValue("bar"));
QCOMPARE(QJsonValue(UNICODE_NON_CHARACTER), QJsonValue(QString(UNICODE_NON_CHARACTER)));
QCOMPARE(QJsonValue(UNICODE_DJE), QJsonValue(QString(UNICODE_DJE)));
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);
QVERIFY(error.offset == 2);
QCOMPARE(error.error, QJsonParseError::GarbageAtEnd);
QCOMPARE(error.offset, 2);
QVERIFY(doc.isEmpty());
doc = QJsonDocument::fromJson("{} ", &error);
QVERIFY(error.error == QJsonParseError::NoError);
QCOMPARE(error.error, QJsonParseError::NoError);
QVERIFY(!doc.isEmpty());
}

6
tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
View File

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

4
tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
View File

@ -599,8 +599,8 @@ void tst_QMetaMethod::method()
QFETCH(QMetaMethod::MethodType, methodType);
QFETCH(QMetaMethod::Access, access);
QVERIFY(parameterTypes.size() == parameterTypeNames.size());
QVERIFY(parameterTypes.size() == parameterNames.size());
QCOMPARE(parameterTypes.size(), parameterTypeNames.size());
QCOMPARE(parameterTypes.size(), parameterNames.size());
const QMetaObject *mo = &MethodTestObject::staticMetaObject;
int index = (methodType == QMetaMethod::Constructor)

4
tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
View File

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

108
tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
View File

@ -138,14 +138,14 @@ void tst_QMetaObjectBuilder::create()
{
QMetaObjectBuilder builder;
QVERIFY(builder.className().isEmpty());
QVERIFY(builder.superClass() == &QObject::staticMetaObject);
QCOMPARE(builder.superClass(), &QObject::staticMetaObject);
QCOMPARE(builder.methodCount(), 0);
QCOMPARE(builder.constructorCount(), 0);
QCOMPARE(builder.propertyCount(), 0);
QCOMPARE(builder.enumeratorCount(), 0);
QCOMPARE(builder.classInfoCount(), 0);
QCOMPARE(builder.relatedMetaObjectCount(), 0);
QVERIFY(builder.staticMetacallFunction() == 0);
QVERIFY(!builder.staticMetacallFunction());
}
void tst_QMetaObjectBuilder::className()
@ -174,17 +174,17 @@ void tst_QMetaObjectBuilder::superClass()
// Change the super class.
builder.setSuperClass(&QObject::staticMetaObject);
QVERIFY(builder.superClass() == &QObject::staticMetaObject);
QCOMPARE(builder.superClass(), &QObject::staticMetaObject);
// Change it again.
builder.setSuperClass(&staticMetaObject);
QVERIFY(builder.superClass() == &staticMetaObject);
QCOMPARE(builder.superClass(), &staticMetaObject);
// Clone the super class off a static QMetaObject.
builder.addMetaObject(&QObject::staticMetaObject, QMetaObjectBuilder::SuperClass);
QVERIFY(builder.superClass() == 0);
QVERIFY(!builder.superClass());
builder.addMetaObject(&staticMetaObject, QMetaObjectBuilder::SuperClass);
QVERIFY(builder.superClass() == staticMetaObject.superClass());
QCOMPARE(builder.superClass(), staticMetaObject.superClass());
// Check that nothing else changed.
QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::SuperClass));
@ -195,11 +195,11 @@ void tst_QMetaObjectBuilder::flags()
QMetaObjectBuilder builder;
// Check default
QVERIFY(builder.flags() == 0);
QCOMPARE(builder.flags(), 0);
// Set flags
builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
QVERIFY(builder.flags() == QMetaObjectBuilder::DynamicMetaObject);
QCOMPARE(builder.flags(), QMetaObjectBuilder::DynamicMetaObject);
}
void tst_QMetaObjectBuilder::method()
@ -209,12 +209,12 @@ void tst_QMetaObjectBuilder::method()
// Check null method
QMetaMethodBuilder nullMethod;
QCOMPARE(nullMethod.signature(), QByteArray());
QVERIFY(nullMethod.methodType() == QMetaMethod::Method);
QCOMPARE(nullMethod.methodType(), QMetaMethod::Method);
QVERIFY(nullMethod.returnType().isEmpty());
QVERIFY(nullMethod.parameterTypes().isEmpty());
QVERIFY(nullMethod.parameterNames().isEmpty());
QVERIFY(nullMethod.tag().isEmpty());
QVERIFY(nullMethod.access() == QMetaMethod::Public);
QCOMPARE(nullMethod.access(), QMetaMethod::Public);
QCOMPARE(nullMethod.attributes(), 0);
QCOMPARE(nullMethod.revision(), 0);
QCOMPARE(nullMethod.index(), 0);
@ -222,12 +222,12 @@ void tst_QMetaObjectBuilder::method()
// Add a method and check its attributes.
QMetaMethodBuilder method1 = builder.addMethod("foo(const QString&, int)");
QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(method1.methodType() == QMetaMethod::Method);
QCOMPARE(method1.methodType(), QMetaMethod::Method);
QCOMPARE(method1.returnType(), QByteArray("void"));
QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QVERIFY(method1.parameterNames().isEmpty());
QVERIFY(method1.tag().isEmpty());
QVERIFY(method1.access() == QMetaMethod::Public);
QCOMPARE(method1.access(), QMetaMethod::Public);
QCOMPARE(method1.attributes(), 0);
QCOMPARE(method1.revision(), 0);
QCOMPARE(method1.index(), 0);
@ -236,12 +236,12 @@ void tst_QMetaObjectBuilder::method()
// Add another method and check again.
QMetaMethodBuilder method2 = builder.addMethod("bar(QString)", "int");
QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
QVERIFY(method2.methodType() == QMetaMethod::Method);
QCOMPARE(method2.methodType(), QMetaMethod::Method);
QCOMPARE(method2.returnType(), QByteArray("int"));
QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
QVERIFY(method2.parameterNames().isEmpty());
QVERIFY(method2.tag().isEmpty());
QVERIFY(method2.access() == QMetaMethod::Public);
QCOMPARE(method2.access(), QMetaMethod::Public);
QCOMPARE(method2.attributes(), 0);
QCOMPARE(method2.revision(), 0);
QCOMPARE(method2.index(), 1);
@ -262,22 +262,22 @@ void tst_QMetaObjectBuilder::method()
// Check that method1 is changed, but method2 is not.
QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(method1.methodType() == QMetaMethod::Method);
QCOMPARE(method1.methodType(), QMetaMethod::Method);
QCOMPARE(method1.returnType(), QByteArray("int"));
QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");
QCOMPARE(method1.tag(), QByteArray("tag"));
QVERIFY(method1.access() == QMetaMethod::Private);
QCOMPARE(method1.access(), QMetaMethod::Private);
QCOMPARE(method1.attributes(), 42);
QCOMPARE(method1.revision(), 123);
QCOMPARE(method1.index(), 0);
QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
QVERIFY(method2.methodType() == QMetaMethod::Method);
QCOMPARE(method2.methodType(), QMetaMethod::Method);
QCOMPARE(method2.returnType(), QByteArray("int"));
QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
QVERIFY(method2.parameterNames().isEmpty());
QVERIFY(method2.tag().isEmpty());
QVERIFY(method2.access() == QMetaMethod::Public);
QCOMPARE(method2.access(), QMetaMethod::Public);
QCOMPARE(method2.attributes(), 0);
QCOMPARE(method2.revision(), 0);
QCOMPARE(method2.index(), 1);
@ -293,22 +293,22 @@ void tst_QMetaObjectBuilder::method()
// This time check that only method2 changed.
QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(method1.methodType() == QMetaMethod::Method);
QCOMPARE(method1.methodType(), QMetaMethod::Method);
QCOMPARE(method1.returnType(), QByteArray("int"));
QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");
QCOMPARE(method1.tag(), QByteArray("tag"));
QVERIFY(method1.access() == QMetaMethod::Private);
QCOMPARE(method1.access(), QMetaMethod::Private);
QCOMPARE(method1.attributes(), 42);
QCOMPARE(method1.revision(), 123);
QCOMPARE(method1.index(), 0);
QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
QVERIFY(method2.methodType() == QMetaMethod::Method);
QCOMPARE(method2.methodType(), QMetaMethod::Method);
QCOMPARE(method2.returnType(), QByteArray("QString"));
QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");
QCOMPARE(method2.tag(), QByteArray("Q_FOO"));
QVERIFY(method2.access() == QMetaMethod::Protected);
QCOMPARE(method2.access(), QMetaMethod::Protected);
QCOMPARE(method2.attributes(), 24);
QCOMPARE(method2.revision(), 321);
QCOMPARE(method2.index(), 1);
@ -319,12 +319,12 @@ void tst_QMetaObjectBuilder::method()
QCOMPARE(builder.methodCount(), 1);
method2 = builder.method(0);
QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
QVERIFY(method2.methodType() == QMetaMethod::Method);
QCOMPARE(method2.methodType(), QMetaMethod::Method);
QCOMPARE(method2.returnType(), QByteArray("QString"));
QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");
QCOMPARE(method2.tag(), QByteArray("Q_FOO"));
QVERIFY(method2.access() == QMetaMethod::Protected);
QCOMPARE(method2.access(), QMetaMethod::Protected);
QCOMPARE(method2.attributes(), 24);
QCOMPARE(method2.revision(), 321);
QCOMPARE(method2.index(), 0);
@ -347,12 +347,12 @@ void tst_QMetaObjectBuilder::slot()
// Add a slot and check its attributes.
QMetaMethodBuilder method1 = builder.addSlot("foo(const QString&, int)");
QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(method1.methodType() == QMetaMethod::Slot);
QCOMPARE(method1.methodType(), QMetaMethod::Slot);
QCOMPARE(method1.returnType(), QByteArray("void"));
QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QVERIFY(method1.parameterNames().isEmpty());
QVERIFY(method1.tag().isEmpty());
QVERIFY(method1.access() == QMetaMethod::Public);
QCOMPARE(method1.access(), QMetaMethod::Public);
QCOMPARE(method1.attributes(), 0);
QCOMPARE(method1.index(), 0);
QCOMPARE(builder.methodCount(), 1);
@ -360,12 +360,12 @@ void tst_QMetaObjectBuilder::slot()
// Add another slot and check again.
QMetaMethodBuilder method2 = builder.addSlot("bar(QString)");
QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
QVERIFY(method2.methodType() == QMetaMethod::Slot);
QCOMPARE(method2.methodType(), QMetaMethod::Slot);
QCOMPARE(method2.returnType(), QByteArray("void"));
QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
QVERIFY(method2.parameterNames().isEmpty());
QVERIFY(method2.tag().isEmpty());
QVERIFY(method2.access() == QMetaMethod::Public);
QCOMPARE(method2.access(), QMetaMethod::Public);
QCOMPARE(method2.attributes(), 0);
QCOMPARE(method2.index(), 1);
QCOMPARE(builder.methodCount(), 2);
@ -386,12 +386,12 @@ void tst_QMetaObjectBuilder::signal()
// Add a signal and check its attributes.
QMetaMethodBuilder method1 = builder.addSignal("foo(const QString&, int)");
QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(method1.methodType() == QMetaMethod::Signal);
QCOMPARE(method1.methodType(), QMetaMethod::Signal);
QCOMPARE(method1.returnType(), QByteArray("void"));
QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QVERIFY(method1.parameterNames().isEmpty());
QVERIFY(method1.tag().isEmpty());
QVERIFY(method1.access() == QMetaMethod::Public);
QCOMPARE(method1.access(), QMetaMethod::Public);
QCOMPARE(method1.attributes(), 0);
QCOMPARE(method1.index(), 0);
QCOMPARE(builder.methodCount(), 1);
@ -399,12 +399,12 @@ void tst_QMetaObjectBuilder::signal()
// Add another signal and check again.
QMetaMethodBuilder method2 = builder.addSignal("bar(QString)");
QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
QVERIFY(method2.methodType() == QMetaMethod::Signal);
QCOMPARE(method2.methodType(), QMetaMethod::Signal);
QCOMPARE(method2.returnType(), QByteArray("void"));
QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
QVERIFY(method2.parameterNames().isEmpty());
QVERIFY(method2.tag().isEmpty());
QVERIFY(method2.access() == QMetaMethod::Public);
QCOMPARE(method2.access(), QMetaMethod::Public);
QCOMPARE(method2.attributes(), 0);
QCOMPARE(method2.index(), 1);
QCOMPARE(builder.methodCount(), 2);
@ -425,12 +425,12 @@ void tst_QMetaObjectBuilder::constructor()
// Add a constructor and check its attributes.
QMetaMethodBuilder ctor1 = builder.addConstructor("foo(const QString&, int)");
QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor1.methodType(), QMetaMethod::Constructor);
QVERIFY(ctor1.returnType().isEmpty());
QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QVERIFY(ctor1.parameterNames().isEmpty());
QVERIFY(ctor1.tag().isEmpty());
QVERIFY(ctor1.access() == QMetaMethod::Public);
QCOMPARE(ctor1.access(), QMetaMethod::Public);
QCOMPARE(ctor1.attributes(), 0);
QCOMPARE(ctor1.index(), 0);
QCOMPARE(builder.constructorCount(), 1);
@ -438,12 +438,12 @@ void tst_QMetaObjectBuilder::constructor()
// Add another constructor and check again.
QMetaMethodBuilder ctor2 = builder.addConstructor("bar(QString)");
QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
QVERIFY(ctor2.returnType().isEmpty());
QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
QVERIFY(ctor2.parameterNames().isEmpty());
QVERIFY(ctor2.tag().isEmpty());
QVERIFY(ctor2.access() == QMetaMethod::Public);
QCOMPARE(ctor2.access(), QMetaMethod::Public);
QCOMPARE(ctor2.attributes(), 0);
QCOMPARE(ctor2.index(), 1);
QCOMPARE(builder.constructorCount(), 2);
@ -464,21 +464,21 @@ void tst_QMetaObjectBuilder::constructor()
// Check that ctor1 is changed, but ctor2 is not.
QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor1.methodType(), QMetaMethod::Constructor);
QCOMPARE(ctor1.returnType(), QByteArray("int"));
QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");
QCOMPARE(ctor1.tag(), QByteArray("tag"));
QVERIFY(ctor1.access() == QMetaMethod::Private);
QCOMPARE(ctor1.access(), QMetaMethod::Private);
QCOMPARE(ctor1.attributes(), 42);
QCOMPARE(ctor1.index(), 0);
QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
QVERIFY(ctor2.returnType().isEmpty());
QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
QVERIFY(ctor2.parameterNames().isEmpty());
QVERIFY(ctor2.tag().isEmpty());
QVERIFY(ctor2.access() == QMetaMethod::Public);
QCOMPARE(ctor2.access(), QMetaMethod::Public);
QCOMPARE(ctor2.attributes(), 0);
QCOMPARE(ctor2.index(), 1);
QCOMPARE(builder.constructorCount(), 2);
@ -492,21 +492,21 @@ void tst_QMetaObjectBuilder::constructor()
// This time check that only ctor2 changed.
QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor1.methodType(), QMetaMethod::Constructor);
QCOMPARE(ctor1.returnType(), QByteArray("int"));
QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");
QCOMPARE(ctor1.tag(), QByteArray("tag"));
QVERIFY(ctor1.access() == QMetaMethod::Private);
QCOMPARE(ctor1.access(), QMetaMethod::Private);
QCOMPARE(ctor1.attributes(), 42);
QCOMPARE(ctor1.index(), 0);
QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
QCOMPARE(ctor2.returnType(), QByteArray("QString"));
QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");
QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));
QVERIFY(ctor2.access() == QMetaMethod::Protected);
QCOMPARE(ctor2.access(), QMetaMethod::Protected);
QCOMPARE(ctor2.attributes(), 24);
QCOMPARE(ctor2.index(), 1);
QCOMPARE(builder.constructorCount(), 2);
@ -516,12 +516,12 @@ void tst_QMetaObjectBuilder::constructor()
QCOMPARE(builder.constructorCount(), 1);
ctor2 = builder.constructor(0);
QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
QCOMPARE(ctor2.methodType(), QMetaMethod::Constructor);
QCOMPARE(ctor2.returnType(), QByteArray("QString"));
QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");
QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));
QVERIFY(ctor2.access() == QMetaMethod::Protected);
QCOMPARE(ctor2.access(), QMetaMethod::Protected);
QCOMPARE(ctor2.attributes(), 24);
QCOMPARE(ctor2.index(), 0);
@ -536,10 +536,10 @@ void tst_QMetaObjectBuilder::constructor()
QCOMPARE(builder.constructorCount(), 2);
QCOMPARE(prototypeConstructor.signature(), QByteArray("SomethingOfEverything()"));
QVERIFY(prototypeConstructor.methodType() == QMetaMethod::Constructor);
QCOMPARE(prototypeConstructor.methodType(), QMetaMethod::Constructor);
QCOMPARE(prototypeConstructor.returnType(), QByteArray());
QVERIFY(prototypeConstructor.parameterTypes().isEmpty());
QVERIFY(prototypeConstructor.access() == QMetaMethod::Public);
QCOMPARE(prototypeConstructor.access(), QMetaMethod::Public);
QCOMPARE(prototypeConstructor.index(), 1);
// Check that nothing else changed.
@ -967,13 +967,13 @@ void tst_QMetaObjectBuilder::relatedMetaObject()
// Add two related meta objects and check their attributes.
QCOMPARE(builder.addRelatedMetaObject(&QObject::staticMetaObject), 0);
QCOMPARE(builder.addRelatedMetaObject(&staticMetaObject), 1);
QVERIFY(builder.relatedMetaObject(0) == &QObject::staticMetaObject);
QVERIFY(builder.relatedMetaObject(1) == &staticMetaObject);
QCOMPARE(builder.relatedMetaObject(0), &QObject::staticMetaObject);
QCOMPARE(builder.relatedMetaObject(1), &staticMetaObject);
QCOMPARE(builder.relatedMetaObjectCount(), 2);
// Remove the first one and check again.
builder.removeRelatedMetaObject(0);
QVERIFY(builder.relatedMetaObject(0) == &staticMetaObject);
QCOMPARE(builder.relatedMetaObject(0), &staticMetaObject);
QCOMPARE(builder.relatedMetaObjectCount(), 1);
// Check that nothing else changed.
@ -1617,7 +1617,7 @@ void tst_QMetaObjectBuilder::usage_slot()
QVERIFY(index != -1);
QMetaMethod voidSlotInt = testObject->metaObject()->method(index);
QVERIFY(testObject->voidSlotIntArgument() == -1);
QCOMPARE(testObject->voidSlotIntArgument(), -1);
QVERIFY(voidSlotInt.invoke(testObject.data(), Q_ARG(int, 123)));
QCOMPARE(testObject->voidSlotIntArgument(), 123);
}
@ -1658,7 +1658,7 @@ void tst_QMetaObjectBuilder::usage_connect()
QVERIFY(QObject::connect(testObject.data(), SIGNAL(intPropChanged(int)),
testObject.data(), SLOT(voidSlotInt(int))));
QVERIFY(testObject->voidSlotIntArgument() == -1);
QCOMPARE(testObject->voidSlotIntArgument(), -1);
testObject->setProperty("intProp", 123);
QCOMPARE(testObject->voidSlotIntArgument(), 123);
@ -1674,7 +1674,7 @@ void tst_QMetaObjectBuilder::usage_templateConnect()
testObject.data(), &TestObject::voidSlotInt);
QVERIFY(con);
QVERIFY(testObject->voidSlotIntArgument() == -1);
QCOMPARE(testObject->voidSlotIntArgument(), -1);
testObject->setProperty("intProp", 123);
QCOMPARE(testObject->voidSlotIntArgument(), 123);

4
tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
View File

@ -2394,8 +2394,8 @@ void tst_QMetaType::compareCustomEqualOnlyType()
QVERIFY(variant50 != variant100x);
QVERIFY(variant100 != variant50);
QVERIFY(variant100x != variant50);
QVERIFY(variant100 == variant100x);
QVERIFY(variant100 == variant100);
QCOMPARE(variant100, variant100x);
QCOMPARE(variant100, variant100);
// compare always fails
QVERIFY(!(variant50 < variant50));

2
tests/auto/corelib/kernel/qmimedata/tst_qmimedata.cpp
View File

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

48
tests/auto/corelib/kernel/qobject/tst_qobject.cpp
View File

@ -2038,57 +2038,57 @@ void tst_QObject::metamethod()
m = mobj->method(mobj->indexOfMethod("invoke1()"));
QVERIFY(m.methodSignature() == "invoke1()");
QVERIFY(m.methodType() == QMetaMethod::Method);
QVERIFY(m.access() == QMetaMethod::Public);
QCOMPARE(m.methodType(), QMetaMethod::Method);
QCOMPARE(m.access(), QMetaMethod::Public);
QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("sinvoke1()"));
QVERIFY(m.methodSignature() == "sinvoke1()");
QVERIFY(m.methodType() == QMetaMethod::Method);
QVERIFY(m.access() == QMetaMethod::Public);
QCOMPARE(m.methodType(), QMetaMethod::Method);
QCOMPARE(m.access(), QMetaMethod::Public);
QVERIFY((m.attributes() & QMetaMethod::Scriptable));
QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("invoke2()"));
QVERIFY(m.methodSignature() == "invoke2()");
QVERIFY(m.methodType() == QMetaMethod::Method);
QVERIFY(m.access() == QMetaMethod::Protected);
QCOMPARE(m.methodType(), QMetaMethod::Method);
QCOMPARE(m.access(), QMetaMethod::Protected);
QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
QVERIFY((m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("sinvoke2()"));
QVERIFY(m.methodSignature() == "sinvoke2()");
QVERIFY(m.methodType() == QMetaMethod::Method);
QVERIFY(m.access() == QMetaMethod::Protected);
QCOMPARE(m.methodType(), QMetaMethod::Method);
QCOMPARE(m.access(), QMetaMethod::Protected);
QVERIFY((m.attributes() & QMetaMethod::Scriptable));
QVERIFY((m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("invoke3()"));
QVERIFY(m.methodSignature() == "invoke3()");
QVERIFY(m.methodType() == QMetaMethod::Method);
QVERIFY(m.access() == QMetaMethod::Private);
QCOMPARE(m.methodType(), QMetaMethod::Method);
QCOMPARE(m.access(), QMetaMethod::Private);
QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("sinvoke3()"));
QVERIFY(m.methodSignature() == "sinvoke3()");
QVERIFY(m.methodType() == QMetaMethod::Method);
QVERIFY(m.access() == QMetaMethod::Private);
QCOMPARE(m.methodType(), QMetaMethod::Method);
QCOMPARE(m.access(), QMetaMethod::Private);
QVERIFY((m.attributes() & QMetaMethod::Scriptable));
QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("signal5()"));
QVERIFY(m.methodSignature() == "signal5()");
QVERIFY(m.methodType() == QMetaMethod::Signal);
QVERIFY(m.access() == QMetaMethod::Public);
QCOMPARE(m.methodType(), QMetaMethod::Signal);
QCOMPARE(m.access(), QMetaMethod::Public);
QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
QVERIFY((m.attributes() & QMetaMethod::Compatibility));
m = mobj->method(mobj->indexOfMethod("aPublicSlot()"));
QVERIFY(m.methodSignature() == "aPublicSlot()");
QVERIFY(m.methodType() == QMetaMethod::Slot);
QVERIFY(m.access() == QMetaMethod::Public);
QCOMPARE(m.methodType(), QMetaMethod::Slot);
QCOMPARE(m.access(), QMetaMethod::Public);
QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
@ -2360,7 +2360,7 @@ void tst_QObject::testUserData()
int id = user_data_ids[i];
CustomData *data = static_cast<CustomData *>(my_test_object.userData(id));
QVERIFY(data != 0);
QVERIFY(data->id == id);
QCOMPARE(data->id, id);
}
}
@ -2902,12 +2902,12 @@ void tst_QObject::floatProperty()
QVERIFY(idx > 0);
QMetaProperty prop = obj.metaObject()->property(idx);
QVERIFY(prop.isValid());
QVERIFY(prop.type() == uint(QMetaType::type("float")));
QCOMPARE(int(prop.type()), QMetaType::type("float"));
QVERIFY(!prop.write(&obj, QVariant("Hello")));
QVERIFY(prop.write(&obj, QVariant::fromValue(128.0f)));
QVariant v = prop.read(&obj);
QVERIFY(int(v.userType()) == QMetaType::Float);
QVERIFY(qvariant_cast<float>(v) == 128.0f);
QCOMPARE(v.userType(), int(QMetaType::Float));
QCOMPARE(qvariant_cast<float>(v), 128.0f);
}
void tst_QObject::qrealProperty()
@ -2917,18 +2917,18 @@ void tst_QObject::qrealProperty()
QVERIFY(idx > 0);
QMetaProperty prop = obj.metaObject()->property(idx);
QVERIFY(prop.isValid());
QVERIFY(prop.type() == uint(QMetaType::type("qreal")));
QCOMPARE(int(prop.type()), QMetaType::type("qreal"));
QVERIFY(!prop.write(&obj, QVariant("Hello")));
QVERIFY(prop.write(&obj, QVariant::fromValue(128.0f)));
QVariant v = prop.read(&obj);
QCOMPARE(v.userType(), qMetaTypeId<qreal>());
QVERIFY(qvariant_cast<qreal>(v) == 128.0);
QCOMPARE(qvariant_cast<qreal>(v), 128.0);
QVERIFY(prop.write(&obj, QVariant::fromValue(double(127))));
v = prop.read(&obj);
QCOMPARE(v.userType(), qMetaTypeId<qreal>());
QVERIFY(qvariant_cast<qreal>(v) == 127.0);
QCOMPARE(qvariant_cast<qreal>(v), 127.0);
}
class DynamicPropertyObject : public PropertyObject
@ -2994,7 +2994,7 @@ void tst_QObject::recursiveSignalEmission()
proc.start(path);
QVERIFY2(proc.waitForStarted(), qPrintable(QString::fromLatin1("Cannot start '%1': %2").arg(path, proc.errorString())));
QVERIFY(proc.waitForFinished());
QVERIFY(proc.exitStatus() == QProcess::NormalExit);
QCOMPARE(proc.exitStatus(), QProcess::NormalExit);
QCOMPARE(proc.exitCode(), 0);
#endif
}

24
tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
View File

@ -145,7 +145,7 @@ void tst_QSharedMemory::init()
{
existingSharedMemory = new QSharedMemory(EXISTING_SHARE);
if (!existingSharedMemory->create(EXISTING_SIZE)) {
QVERIFY(existingSharedMemory->error() == QSharedMemory::AlreadyExists);
QCOMPARE(existingSharedMemory->error(), QSharedMemory::AlreadyExists);
}
}
@ -244,10 +244,10 @@ void tst_QSharedMemory::constructor()
QSharedMemory sm;
QCOMPARE(sm.key(), QString());
QVERIFY(!sm.isAttached());
QVERIFY(sm.data() == 0);
QVERIFY(!sm.data());
QCOMPARE(sm.size(), 0);
QCOMPARE(sm.error(), QSharedMemory::NoError);
QVERIFY(sm.errorString() == QString());
QCOMPARE(sm.errorString(), QString());
}
void tst_QSharedMemory::key_data()
@ -288,8 +288,8 @@ void tst_QSharedMemory::key()
QCOMPARE(sm.isAttached(), false);
QCOMPARE(sm.error(), QSharedMemory::NoError);
QVERIFY(sm.errorString() == QString());
QVERIFY(sm.data() == 0);
QCOMPARE(sm.errorString(), QString());
QVERIFY(!sm.data());
QCOMPARE(sm.size(), 0);
QCOMPARE(sm.detach(), false);
@ -328,11 +328,11 @@ void tst_QSharedMemory::create()
qDebug() << sm.errorString();
QCOMPARE(sm.key(), key);
if (canCreate) {
QVERIFY(sm.errorString() == QString());
QCOMPARE(sm.errorString(), QString());
QVERIFY(sm.data() != 0);
QVERIFY(sm.size() != 0);
} else {
QVERIFY(sm.data() == 0);
QVERIFY(!sm.data());
QVERIFY(sm.errorString() != QString());
}
}
@ -377,10 +377,10 @@ void tst_QSharedMemory::attach()
QVERIFY(sm.size() != 0);
QVERIFY(sm.detach());
QCOMPARE(sm.size(), 0);
QVERIFY(sm.data() == 0);
QVERIFY(!sm.data());
} else {
QVERIFY(sm.data() == 0);
QVERIFY(sm.size() == 0);
QVERIFY(!sm.data());
QCOMPARE(sm.size(), 0);
QVERIFY(sm.errorString() != QString());
QVERIFY(!sm.detach());
}
@ -498,7 +498,7 @@ void tst_QSharedMemory::useTooMuchMemory()
QVERIFY(!sm->isAttached());
QCOMPARE(sm->key(), key);
QCOMPARE(sm->size(), 0);
QVERIFY(sm->data() == 0);
QVERIFY(!sm->data());
if (sm->error() != QSharedMemory::OutOfResources)
qDebug() << sm->error() << sm->errorString();
// ### Linux won't return OutOfResources if there are not enough semaphores to use.
@ -535,7 +535,7 @@ void tst_QSharedMemory::attachTooMuch()
QVERIFY(!war->isAttached());
QCOMPARE(war->key(), government.key());
QCOMPARE(war->size(), 0);
QVERIFY(war->data() == 0);
QVERIFY(!war->data());
QCOMPARE(war->error(), QSharedMemory::OutOfResources);
QVERIFY(war->errorString() != QString());
QVERIFY(!war->detach());

10
tests/auto/corelib/kernel/qsignalmapper/tst_qsignalmapper.cpp
View File

@ -97,16 +97,16 @@ void tst_QSignalMapper::mapped()
connect(&mapper, SIGNAL(mapped(QString)), &target, SLOT(myslot(QString)));
src1.emit_mysignal(20);
QVERIFY(target.id == 1);
QCOMPARE(target.id, 1);
QVERIFY(target.str.isEmpty());
src2.emit_mysignal(20);
QVERIFY(target.id == 2);
QVERIFY(target.str == "two");
QCOMPARE(target.id, 2);
QCOMPARE(target.str, QLatin1String("two"));
src3.emit_mysignal(20);
QVERIFY(target.id == 2);
QVERIFY(target.str == "three");
QCOMPARE(target.id, 2);
QCOMPARE(target.str, QLatin1String("three"));
}
QTEST_MAIN(tst_QSignalMapper)

8
tests/auto/corelib/kernel/qsocketnotifier/tst_qsocketnotifier.cpp
View File

@ -129,7 +129,7 @@ void tst_QSocketNotifier::unexpectedDisconnection()
readEnd1.initialize(QAbstractSocket::TcpSocket);
readEnd1.connectToHost(server.serverAddress(), server.serverPort());
QVERIFY(readEnd1.waitForWrite());
QVERIFY(readEnd1.state() == QAbstractSocket::ConnectedState);
QCOMPARE(readEnd1.state(), QAbstractSocket::ConnectedState);
QVERIFY(server.waitForNewConnection());
QTcpSocket *writeEnd1 = server.nextPendingConnection();
QVERIFY(writeEnd1 != 0);
@ -138,7 +138,7 @@ void tst_QSocketNotifier::unexpectedDisconnection()
readEnd2.initialize(QAbstractSocket::TcpSocket);
readEnd2.connectToHost(server.serverAddress(), server.serverPort());
QVERIFY(readEnd2.waitForWrite());
QVERIFY(readEnd2.state() == QAbstractSocket::ConnectedState);
QCOMPARE(readEnd2.state(), QAbstractSocket::ConnectedState);
QVERIFY(server.waitForNewConnection());
QTcpSocket *writeEnd2 = server.nextPendingConnection();
QVERIFY(writeEnd2 != 0);
@ -164,8 +164,8 @@ void tst_QSocketNotifier::unexpectedDisconnection()
QVERIFY(timer.isActive()); //escape if test would hang
} while(tester.sequence <= 0);
QVERIFY(readEnd1.state() == QAbstractSocket::ConnectedState);
QVERIFY(readEnd2.state() == QAbstractSocket::ConnectedState);
QCOMPARE(readEnd1.state(), QAbstractSocket::ConnectedState);
QCOMPARE(readEnd2.state(), QAbstractSocket::ConnectedState);
QCOMPARE(tester.sequence, 2);

4
tests/auto/corelib/kernel/qsystemsemaphore/test/tst_qsystemsemaphore.cpp
View File

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

2
tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
View File

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

44
tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
View File

@ -351,13 +351,13 @@ void tst_QVariant::constructor_invalid()
QTest::ignoreMessage(QtWarningMsg, QRegularExpression("^Trying to construct an instance of an invalid type, type id:"));
QVariant variant(static_cast<QVariant::Type>(typeId));
QVERIFY(!variant.isValid());
QVERIFY(variant.userType() == QMetaType::UnknownType);
QCOMPARE(variant.userType(), int(QMetaType::UnknownType));
}
{
QTest::ignoreMessage(QtWarningMsg, QRegularExpression("^Trying to construct an instance of an invalid type, type id:"));
QVariant variant(typeId, /* copy */ 0);
QVERIFY(!variant.isValid());
QVERIFY(variant.userType() == QMetaType::UnknownType);
QCOMPARE(variant.userType(), int(QMetaType::UnknownType));
}
}
@ -901,7 +901,7 @@ void tst_QVariant::toFloat()
bool ok;
float d = value.toFloat(&ok);
QCOMPARE(d, result);
QVERIFY(ok == valueOK);
QCOMPARE(ok, valueOK);
}
void tst_QVariant::toLongLong_data()
@ -1323,9 +1323,9 @@ void tst_QVariant::writeToReadFromDataStream()
// the uninitialized float can be NaN (observed on Windows Mobile 5 ARMv4i)
float readFloat = qvariant_cast<float>(readVariant);
float writtenFloat = qvariant_cast<float>(writeVariant);
QVERIFY(qIsNaN(readFloat) == qIsNaN(writtenFloat));
QCOMPARE(qIsNaN(readFloat), qIsNaN(writtenFloat));
if (!qIsNaN(readFloat))
QVERIFY(readFloat == writtenFloat);
QCOMPARE(readFloat, writtenFloat);
}
break;
}
@ -2115,7 +2115,7 @@ void tst_QVariant::userType()
QVERIFY(!userVar.canConvert(QVariant::String));
QVariant userVar2(userVar);
QVERIFY(userVar == userVar2);
QCOMPARE(userVar, userVar2);
userVar2.setValue(data2);
QVERIFY(userVar != userVar2);
@ -2129,7 +2129,7 @@ void tst_QVariant::userType()
userVar3.setValue(data2);
userVar3 = userVar2;
QVERIFY(userVar2 == userVar3);
QCOMPARE(userVar2, userVar3);
}
// At this point all QVariants got destroyed but we have 2 MyType instances.
QCOMPARE(instanceCount, 2);
@ -2144,7 +2144,7 @@ void tst_QVariant::userType()
QVERIFY(!userVar.canConvert(QVariant::String));
QVariant userVar2(userVar);
QVERIFY(userVar == userVar2);
QCOMPARE(userVar, userVar2);
userVar2.setValue(&data2);
QVERIFY(userVar != userVar2);
@ -2158,10 +2158,10 @@ void tst_QVariant::userType()
/* This check is correct now. userVar2 contains a pointer to data2 and so
* does userVar3. */
QVERIFY(userVar2 == userVar3);
QCOMPARE(userVar2, userVar3);
userVar3 = userVar2;
QVERIFY(userVar2 == userVar3);
QCOMPARE(userVar2, userVar3);
}
QCOMPARE(instanceCount, 2);
@ -2446,7 +2446,7 @@ void tst_QVariant::saveLoadCustomTypes()
qRegisterMetaTypeStreamOperators<Blah>("Blah");
QCOMPARE(v.userType(), tp);
QVERIFY(v.type() == QVariant::UserType);
QCOMPARE(v.type(), QVariant::UserType);
{
QDataStream stream(&data, QIODevice::WriteOnly);
stream << v;
@ -2610,7 +2610,7 @@ void tst_QVariant::qvariant_cast_QObject_derived()
{
CustomQObjectDerivedNoMetaType *object = new CustomQObjectDerivedNoMetaType(this);
QVariant data = QVariant::fromValue(object);
QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerivedNoMetaType*>());
QCOMPARE(data.userType(), qMetaTypeId<CustomQObjectDerivedNoMetaType*>());
QCOMPARE(data.value<QObject *>(), object);
QCOMPARE(data.value<CustomQObjectDerivedNoMetaType *>(), object);
QCOMPARE(data.value<CustomQObject *>(), object);
@ -2619,7 +2619,7 @@ void tst_QVariant::qvariant_cast_QObject_derived()
CustomQObjectDerived *object = new CustomQObjectDerived(this);
QVariant data = QVariant::fromValue(object);
QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerived*>());
QCOMPARE(data.userType(), qMetaTypeId<CustomQObjectDerived*>());
QCOMPARE(data.value<QObject *>(), object);
QCOMPARE(data.value<CustomQObjectDerived *>(), object);
@ -2886,10 +2886,10 @@ void tst_QVariant::voidStar() const
QVariant v1, v2;
v1 = QVariant::fromValue(p1);
v2 = v1;
QVERIFY(v1 == v2);
QCOMPARE(v1, v2);
v2 = QVariant::fromValue(p2);
QVERIFY(v1 == v2);
QCOMPARE(v1, v2);
p2 = 0;
v2 = QVariant::fromValue(p2);
@ -2906,10 +2906,10 @@ void tst_QVariant::dataStar() const
QCOMPARE(qvariant_cast<Data*>(v1), p1);
QVariant v2 = v1;
QVERIFY(v1 == v2);
QCOMPARE(v1, v2);
v2 = QVariant::fromValue(p1);
QVERIFY(v1 == v2);
QCOMPARE(v1, v2);
delete p1;
}
@ -3081,8 +3081,8 @@ void tst_QVariant::compareCustomTypes() const
/* We compare pointers. */
QVERIFY(variant1 != variant2);
QVERIFY(variant1 == variant1);
QVERIFY(variant2 == variant2);
QCOMPARE(variant1, variant1);
QCOMPARE(variant2, variant2);
}
void tst_QVariant::timeToDateTime() const
@ -3289,7 +3289,7 @@ void tst_QVariant::toIntFromQString() const
void tst_QVariant::toIntFromDouble() const
{
double d = 2147483630; // max int 2147483647
QVERIFY((int)d == 2147483630);
QCOMPARE((int)d, 2147483630);
QVariant var(d);
QVERIFY( var.canConvert( QVariant::Int ) );
@ -4119,7 +4119,7 @@ void tst_QVariant::saveInvalid()
QDataStream stream(&data, QIODevice::WriteOnly);
stream.setVersion(version);
stream << QVariant();
QVERIFY(stream.status() == QDataStream::Ok);
QCOMPARE(stream.status(), QDataStream::Ok);
QVERIFY(data.size() >= 4);
QCOMPARE(int(data.constData()[0]), 0);
QCOMPARE(int(data.constData()[1]), 0);
@ -4133,7 +4133,7 @@ void tst_QVariant::saveNewBuiltinWithOldStream()
QDataStream stream(&data, QIODevice::WriteOnly);
stream.setVersion(QDataStream::Qt_3_1);
stream << QVariant::fromValue<QJsonValue>(123); // QJsonValue class was introduced in Qt5
QVERIFY(stream.status() == QDataStream::Ok);
QCOMPARE(stream.status(), QDataStream::Ok);
QVERIFY(data.size() >= 4);
QCOMPARE(int(data.constData()[0]), 0);
QCOMPARE(int(data.constData()[1]), 0);

4
tests/auto/corelib/plugin/quuid/tst_quuid.cpp
View File

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

14
tests/auto/corelib/statemachine/qstatemachine/tst_qstatemachine.cpp
View File

@ -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.parentState() == 0);
QVERIFY(!machine.parent());
QVERIFY(!machine.parentState());
}
{
QStateMachine machine(QState::ParallelStates);
QCOMPARE(machine.childMode(), QState::ParallelStates);
QVERIFY(machine.parent() == 0);
QVERIFY(machine.parentState() == 0);
QVERIFY(!machine.parent());
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;
{

88
tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
View File

@ -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);
QVERIFY(atomic2.load() == two);
QVERIFY(atomic3.load() == three);
QCOMPARE(atomic1.load(), one);
QCOMPARE(atomic2.load(), two);
QCOMPARE(atomic3.load(), three);
atomic1 = two;
atomic2 = three;
atomic3 = one;
QVERIFY(atomic1.load() == two);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
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);
QVERIFY(atomic2.load() == three);
QVERIFY(atomic3.load() == one);
QCOMPARE(atomic1.load(), two);
QCOMPARE(atomic2.load(), three);
QCOMPARE(atomic3.load(), one);
}
}

42
tests/auto/corelib/thread/qfuture/tst_qfuture.cpp
View File

@ -84,9 +84,9 @@ void tst_QFuture::resultStore()
{
QtPrivate::ResultStore<int> store;
QVERIFY(store.begin() == store.end());
QVERIFY(store.resultAt(0) == store.end());
QVERIFY(store.resultAt(1) == store.end());
QCOMPARE(store.begin(), store.end());
QCOMPARE(store.resultAt(0), 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);
QVERIFY(i1 == c1);
QVERIFY(c1 == i1);
QVERIFY(c1 == c1);
QVERIFY(i2 == i2);
QVERIFY(i2 == c2);
QVERIFY(c2 == i2);
QVERIFY(c2 == c2);
QCOMPARE(i1, i1);
QCOMPARE(i1, c1);
QCOMPARE(c1, i1);
QCOMPARE(c1, c1);
QCOMPARE(i2, i2);
QCOMPARE(i2, c2);
QCOMPARE(c2, i2);
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);
QVERIFY(i1 == c1);
QVERIFY(c1 == i1);
QVERIFY(c1 == c1);
QVERIFY(i2 == i2);
QVERIFY(i2 == c2);
QVERIFY(c2 == i2);
QVERIFY(c2 == c2);
QCOMPARE(i1, i1);
QCOMPARE(i1, c1);
QCOMPARE(c1, i1);
QCOMPARE(c1, c1);
QCOMPARE(i2, i2);
QCOMPARE(i2, c2);
QCOMPARE(c2, i2);
QCOMPARE(c2, c2);
QVERIFY(i1 != i2);
QVERIFY(i1 != c2);

14
tests/auto/corelib/thread/qresultstore/tst_qresultstore.cpp
View File

@ -80,9 +80,9 @@ void tst_QtConcurrentResultStore::iterators()
{
{
ResultStore<int> store;
QVERIFY(store.begin() == store.end());
QVERIFY(store.resultAt(0) == store.end());
QVERIFY(store.resultAt(1) == store.end());
QCOMPARE(store.begin(), store.end());
QCOMPARE(store.resultAt(0), 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()

2
tests/auto/corelib/thread/qthreadonce/tst_qthreadonce.cpp
View File

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

6
tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
View File

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