AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Don't use obsolete qVariantValue, qVariantCanConvert, etc.

Browse Source 
qVariantValue and qVariantCanConvert are Compatibility members, while in
Qt4.8 they are marked as Qt 3 Support Members.

qVariantFromValue and qVariantSetValue are Obsolete members.

Change-Id: Ie8505cad1e0950e40c6f6710fde9f6fb2ac670fd
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
This commit is contained in:
Debao Zhang 2012-04-29 00:11:28 -07:00 committed by Qt by Nokia
parent 6102ab8d64
commit ade8888603
46 changed files with 589 additions and 589 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/dbus/qdbusdemarshaller.cpp
View File

@ -287,7 +287,7 @@ QVariant QDBusDemarshaller::toVariantInternal()
case DBUS_TYPE_UNIX_FD:
if (capabilities & QDBusConnection::UnixFileDescriptorPassing)
return qVariantFromValue(toUnixFileDescriptor());
return QVariant::fromValue(toUnixFileDescriptor());
// fall through
default:

2
src/gui/text/qcssparser.cpp
View File

@ -544,7 +544,7 @@ QSize ValueExtractor::sizeValue(const Declaration &decl)
else
x[1] = x[0];
QList<QVariant> v;
v << QVariant::fromValue<LengthData>(x[0]) << qVariantFromValue<LengthData>(x[1]);
v << QVariant::fromValue<LengthData>(x[0]) << QVariant::fromValue<LengthData>(x[1]);
decl.d->parsed = v;
return QSize(lengthValueFromData(x[0], f), lengthValueFromData(x[1], f));
}

2
src/network/access/qnetworkreplyhttpimpl.cpp
View File

@ -1068,7 +1068,7 @@ void QNetworkReplyHttpImplPrivate::replyDownloadMetaData
downloadZerocopyBuffer = downloadBufferPointer.data();
downloadBufferCurrentSize = 0;
downloadBufferMaximumSize = contentLength;
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, qVariantFromValue<QSharedPointer<char> > (downloadBufferPointer));
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, QVariant::fromValue<QSharedPointer<char> > (downloadBufferPointer));
}
q->setAttribute(QNetworkRequest::HttpPipeliningWasUsedAttribute, pu);

4
src/network/access/qnetworkreplyimpl.cpp
View File

@ -698,7 +698,7 @@ char* QNetworkReplyImplPrivate::getDownloadBuffer(qint64 size)
downloadBuffer = new char[downloadBufferMaximumSize]; // throws if allocation fails
downloadBufferPointer = QSharedPointer<char>(downloadBuffer, downloadBufferDeleter);
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, qVariantFromValue<QSharedPointer<char> > (downloadBufferPointer));
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, QVariant::fromValue<QSharedPointer<char> > (downloadBufferPointer));
}
}
@ -713,7 +713,7 @@ void QNetworkReplyImplPrivate::setDownloadBuffer(QSharedPointer<char> sp, qint64
downloadBuffer = downloadBufferPointer.data();
downloadBufferCurrentSize = 0;
downloadBufferMaximumSize = size;
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, qVariantFromValue<QSharedPointer<char> > (downloadBufferPointer));
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, QVariant::fromValue<QSharedPointer<char> > (downloadBufferPointer));
}

4
src/plugins/bearer/connman/qofonoservice_linux.cpp
View File

@ -786,7 +786,7 @@ bool QOfonoPrimaryDataContextInterface::setActive(bool on)
{
// this->setProperty("Active", QVariant(on));
return setProp("Active", qVariantFromValue(on));
return setProp("Active", QVariant::fromValue(on));
}
bool QOfonoPrimaryDataContextInterface::setApn(const QString &name)
@ -855,7 +855,7 @@ QVariantMap QOfonoPrimaryDataContextInterface::getProperties()
bool QOfonoPrimaryDataContextInterface::setProp(const QString &property, const QVariant &var)
{
QList<QVariant> args;
args << qVariantFromValue(property) << qVariantFromValue(QDBusVariant(var));
args << QVariant::fromValue(property) << QVariant::fromValue(QDBusVariant(var));
QDBusMessage reply = this->callWithArgumentList(QDBus::AutoDetect,
QLatin1String("SetProperty"),

2
src/plugins/platforms/qnx/qqnxclipboard.cpp
View File

@ -153,7 +153,7 @@ protected:
return QMimeData::retrieveData(mimetype, preferredType);
const QByteArray data = readClipboardBuff(mimetype.toUtf8().constData());
return qVariantFromValue(data);
return QVariant::fromValue(data);
}
private Q_SLOTS:

2
src/sql/drivers/mysql/qsql_mysql.cpp
View File

@ -420,7 +420,7 @@ QVariant QMYSQLResult::handle() const
{
#if MYSQL_VERSION_ID >= 40108
if(d->preparedQuery)
return d->meta ? QVariant::fromValue(d->meta) : qVariantFromValue(d->stmt);
return d->meta ? QVariant::fromValue(d->meta) : QVariant::fromValue(d->stmt);
else
#endif
return QVariant::fromValue(d->result);

8
tests/auto/corelib/animation/qanimationgroup/tst_qanimationgroup.cpp
View File

@ -145,9 +145,9 @@ void tst_QAnimationGroup::emptyGroup()
QCOMPARE(groupStateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(group.state(), QAnimationGroup::Stopped);
@ -160,9 +160,9 @@ void tst_QAnimationGroup::emptyGroup()
group.start();
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(2).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(3).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(3).first()),
QAnimationGroup::Stopped);
QCOMPARE(group.state(), QAnimationGroup::Stopped);

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

@ -270,18 +270,18 @@ void tst_QParallelAnimationGroup::stateChanged()
group.start();
//all the animations should be started
QCOMPARE(spy1.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
QCOMPARE(spy2.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
QCOMPARE(spy3.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
QCOMPARE(spy4.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
group.setCurrentTime(1500); //anim1 should be finished
QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
QCOMPARE(spy2.count(), 1); //no change
QCOMPARE(spy3.count(), 1); //no change
QCOMPARE(spy4.count(), 1); //no change
@ -290,7 +290,7 @@ void tst_QParallelAnimationGroup::stateChanged()
QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 2); //no change
QCOMPARE(spy2.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
QCOMPARE(spy3.count(), 1); //no change
QCOMPARE(spy4.count(), 1); //no change
@ -299,9 +299,9 @@ void tst_QParallelAnimationGroup::stateChanged()
QCOMPARE(spy1.count(), 2); //no change
QCOMPARE(spy2.count(), 2); //no change
QCOMPARE(spy3.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
QCOMPARE(spy4.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
//cleanup
spy1.clear();
@ -318,22 +318,22 @@ void tst_QParallelAnimationGroup::stateChanged()
QCOMPARE(spy1.count(), 0);
QCOMPARE(spy2.count(), 0);
QCOMPARE(spy3.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
QCOMPARE(spy4.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
group.setCurrentTime(1500); //anim2 should be started
QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 0); //no change
QCOMPARE(spy2.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
QCOMPARE(spy3.count(), 1); //no change
QCOMPARE(spy4.count(), 1); //no change
group.setCurrentTime(500); //anim1 is finally also started
QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
QCOMPARE(spy2.count(), 1); //no change
QCOMPARE(spy3.count(), 1); //no change
QCOMPARE(spy4.count(), 1); //no change
@ -341,13 +341,13 @@ void tst_QParallelAnimationGroup::stateChanged()
group.setCurrentTime(0); //everything should be stopped
QCOMPARE(group.state(), QAnimationGroup::Stopped);
QCOMPARE(spy1.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
QCOMPARE(spy2.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
QCOMPARE(spy3.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
QCOMPARE(spy4.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
}
void tst_QParallelAnimationGroup::clearGroup()
@ -455,9 +455,9 @@ void tst_QParallelAnimationGroup::updateChildrenWithRunningGroup()
QCOMPARE(groupStateChangedSpy.count(), 1);
QCOMPARE(childStateChangedSpy.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
// starting directly a running child will not have any effect
@ -620,11 +620,11 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
anim2.start();
anim2.pause();
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(1).first()),
QAnimationGroup::Paused);
QCOMPARE(group.state(), QAnimationGroup::Stopped);
@ -634,15 +634,15 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
group.start();
QCOMPARE(stateChangedSpy1.count(), 3);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(2).first()),
QAnimationGroup::Running);
QCOMPARE(stateChangedSpy2.count(), 4);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
QAnimationGroup::Running);
QCOMPARE(group.state(), QAnimationGroup::Running);
@ -694,19 +694,19 @@ void tst_QParallelAnimationGroup::zeroDurationAnimation()
group.start();
QCOMPARE(stateChangedSpy1.count(), 2);
QCOMPARE(finishedSpy1.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(stateChangedSpy2.count(), 1);
QCOMPARE(finishedSpy2.count(), 0);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(stateChangedSpy3.count(), 1);
QCOMPARE(finishedSpy3.count(), 0);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy3.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy3.at(0).first()),
QAnimationGroup::Running);
@ -770,9 +770,9 @@ void tst_QParallelAnimationGroup::stopUncontrolledAnimations()
group.start();
QCOMPARE(stateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(group.state(), QAnimationGroup::Running);
@ -1000,10 +1000,10 @@ void tst_QParallelAnimationGroup::pauseResume()
new TestAnimation2(500, &group);
group.start();
QCOMPARE(spy.count(), 1); //the animation should have been started
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Running);
group.setCurrentTime(250); //end of first animation
QCOMPARE(spy.count(), 2); //the animation should have been stopped
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Stopped);
group.pause();
QCOMPARE(spy.count(), 2); //this shouldn't have changed
group.resume();

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

@ -702,7 +702,7 @@ Q_DECLARE_METATYPE(QAbstractAnimation::State)
QVariant numberInterpolator(const Number &f, const Number &t, qreal progress)
{
return qVariantFromValue<Number>(Number(f.n + (t.n - f.n)*progress));
return QVariant::fromValue<Number>(Number(f.n + (t.n - f.n)*progress));
}
QVariant xaxisQPointInterpolator(const QPointF &f, const QPointF &t, qreal progress)
@ -714,21 +714,21 @@ void tst_QPropertyAnimation::interpolated()
{
QObject o;
o.setProperty("point", QPointF()); //this will avoid warnings
o.setProperty("number", qVariantFromValue<Number>(Number(42)));
QCOMPARE(qVariantValue<Number>(o.property("number")), Number(42));
o.setProperty("number", QVariant::fromValue<Number>(Number(42)));
QCOMPARE(qvariant_cast<Number>(o.property("number")), Number(42));
{
qRegisterAnimationInterpolator<Number>(numberInterpolator);
QPropertyAnimation anim(&o, "number");
anim.setStartValue(qVariantFromValue<Number>(Number(0)));
anim.setEndValue(qVariantFromValue<Number>(Number(100)));
anim.setStartValue(QVariant::fromValue<Number>(Number(0)));
anim.setEndValue(QVariant::fromValue<Number>(Number(100)));
anim.setDuration(1000);
anim.start();
anim.pause();
anim.setCurrentTime(100);
Number t(qVariantValue<Number>(o.property("number")));
Number t(qvariant_cast<Number>(o.property("number")));
QCOMPARE(t, Number(10));
anim.setCurrentTime(500);
QCOMPARE(qVariantValue<Number>(o.property("number")), Number(50));
QCOMPARE(qvariant_cast<Number>(o.property("number")), Number(50));
}
{
qRegisterAnimationInterpolator<QPointF>(xaxisQPointInterpolator);
@ -861,16 +861,16 @@ void tst_QPropertyAnimation::zeroDurationStart()
//let's check the first state change
const QVariantList firstChange = spy.first();
//old state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Stopped);
//new state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Running);
//let's check the first state change
const QVariantList secondChange = spy.last();
//old state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Running);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Running);
//new state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Stopped);
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Stopped);
}
#define Pause 1

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

@ -590,7 +590,7 @@ static bool compareStates(const QSignalSpy& spy, const StateList &expectedStates
}
QList<QVariant> args = spy.at(i);
QAbstractAnimation::State st = expectedStates.at(i);
QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.first());
QAbstractAnimation::State actual = qvariant_cast<QAbstractAnimation::State>(args.first());
if (equals && actual != st) {
equals = false;
break;
@ -608,7 +608,7 @@ static bool compareStates(const QSignalSpy& spy, const StateList &expectedStates
}
if (i < spy.count()) {
QList<QVariant> args = spy.at(i);
QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.value(1));
QAbstractAnimation::State actual = qvariant_cast<QAbstractAnimation::State>(args.value(1));
if (!a.isEmpty())
a += QLatin1String(", ");
if (int(actual) >= 0 && int(actual) <= 2) {
@ -677,20 +677,20 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
<< QAbstractAnimation::Running
<< QAbstractAnimation::Stopped)));
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(1).first()),
QAnimationGroup::Paused);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(2).first()),
QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(3).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(4).first()),
QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
QAnimationGroup::Paused);
group.resume();
@ -711,7 +711,7 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
QVERIFY(a3_s_o1->currentLoopTime() >= 1);
QCOMPARE(seqStateChangedSpy.count(), 3); // Running,Paused,Running
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(2).first()),
QAnimationGroup::Running);
group.pause();
@ -732,13 +732,13 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
QVERIFY(a3_s_o1->currentLoopTime() >= 1);
QCOMPARE(seqStateChangedSpy.count(), 4); // Running,Paused,Running,Paused
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(3).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(3).first()),
QAnimationGroup::Paused);
group.stop();
QCOMPARE(seqStateChangedSpy.count(), 5); // Running,Paused,Running,Paused,Stopped
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(4).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(4).first()),
QAnimationGroup::Stopped);
}
@ -782,25 +782,25 @@ void tst_QSequentialAnimationGroup::restart()
for (int i = 0; i < 3; i++) {
QCOMPARE(animsStateChanged[i]->count(), 4);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(2).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(3).first()),
QAnimationGroup::Stopped);
}
QCOMPARE(seqStateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(seqCurrentAnimChangedSpy.count(), 6);
for(int i=0; i<seqCurrentAnimChangedSpy.count(); i++)
QCOMPARE(static_cast<QAbstractAnimation*>(anims[i%3]), qVariantValue<QAbstractAnimation*>(seqCurrentAnimChangedSpy.at(i).at(0)));
QCOMPARE(static_cast<QAbstractAnimation*>(anims[i%3]), qvariant_cast<QAbstractAnimation*>(seqCurrentAnimChangedSpy.at(i).at(0)));
group.start();
@ -1124,9 +1124,9 @@ void tst_QSequentialAnimationGroup::updateChildrenWithRunningGroup()
QCOMPARE(groupStateChangedSpy.count(), 1);
QCOMPARE(childStateChangedSpy.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
QAnimationGroup::Running);
// starting directly a running child will not have any effect
@ -1317,9 +1317,9 @@ void tst_QSequentialAnimationGroup::startGroupWithRunningChild()
QCOMPARE(anim2->state(), QAnimationGroup::Running);
QCOMPARE(stateChangedSpy2.count(), 4);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
QAnimationGroup::Running);
group.stop();
@ -1357,9 +1357,9 @@ void tst_QSequentialAnimationGroup::zeroDurationAnimation()
group.start();
QCOMPARE(stateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
QAnimationGroup::Stopped);
QCOMPARE(anim1->state(), QAnimationGroup::Stopped);

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

@ -264,9 +264,9 @@ void tst_QProcess::simpleStart()
process = 0;
QCOMPARE(spy.count(), 3);
QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting);
QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(1).at(0)), QProcess::Running);
QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(2).at(0)), QProcess::NotRunning);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(spy.at(1).at(0)), QProcess::Running);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(spy.at(2).at(0)), QProcess::NotRunning);
}
//-----------------------------------------------------------------------------
void tst_QProcess::execute()
@ -331,9 +331,9 @@ void tst_QProcess::crashTest()
process = 0;
QCOMPARE(stateSpy.count(), 3);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(1).at(0)), QProcess::Running);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(2).at(0)), QProcess::NotRunning);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(1).at(0)), QProcess::Running);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(2).at(0)), QProcess::NotRunning);
}
//-----------------------------------------------------------------------------
@ -1571,8 +1571,8 @@ void tst_QProcess::failToStart()
int it = j * attempts + i + 1;
QCOMPARE(stateSpy.count(), it * 2);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(it * 2 - 2).at(0)), QProcess::Starting);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(it * 2 - 1).at(0)), QProcess::NotRunning);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(it * 2 - 2).at(0)), QProcess::Starting);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(it * 2 - 1).at(0)), QProcess::NotRunning);
}
}
}

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

@ -1023,7 +1023,7 @@ void tst_QSettings::testVariantTypes()
#define testVal(key, val, tp, rtype) \
{ \
QSettings settings1(format, QSettings::UserScope, "software.org", "KillerAPP"); \
settings1.setValue(key, qVariantFromValue(val)); \
settings1.setValue(key, QVariant::fromValue(val)); \
} \
QConfFile::clearCache(); \
{ \
@ -1055,7 +1055,7 @@ void tst_QSettings::testVariantTypes()
QList<QVariant> l3;
QDate date = QDate::currentDate();
QTime time = QTime::currentTime();
l3 << QString("ene") << 10 << qVariantFromValue(QColor(1, 2, 3)) << QVariant(QRect(1, 2, 3, 4))
l3 << QString("ene") << 10 << QVariant::fromValue(QColor(1, 2, 3)) << QVariant(QRect(1, 2, 3, 4))
<< QVariant(QSize(4, 56)) << QVariant(QPoint(4, 2)) << true << false << date << time;
testVal("key3", l3, QVariantList, List);

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

@ -535,27 +535,27 @@ void tst_QItemModel::data()
// General Purpose roles
QVariant variant = currentModel->data(currentModel->index(0,0), Qt::ToolTipRole);
if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QString>(variant));
QVERIFY(variant.canConvert<QString>());
}
variant = currentModel->data(currentModel->index(0,0), Qt::StatusTipRole);
if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QString>(variant));
QVERIFY(variant.canConvert<QString>());
}
variant = currentModel->data(currentModel->index(0,0), Qt::WhatsThisRole);
if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QString>(variant));
QVERIFY(variant.canConvert<QString>());
}
variant = currentModel->data(currentModel->index(0,0), Qt::SizeHintRole);
if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QSize>(variant));
QVERIFY(variant.canConvert<QSize>());
}
// Appearance roles
QVariant fontVariant = currentModel->data(currentModel->index(0,0), Qt::FontRole);
if (fontVariant.isValid()) {
QVERIFY(qVariantCanConvert<QFont>(fontVariant));
QVERIFY(fontVariant.canConvert<QFont>());
}
QVariant textAlignmentVariant = currentModel->data(currentModel->index(0,0), Qt::TextAlignmentRole);
@ -569,12 +569,12 @@ void tst_QItemModel::data()
QVariant colorVariant = currentModel->data(currentModel->index(0,0), Qt::BackgroundColorRole);
if (colorVariant.isValid()) {
QVERIFY(qVariantCanConvert<QColor>(colorVariant));
QVERIFY(colorVariant.canConvert<QColor>());
}
colorVariant = currentModel->data(currentModel->index(0,0), Qt::TextColorRole);
if (colorVariant.isValid()) {
QVERIFY(qVariantCanConvert<QColor>(colorVariant));
QVERIFY(colorVariant.canConvert<QColor>());
}
QVariant checkStateVariant = currentModel->data(currentModel->index(0,0), Qt::CheckStateRole);

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

@ -260,7 +260,7 @@ Q_DECLARE_METATYPE(TestSpace::Foo)
void tst_QMetaType::namespaces()
{
TestSpace::Foo nf = { 11.12 };
QVariant v = qVariantFromValue(nf);
QVariant v = QVariant::fromValue(nf);
QCOMPARE(qvariant_cast<TestSpace::Foo>(v).d, 11.12);
}

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

@ -2051,12 +2051,12 @@ void tst_QObject::property()
CustomType *customPointer = 0;
QVariant customVariant = object.property("custom");
customPointer = qVariantValue<CustomType *>(customVariant);
customPointer = qvariant_cast<CustomType *>(customVariant);
QCOMPARE(customPointer, object.custom());
CustomType custom;
customPointer = &custom;
qVariantSetValue(customVariant, customPointer);
customVariant.setValue(customPointer);
property = mo->property(mo->indexOfProperty("custom"));
QVERIFY(property.isWritable());
@ -2068,7 +2068,7 @@ void tst_QObject::property()
QCOMPARE(object.custom(), customPointer);
customVariant = object.property("custom");
customPointer = qVariantValue<CustomType *>(customVariant);
customPointer = qvariant_cast<CustomType *>(customVariant);
QCOMPARE(object.custom(), customPointer);
// this enum property has a meta type, but it's not yet registered, so we know this fails
@ -2101,22 +2101,22 @@ void tst_QObject::property()
var = object.property("priority");
QVERIFY(!var.isNull());
QVERIFY(qVariantCanConvert<PropertyObject::Priority>(var));
QCOMPARE(qVariantValue<PropertyObject::Priority>(var), PropertyObject::High);
QVERIFY(var.canConvert<PropertyObject::Priority>());
QCOMPARE(qvariant_cast<PropertyObject::Priority>(var), PropertyObject::High);
object.setPriority(PropertyObject::Low);
QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::Low);
QCOMPARE(qvariant_cast<PropertyObject::Priority>(object.property("priority")), PropertyObject::Low);
QVERIFY(object.setProperty("priority", PropertyObject::VeryHigh));
QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::VeryHigh);
QCOMPARE(qvariant_cast<PropertyObject::Priority>(object.property("priority")), PropertyObject::VeryHigh);
QVERIFY(object.setProperty("priority", "High"));
QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::High);
QCOMPARE(qvariant_cast<PropertyObject::Priority>(object.property("priority")), PropertyObject::High);
QVERIFY(!object.setProperty("priority", QVariant()));
var = object.property("priority");
QCOMPARE(qVariantValue<PropertyObject::Priority>(var), PropertyObject::High);
QCOMPARE(qvariant_cast<PropertyObject::Priority>(var), PropertyObject::High);
object.setPriority(PropertyObject::Low);
QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::Low);
QCOMPARE(qvariant_cast<PropertyObject::Priority>(object.property("priority")), PropertyObject::Low);
object.setProperty("priority", var);
QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::High);
QCOMPARE(qvariant_cast<PropertyObject::Priority>(object.property("priority")), PropertyObject::High);
qRegisterMetaType<CustomString>("CustomString");
QVERIFY(mo->indexOfProperty("customString") != -1);
@ -3002,10 +3002,10 @@ void tst_QObject::floatProperty()
QVERIFY(prop.isValid());
QVERIFY(prop.type() == uint(QMetaType::type("float")));
QVERIFY(!prop.write(&obj, QVariant("Hello")));
QVERIFY(prop.write(&obj, qVariantFromValue(128.0f)));
QVERIFY(prop.write(&obj, QVariant::fromValue(128.0f)));
QVariant v = prop.read(&obj);
QVERIFY(int(v.userType()) == QMetaType::Float);
QVERIFY(qVariantValue<float>(v) == 128.0f);
QVERIFY(qvariant_cast<float>(v) == 128.0f);
}
void tst_QObject::qrealProperty()
@ -3018,15 +3018,15 @@ void tst_QObject::qrealProperty()
QVERIFY(prop.type() == uint(QMetaType::type("qreal")));
QVERIFY(!prop.write(&obj, QVariant("Hello")));
QVERIFY(prop.write(&obj, qVariantFromValue(128.0f)));
QVERIFY(prop.write(&obj, QVariant::fromValue(128.0f)));
QVariant v = prop.read(&obj);
QCOMPARE(v.userType(), qMetaTypeId<qreal>());
QVERIFY(qVariantValue<qreal>(v) == 128.0);
QVERIFY(qvariant_cast<qreal>(v) == 128.0);
QVERIFY(prop.write(&obj, qVariantFromValue(double(127))));
QVERIFY(prop.write(&obj, QVariant::fromValue(double(127))));
v = prop.read(&obj);
QCOMPARE(v.userType(), qMetaTypeId<qreal>());
QVERIFY(qVariantValue<qreal>(v) == 127.0);
QVERIFY(qvariant_cast<qreal>(v) == 127.0);
}
class DynamicPropertyObject : public PropertyObject

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

@ -512,20 +512,20 @@ void tst_QVariant::canConvert_data()
QVariant var(QBitArray(0));
QTest::newRow("BitArray")
<< var << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QBitmap());
var = QVariant::fromValue(QBitmap());
QTest::newRow("Bitmap")
<< var << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QBrush());
var = QVariant::fromValue(QBrush());
QTest::newRow("Brush")
<< var << N << N << N << Y << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant(QByteArray());
QTest::newRow("ByteArray")
<< var << N << N << Y << N << Y << Y << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
var = qVariantFromValue(QColor());
var = QVariant::fromValue(QColor());
QTest::newRow("Color")
<< var << N << N << N << Y << Y << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
#ifndef QT_NO_CURSOR
var = qVariantFromValue(QCursor());
var = QVariant::fromValue(QCursor());
QTest::newRow("Cursor")
<< var << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
#endif
@ -541,13 +541,13 @@ void tst_QVariant::canConvert_data()
var = QVariant(0.1f);
QTest::newRow("Float")
<< var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
var = qVariantFromValue(QFont());
var = QVariant::fromValue(QFont());
QTest::newRow("Font")
<< var << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
var = qVariantFromValue(QIcon());
var = QVariant::fromValue(QIcon());
QTest::newRow("Icon")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QImage());
var = QVariant::fromValue(QImage());
QTest::newRow("Image")
<< var << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant((int)1);
@ -556,7 +556,7 @@ void tst_QVariant::canConvert_data()
var = QVariant();
QTest::newRow("Invalid")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QKeySequence());
var = QVariant::fromValue(QKeySequence());
QTest::newRow("KeySequence")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << Y << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
var = QVariant(QList<QVariant>());
@ -568,16 +568,16 @@ void tst_QVariant::canConvert_data()
var = QVariant(QMap<QString,QVariant>());
QTest::newRow("Map")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QPalette());
var = QVariant::fromValue(QPalette());
QTest::newRow("Palette")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QPen());
var = QVariant::fromValue(QPen());
QTest::newRow("Pen")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QPixmap());
var = QVariant::fromValue(QPixmap());
QTest::newRow("Pixmap")
<< var << N << Y << N << Y << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QPolygon());
var = QVariant::fromValue(QPolygon());
QTest::newRow("PointArray")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = QVariant(QPoint());
@ -586,13 +586,13 @@ void tst_QVariant::canConvert_data()
var = QVariant(QRect());
QTest::newRow("Rect")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N;
var = qVariantFromValue(QRegion());
var = QVariant::fromValue(QRegion());
QTest::newRow("Region")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N;
var = QVariant(QSize());
QTest::newRow("Size")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N;
var = qVariantFromValue(QSizePolicy());
var = QVariant::fromValue(QSizePolicy());
QTest::newRow("SizePolicy")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N;
var = QVariant(QString());
@ -713,7 +713,7 @@ void tst_QVariant::toInt_data()
QTest::newRow( "signedint-string" ) << QVariant( QString("-123") ) << -123 << true;
QTest::newRow( "signedlonglong0" ) << QVariant( (qlonglong)-34 ) << -34 << true;
QTest::newRow( "QChar" ) << QVariant(QChar('a')) << int('a') << true;
QTest::newRow( "keysequence" ) << qVariantFromValue( QKeySequence( Qt::Key_A ) ) << 65 << true;
QTest::newRow( "keysequence" ) << QVariant::fromValue( QKeySequence( Qt::Key_A ) ) << 65 << true;
QByteArray bytearray(4, ' ');
bytearray[0] = 'T';
bytearray[1] = 'e';
@ -1020,7 +1020,7 @@ void tst_QVariant::toColor()
QFETCH( QColor, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Color ) );
QColor d = qVariantValue<QColor>(value);
QColor d = qvariant_cast<QColor>(value);
QCOMPARE( d, result );
}
@ -1044,7 +1044,7 @@ void tst_QVariant::toPixmap()
QFETCH( QPixmap, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Pixmap ) );
QPixmap d = qVariantValue<QPixmap>(value);
QPixmap d = qvariant_cast<QPixmap>(value);
QCOMPARE( d, result );
}
@ -1064,7 +1064,7 @@ void tst_QVariant::toImage()
QFETCH( QImage, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Image ) );
QImage d = qVariantValue<QImage>(value);
QImage d = qvariant_cast<QImage>(value);
QCOMPARE( d, result );
}
@ -1086,7 +1086,7 @@ void tst_QVariant::toBrush()
QFETCH( QBrush, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Brush ) );
QBrush d = qVariantValue<QBrush>(value);
QBrush d = qvariant_cast<QBrush>(value);
QCOMPARE( d, result );
}
@ -1105,7 +1105,7 @@ void tst_QVariant::toFont()
QFETCH( QFont, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Font ) );
QFont d = qVariantValue<QFont>(value);
QFont d = qvariant_cast<QFont>(value);
QCOMPARE( d, result );
}
@ -1129,7 +1129,7 @@ void tst_QVariant::toKeySequence()
QFETCH( QKeySequence, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::KeySequence ) );
QKeySequence d = qVariantValue<QKeySequence>(value);
QKeySequence d = qvariant_cast<QKeySequence>(value);
QCOMPARE( d, result );
}
@ -1291,7 +1291,7 @@ void tst_QVariant::toString_data()
QTest::newRow( "qdate" ) << QVariant( QDate( 2002, 1, 1 ) ) << QString( "2002-01-01" );
QTest::newRow( "qtime" ) << QVariant( QTime( 12, 34, 56 ) ) << QString( "12:34:56" );
QTest::newRow( "qdatetime" ) << QVariant( QDateTime( QDate( 2002, 1, 1 ), QTime( 12, 34, 56 ) ) ) << QString( "2002-01-01T12:34:56" );
QTest::newRow( "qkeysequence" ) << qVariantFromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) )
QTest::newRow( "qkeysequence" ) << QVariant::fromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) )
#ifndef Q_OS_MAC
<< QString( "Ctrl+A" );
#else
@ -1299,8 +1299,8 @@ void tst_QVariant::toString_data()
#endif
QFont font( "times", 12 );
QTest::newRow( "qfont" ) << qVariantFromValue( font ) << QString("times,12,-1,5,50,0,0,0,0,0");
QTest::newRow( "qcolor" ) << qVariantFromValue( QColor( 10, 10, 10 ) ) << QString( "#0a0a0a" );
QTest::newRow( "qfont" ) << QVariant::fromValue( font ) << QString("times,12,-1,5,50,0,0,0,0,0");
QTest::newRow( "qcolor" ) << QVariant::fromValue( QColor( 10, 10, 10 ) ) << QString( "#0a0a0a" );
QTest::newRow( "llong" ) << QVariant( (qlonglong)Q_INT64_C(123456789012) ) <<
QString( "123456789012" );
}
@ -1407,10 +1407,10 @@ void tst_QVariant::toRegularExpression()
void tst_QVariant::matrix()
{
QVariant variant;
QMatrix matrix = qVariantValue<QMatrix>(variant);
QMatrix matrix = qvariant_cast<QMatrix>(variant);
QVERIFY(matrix.isIdentity());
qVariantSetValue(variant, QMatrix().rotate(90));
QCOMPARE(QMatrix().rotate(90), qVariantValue<QMatrix>(variant));
variant.setValue(QMatrix().rotate(90));
QCOMPARE(QMatrix().rotate(90), qvariant_cast<QMatrix>(variant));
void *mmatrix = QMetaType::create(QVariant::Matrix, 0);
QVERIFY(mmatrix);
@ -1420,12 +1420,12 @@ void tst_QVariant::matrix()
void tst_QVariant::matrix4x4()
{
QVariant variant;
QMatrix4x4 matrix = qVariantValue<QMatrix4x4>(variant);
QMatrix4x4 matrix = qvariant_cast<QMatrix4x4>(variant);
QVERIFY(matrix.isIdentity());
QMatrix4x4 m;
m.scale(2.0f);
qVariantSetValue(variant, m);
QCOMPARE(m, qVariantValue<QMatrix4x4>(variant));
variant.setValue(m);
QCOMPARE(m, qvariant_cast<QMatrix4x4>(variant));
void *mmatrix = QMetaType::create(QVariant::Matrix4x4, 0);
QVERIFY(mmatrix);
@ -1435,10 +1435,10 @@ void tst_QVariant::matrix4x4()
void tst_QVariant::transform()
{
QVariant variant;
QTransform matrix = qVariantValue<QTransform>(variant);
QTransform matrix = qvariant_cast<QTransform>(variant);
QVERIFY(matrix.isIdentity());
qVariantSetValue(variant, QTransform().rotate(90));
QCOMPARE(QTransform().rotate(90), qVariantValue<QTransform>(variant));
variant.setValue(QTransform().rotate(90));
QCOMPARE(QTransform().rotate(90), qvariant_cast<QTransform>(variant));
void *mmatrix = QMetaType::create(QVariant::Transform, 0);
QVERIFY(mmatrix);
@ -1449,10 +1449,10 @@ void tst_QVariant::transform()
void tst_QVariant::vector2D()
{
QVariant variant;
QVector2D vector = qVariantValue<QVector2D>(variant);
QVector2D vector = qvariant_cast<QVector2D>(variant);
QVERIFY(vector.isNull());
qVariantSetValue(variant, QVector2D(0.1, 0.2));
QCOMPARE(QVector2D(0.1, 0.2), qVariantValue<QVector2D>(variant));
variant.setValue(QVector2D(0.1, 0.2));
QCOMPARE(QVector2D(0.1, 0.2), qvariant_cast<QVector2D>(variant));
void *pvector = QMetaType::create(QVariant::Vector2D, 0);
QVERIFY(pvector);
@ -1462,10 +1462,10 @@ void tst_QVariant::vector2D()
void tst_QVariant::vector3D()
{
QVariant variant;
QVector3D vector = qVariantValue<QVector3D>(variant);
QVector3D vector = qvariant_cast<QVector3D>(variant);
QVERIFY(vector.isNull());
qVariantSetValue(variant, QVector3D(0.1, 0.2, 0.3));
QCOMPARE(QVector3D(0.1, 0.2, 0.3), qVariantValue<QVector3D>(variant));
variant.setValue(QVector3D(0.1, 0.2, 0.3));
QCOMPARE(QVector3D(0.1, 0.2, 0.3), qvariant_cast<QVector3D>(variant));
void *pvector = QMetaType::create(QVariant::Vector3D, 0);
QVERIFY(pvector);
@ -1475,10 +1475,10 @@ void tst_QVariant::vector3D()
void tst_QVariant::vector4D()
{
QVariant variant;
QVector4D vector = qVariantValue<QVector4D>(variant);
QVector4D vector = qvariant_cast<QVector4D>(variant);
QVERIFY(vector.isNull());
qVariantSetValue(variant, QVector4D(0.1, 0.2, 0.3, 0.4));
QCOMPARE(QVector4D(0.1, 0.2, 0.3, 0.4), qVariantValue<QVector4D>(variant));
variant.setValue(QVector4D(0.1, 0.2, 0.3, 0.4));
QCOMPARE(QVector4D(0.1, 0.2, 0.3, 0.4), qvariant_cast<QVector4D>(variant));
void *pvector = QMetaType::create(QVariant::Vector4D, 0);
QVERIFY(pvector);
@ -1488,10 +1488,10 @@ void tst_QVariant::vector4D()
void tst_QVariant::quaternion()
{
QVariant variant;
QQuaternion quaternion = qVariantValue<QQuaternion>(variant);
QQuaternion quaternion = qvariant_cast<QQuaternion>(variant);
QVERIFY(quaternion.isIdentity());
qVariantSetValue(variant, QQuaternion(0.1, 0.2, 0.3, 0.4));
QCOMPARE(QQuaternion(0.1, 0.2, 0.3, 0.4), qVariantValue<QQuaternion>(variant));
variant.setValue(QQuaternion(0.1, 0.2, 0.3, 0.4));
QCOMPARE(QQuaternion(0.1, 0.2, 0.3, 0.4), qvariant_cast<QQuaternion>(variant));
void *pquaternion = QMetaType::create(QVariant::Quaternion, 0);
QVERIFY(pquaternion);
@ -1548,14 +1548,14 @@ void tst_QVariant::writeToReadFromDataStream_data()
bytearray[3] = 't';
bytearray[4] = '\0';
QTest::newRow( "bytearray_valid" ) << QVariant( bytearray ) << false;
QTest::newRow( "bitmap_invalid" ) << qVariantFromValue( QBitmap() ) << true;
QTest::newRow( "bitmap_invalid" ) << QVariant::fromValue( QBitmap() ) << true;
QBitmap bitmap( 10, 10 );
bitmap.fill( Qt::red );
QTest::newRow( "bitmap_valid" ) << qVariantFromValue( bitmap ) << false;
QTest::newRow( "brush_valid" ) << qVariantFromValue( QBrush( Qt::red ) ) << false;
QTest::newRow( "color_valid" ) << qVariantFromValue( QColor( Qt::red ) ) << false;
QTest::newRow( "bitmap_valid" ) << QVariant::fromValue( bitmap ) << false;
QTest::newRow( "brush_valid" ) << QVariant::fromValue( QBrush( Qt::red ) ) << false;
QTest::newRow( "color_valid" ) << QVariant::fromValue( QColor( Qt::red ) ) << false;
#ifndef QT_NO_CURSOR
QTest::newRow( "cursor_valid" ) << qVariantFromValue( QCursor( Qt::PointingHandCursor ) ) << false;
QTest::newRow( "cursor_valid" ) << QVariant::fromValue( QCursor( Qt::PointingHandCursor ) ) << false;
#endif
QTest::newRow( "date_invalid" ) << QVariant( QDate() ) << true;
QTest::newRow( "date_valid" ) << QVariant( QDate( 2002, 07, 06 ) ) << false;
@ -1563,14 +1563,14 @@ void tst_QVariant::writeToReadFromDataStream_data()
QTest::newRow( "datetime_valid" ) << QVariant( QDateTime( QDate( 2002, 07, 06 ), QTime( 14, 0, 0 ) ) ) << false;
QTest::newRow( "double_valid" ) << QVariant( 123.456 ) << false;
QTest::newRow( "float_valid" ) << QVariant( 123.456f ) << false;
QTest::newRow( "font_valid" ) << qVariantFromValue( QFont( "times", 12 ) ) << false;
QTest::newRow( "pixmap_invalid" ) << qVariantFromValue( QPixmap() ) << true;
QTest::newRow( "font_valid" ) << QVariant::fromValue( QFont( "times", 12 ) ) << false;
QTest::newRow( "pixmap_invalid" ) << QVariant::fromValue( QPixmap() ) << true;
QPixmap pixmap( 10, 10 );
pixmap.fill( Qt::red );
QTest::newRow( "pixmap_valid" ) << qVariantFromValue( pixmap ) << false;
QTest::newRow( "pixmap_valid" ) << QVariant::fromValue( pixmap ) << false;
// QTest::newRow( "iconset_valid" ) << QVariant( QIcon( pixmap ) ) << false;
QTest::newRow( "image_invalid" ) << qVariantFromValue( QImage() ) << true;
QTest::newRow( "keysequence_valid" ) << qVariantFromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) ) << false;
QTest::newRow( "image_invalid" ) << QVariant::fromValue( QImage() ) << true;
QTest::newRow( "keysequence_valid" ) << QVariant::fromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) ) << false;
QTest::newRow( "int_valid" ) << QVariant( -123 ) << false;
typedef QMap<QString, QVariant> variantsMap;
variantsMap vMap;
@ -1579,15 +1579,15 @@ void tst_QVariant::writeToReadFromDataStream_data()
vMap.insert( "double", QVariant( 3.45 ) );
vMap.insert( "float", QVariant( 3.45f ) );
QTest::newRow( "map_valid" ) << QVariant( vMap ) << false;
QTest::newRow( "palette_valid" ) << qVariantFromValue(QPalette(QColor("turquoise"))) << false;
QTest::newRow( "pen_valid" ) << qVariantFromValue( QPen( Qt::red ) ) << false;
QTest::newRow( "pointarray_invalid" ) << qVariantFromValue( QPolygon() ) << true;
QTest::newRow( "pointarray_valid" ) << qVariantFromValue( QPolygon( QRect( 10, 10, 20, 20 ) ) ) << false;
QTest::newRow( "region_invalid" ) << qVariantFromValue( QRegion() ) << true;
QTest::newRow( "region_valid" ) << qVariantFromValue( QRegion( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "sizepolicy_valid" ) << qVariantFromValue( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ) << false;
QTest::newRow( "point_invalid" ) << qVariantFromValue( QPoint() ) << true;
QTest::newRow( "point_valid" ) << qVariantFromValue( QPoint( 10, 10 ) ) << false;
QTest::newRow( "palette_valid" ) << QVariant::fromValue(QPalette(QColor("turquoise"))) << false;
QTest::newRow( "pen_valid" ) << QVariant::fromValue( QPen( Qt::red ) ) << false;
QTest::newRow( "pointarray_invalid" ) << QVariant::fromValue( QPolygon() ) << true;
QTest::newRow( "pointarray_valid" ) << QVariant::fromValue( QPolygon( QRect( 10, 10, 20, 20 ) ) ) << false;
QTest::newRow( "region_invalid" ) << QVariant::fromValue( QRegion() ) << true;
QTest::newRow( "region_valid" ) << QVariant::fromValue( QRegion( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "sizepolicy_valid" ) << QVariant::fromValue( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ) << false;
QTest::newRow( "point_invalid" ) << QVariant::fromValue( QPoint() ) << true;
QTest::newRow( "point_valid" ) << QVariant::fromValue( QPoint( 10, 10 ) ) << false;
QTest::newRow( "rect_invalid" ) << QVariant( QRect() ) << true;
QTest::newRow( "rect_valid" ) << QVariant( QRect( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "size_invalid" ) << QVariant( QSize( 0, 0 ) ) << true;
@ -2132,7 +2132,7 @@ void tst_QVariant::userType()
{
QVariant userVar;
qVariantSetValue(userVar, data);
userVar.setValue(data);
QCOMPARE(userVar.type(), QVariant::UserType);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType>());
@ -2143,7 +2143,7 @@ void tst_QVariant::userType()
QVariant userVar2(userVar);
QVERIFY(userVar == userVar2);
qVariantSetValue(userVar2, data2);
userVar2.setValue(data2);
QVERIFY(userVar != userVar2);
const MyType *varData = static_cast<const MyType *>(userVar.constData());
@ -2152,7 +2152,7 @@ void tst_QVariant::userType()
QCOMPARE(varData->text, data.text);
QVariant userVar3;
qVariantSetValue(userVar3, data2);
userVar3.setValue(data2);
userVar3 = userVar2;
QVERIFY(userVar2 == userVar3);
@ -2161,7 +2161,7 @@ void tst_QVariant::userType()
QCOMPARE(instanceCount, 2);
{
QVariant userVar;
qVariantSetValue(userVar, &data);
userVar.setValue(&data);
QCOMPARE(userVar.type(), QVariant::UserType);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType*>());
@ -2172,7 +2172,7 @@ void tst_QVariant::userType()
QVariant userVar2(userVar);
QVERIFY(userVar == userVar2);
qVariantSetValue(userVar2, &data2);
userVar2.setValue(&data2);
QVERIFY(userVar != userVar2);
MyType * const*varData = reinterpret_cast<MyType *const *>(userVar.constData());
@ -2180,7 +2180,7 @@ void tst_QVariant::userType()
QCOMPARE(*varData, &data);
QVariant userVar3;
qVariantSetValue(userVar3, &data2);
userVar3.setValue(&data2);
/* This check is correct now. userVar2 contains a pointer to data2 and so
* does userVar3. */
@ -2192,7 +2192,7 @@ void tst_QVariant::userType()
QCOMPARE(instanceCount, 2);
QVariant myCarrier;
qVariantSetValue(myCarrier, data);
myCarrier.setValue(data);
QCOMPARE(instanceCount, 3);
{
QVariant second = myCarrier;
@ -2203,7 +2203,7 @@ void tst_QVariant::userType()
QCOMPARE(instanceCount, 3);
MyType data3(0, "null");
data3 = qVariantValue<MyType>(myCarrier);
data3 = qvariant_cast<MyType>(myCarrier);
QCOMPARE(data3.number, 1);
QCOMPARE(data3.text, (const char *)"eins");
#ifndef Q_CC_SUN
@ -2216,7 +2216,7 @@ void tst_QVariant::userType()
const MyType data(3, "drei");
QVariant myCarrier;
qVariantSetValue(myCarrier, data);
myCarrier.setValue(data);
QCOMPARE(myCarrier.typeName(), "MyType");
const MyType data2 = qvariant_cast<MyType>(myCarrier);
@ -2228,7 +2228,7 @@ void tst_QVariant::userType()
short s = 42;
QVariant myCarrier;
qVariantSetValue(myCarrier, s);
myCarrier.setValue(s);
QCOMPARE((int)qvariant_cast<short>(myCarrier), 42);
}
@ -2236,7 +2236,7 @@ void tst_QVariant::userType()
qlonglong ll = Q_INT64_C(42);
QVariant myCarrier;
qVariantSetValue(myCarrier, ll);
myCarrier.setValue(ll);
QCOMPARE(qvariant_cast<int>(myCarrier), 42);
}
@ -2257,14 +2257,14 @@ void tst_QVariant::podUserType()
pod.a = 10;
pod.b = 20;
QVariant pod_as_variant = qVariantFromValue(pod);
QVariant pod_as_variant = QVariant::fromValue(pod);
MyTypePOD pod2 = qvariant_cast<MyTypePOD>(pod_as_variant);
QCOMPARE(pod.a, pod2.a);
QCOMPARE(pod.b, pod2.b);
qVariantSetValue(pod_as_variant, pod);
pod2 = qVariantValue<MyTypePOD>(pod_as_variant);
pod_as_variant.setValue(pod);
pod2 = qvariant_cast<MyTypePOD>(pod_as_variant);
QCOMPARE(pod.a, pod2.a);
QCOMPARE(pod.b, pod2.b);
@ -2331,7 +2331,7 @@ void tst_QVariant::data()
v = f;
QVERIFY(v.data());
QCOMPARE(*static_cast<float *>(v.data()), qVariantValue<float>(v));
QCOMPARE(*static_cast<float *>(v.data()), qvariant_cast<float>(v));
v = ll;
QVERIFY(v.data());
@ -2410,12 +2410,12 @@ void tst_QVariant::variant_to()
QStringList sl;
sl << QLatin1String("blah");
qVariantSetValue(v3, sl);
v3.setValue(sl);
Foo foo;
foo.i = 42;
qVariantSetValue(v4, foo);
v4.setValue(foo);
QCOMPARE(qvariant_cast<double>(v1), 4.2);
QCOMPARE(qvariant_cast<float>(v1), 4.2f);
@ -2430,7 +2430,7 @@ void tst_QVariant::variant_to()
QCOMPARE(qvariant_cast<int>(v1), 4);
QVariant n = qVariantFromValue<short>(42);
QVariant n = QVariant::fromValue<short>(42);
QCOMPARE(qvariant_cast<int>(n), 42);
QCOMPARE(qvariant_cast<uint>(n), 42u);
QCOMPARE(qvariant_cast<double>(n), 42.0);
@ -2438,7 +2438,7 @@ void tst_QVariant::variant_to()
QCOMPARE(qvariant_cast<short>(n), short(42));
QCOMPARE(qvariant_cast<ushort>(n), ushort(42));
n = qVariantFromValue(43l);
n = QVariant::fromValue(43l);
QCOMPARE(qvariant_cast<int>(n), 43);
QCOMPARE(qvariant_cast<uint>(n), 43u);
QCOMPARE(qvariant_cast<double>(n), 43.0);
@ -2450,7 +2450,7 @@ void tst_QVariant::variant_to()
QCOMPARE(qvariant_cast<ulong>(n), 44ul);
QCOMPARE(qvariant_cast<float>(n), 44.0f);
QCOMPARE(qVariantFromValue(0.25f).toDouble(), 0.25);
QCOMPARE(QVariant::fromValue(0.25f).toDouble(), 0.25);
}
struct Blah { int i; };
@ -2502,10 +2502,10 @@ void tst_QVariant::url()
QVariant v3(str); //built with a QString
QCOMPARE(v2.toUrl(), url);
QVERIFY(qVariantCanConvert<QUrl>(v3));
QVERIFY(v3.canConvert<QUrl>());
QCOMPARE(v2.toUrl(), v3.toUrl());
QVERIFY(qVariantCanConvert<QString>(v2));
QVERIFY(v2.canConvert<QString>());
QCOMPARE(v2.toString(), str);
QCOMPARE(v3.toString(), str);
}
@ -2514,7 +2514,7 @@ void tst_QVariant::globalColor()
{
QVariant variant(Qt::blue);
QVERIFY(variant.type() == QVariant::Color);
QVERIFY(qVariantValue<QColor>(variant) == QColor(Qt::blue));
QVERIFY(qvariant_cast<QColor>(variant) == QColor(Qt::blue));
}
void tst_QVariant::variantMap()
@ -2687,7 +2687,7 @@ void tst_QVariant::convertToQUint8() const
* It's of type QVariant::Int. */
const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<qint8>(v0));
QVERIFY(v0.canConvert<qint8>());
QCOMPARE(int(qvariant_cast<qint8>(v0)), 32);
QCOMPARE(int(v0.toInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
@ -2705,7 +2705,7 @@ void tst_QVariant::convertToQUint8() const
const quint8 anInt = 32;
const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<quint8>(v0));
QVERIFY(v0.canConvert<quint8>());
QCOMPARE(int(qvariant_cast<quint8>(v0)), 32);
QCOMPARE(int(v0.toUInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
@ -2716,7 +2716,7 @@ void tst_QVariant::convertToQUint8() const
const qint16 anInt = 32;
const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<qint16>(v0));
QVERIFY(v0.canConvert<qint16>());
QCOMPARE(int(qvariant_cast<qint16>(v0)), 32);
QCOMPARE(int(v0.toInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
@ -2727,7 +2727,7 @@ void tst_QVariant::convertToQUint8() const
const quint16 anInt = 32;
const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<quint16>(v0));
QVERIFY(v0.canConvert<quint16>());
QCOMPARE(int(qvariant_cast<quint16>(v0)), 32);
QCOMPARE(int(v0.toUInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
@ -2742,8 +2742,8 @@ void tst_QVariant::comparePointers() const
MyClass myClass;
QVariant v = qVariantFromValue<void *>(&myClass);
QVariant v2 = qVariantFromValue<void *>(&myClass);
QVariant v = QVariant::fromValue<void *>(&myClass);
QVariant v2 = QVariant::fromValue<void *>(&myClass);
QCOMPARE(v, v2);
}
@ -2758,15 +2758,15 @@ void tst_QVariant::voidStar() const
void *p2 = p1;
QVariant v1, v2;
v1 = qVariantFromValue(p1);
v1 = QVariant::fromValue(p1);
v2 = v1;
QVERIFY(v1 == v2);
v2 = qVariantFromValue(p2);
v2 = QVariant::fromValue(p2);
QVERIFY(v1 == v2);
p2 = 0;
v2 = qVariantFromValue(p2);
v2 = QVariant::fromValue(p2);
QVERIFY(v1 != v2);
}
@ -2775,14 +2775,14 @@ void tst_QVariant::dataStar() const
qRegisterMetaType<Data*>();
Data *p1 = new Data;
QVariant v1 = qVariantFromValue(p1);
QVariant v1 = QVariant::fromValue(p1);
QCOMPARE(v1.userType(), qMetaTypeId<Data*>());
QCOMPARE(qvariant_cast<Data*>(v1), p1);
QVariant v2 = v1;
QVERIFY(v1 == v2);
v2 = qVariantFromValue(p1);
v2 = QVariant::fromValue(p1);
QVERIFY(v1 == v2);
delete p1;
}
@ -2820,10 +2820,10 @@ void tst_QVariant::canConvertQStringList_data() const
template<typename T> void convertMetaType()
{
QVERIFY(qVariantFromValue<T>(10).isValid());
QVERIFY(qVariantFromValue<T>(10).canConvert(QVariant::Int));
QCOMPARE(qVariantFromValue<T>(10).toInt(), 10);
QCOMPARE(qVariantFromValue<T>(10), qVariantFromValue<T>(10));
QVERIFY(QVariant::fromValue<T>(10).isValid());
QVERIFY(QVariant::fromValue<T>(10).canConvert(QVariant::Int));
QCOMPARE(QVariant::fromValue<T>(10).toInt(), 10);
QCOMPARE(QVariant::fromValue<T>(10), QVariant::fromValue<T>(10));
}
#define CONVERT_META_TYPE(Type) \
@ -2947,11 +2947,11 @@ void tst_QVariant::compareCustomTypes() const
WontCompare f1;
f1.x = 0;
const QVariant variant1(qVariantFromValue(f1));
const QVariant variant1(QVariant::fromValue(f1));
WontCompare f2;
f2.x = 0;
const QVariant variant2(qVariantFromValue(f2));
const QVariant variant2(QVariant::fromValue(f2));
/* We compare pointers. */
QVERIFY(variant1 != variant2);
@ -2973,10 +2973,10 @@ void tst_QVariant::copyingUserTypes() const
QVariant var;
QVariant var3;
const QHostAddress ha("127.0.0.1");
qVariantSetValue(var, ha);
var.setValue(ha);
var3 = var;
QCOMPARE(qVariantValue<QHostAddress>(var3), ha);
QCOMPARE(qvariant_cast<QHostAddress>(var3), ha);
}
void tst_QVariant::convertBoolToByteArray() const
@ -2987,7 +2987,7 @@ void tst_QVariant::convertBoolToByteArray() const
const QVariant variant(input);
QCOMPARE(qVariantCanConvert<bool>(variant), canConvert);
QCOMPARE(variant.canConvert<bool>(), canConvert);
if(canConvert) {
/* Just call this function so we run the code path. */
@ -3055,7 +3055,7 @@ void tst_QVariant::convertByteArrayToBool() const
const QVariant variant(input);
QCOMPARE(variant.type(), QVariant::Bool);
QCOMPARE(variant.toBool(), input);
QVERIFY(qVariantCanConvert<bool>(variant));
QVERIFY(variant.canConvert<bool>());
QCOMPARE(variant.toByteArray(), output);
}
@ -3130,7 +3130,7 @@ void tst_QVariant::setValue()
QVERIFY( !v1.isDetached() );
QVERIFY( !v2.isDetached() );
qVariantSetValue(v2, 3); //set an integer value
v2.setValue(3); //set an integer value
QVERIFY( v1.isDetached() );
QVERIFY( v2.isDetached() );
@ -3209,7 +3209,7 @@ template<class T> void playWithVariant(const T &orig, bool isNull, const QString
}
QCOMPARE(qvariant_cast<T>(v2), qvariant_cast<T>(v));
QCOMPARE(v2.toString(), toString);
v3 = qVariantFromValue(orig);
v3 = QVariant::fromValue(orig);
QVERIFY(v3.isValid());
QCOMPARE(v3.isNull(), isNull);

6
tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
View File

@ -526,7 +526,7 @@ void tst_QEasingCurve::properties()
obj.setEasing(inOutBack);
QEasingCurve easing = qVariantValue<QEasingCurve>(obj.property("easing"));
QEasingCurve easing = qvariant_cast<QEasingCurve>(obj.property("easing"));
QCOMPARE(easing.type(), QEasingCurve::InOutBack);
QCOMPARE(easing.overshoot(), overshoot);
QCOMPARE(easing.amplitude(), amplitude);
@ -538,9 +538,9 @@ void tst_QEasingCurve::properties()
period = linear.period();
obj.setProperty("easing",
qVariantFromValue(QEasingCurve(QEasingCurve::Linear)));
QVariant::fromValue(QEasingCurve(QEasingCurve::Linear)));
easing = qVariantValue<QEasingCurve>(obj.property("easing"));
easing = qvariant_cast<QEasingCurve>(obj.property("easing"));
QCOMPARE(easing.type(), QEasingCurve::Linear);
QCOMPARE(easing.overshoot(), overshoot);
QCOMPARE(easing.amplitude(), amplitude);

26
tests/auto/dbus/qdbusabstractadaptor/tst_qdbusabstractadaptor.cpp
View File

@ -1064,11 +1064,11 @@ void tst_QDBusAbstractAdaptor::writeProperties()
valueSpy.clear();
properties.call(QDBus::BlockWithGui, "Set", "local." + name, QString("prop1"),
qVariantFromValue(QDBusVariant(name)));
QVariant::fromValue(QDBusVariant(name)));
QVERIFY(valueSpy.isEmpty()); // call mustn't have succeeded
properties.call(QDBus::BlockWithGui, "Set", "local." + name, QString("prop2"),
qVariantFromValue(QDBusVariant(name)));
QVariant::fromValue(QDBusVariant(name)));
QCOMPARE(valueSpy, name);
QCOMPARE(QString(slotSpy), QString("void %1::setProp2(const QString &)").arg(name));
}
@ -1570,11 +1570,11 @@ void tst_QDBusAbstractAdaptor::writePropertiesPeer()
clearValueSpyPeer();
properties.call(QDBus::BlockWithGui, "Set", "local." + name, QString("prop1"),
qVariantFromValue(QDBusVariant(name)));
QVariant::fromValue(QDBusVariant(name)));
QVERIFY(valueSpyPeer().isEmpty()); // call mustn't have succeeded
properties.call(QDBus::BlockWithGui, "Set", "local." + name, QString("prop2"),
qVariantFromValue(QDBusVariant(name)));
QVariant::fromValue(QDBusVariant(name)));
QCOMPARE(valueSpyPeer(), name);
QCOMPARE(QString(slotSpyPeer()), QString("void %1::setProp2(const QString &)").arg(name));
}
@ -1774,9 +1774,9 @@ void tst_QDBusAbstractAdaptor::typeMatching_data()
QTest::addColumn<QVariant>("value");
QTest::newRow("bool") << "Bool" << "b" << QVariant(true);
QTest::newRow("byte") << "UChar" << "y" << qVariantFromValue(uchar(42));
QTest::newRow("short") << "Short" << "n" << qVariantFromValue(short(-43));
QTest::newRow("ushort") << "UShort" << "q" << qVariantFromValue(ushort(44));
QTest::newRow("byte") << "UChar" << "y" << QVariant::fromValue(uchar(42));
QTest::newRow("short") << "Short" << "n" << QVariant::fromValue(short(-43));
QTest::newRow("ushort") << "UShort" << "q" << QVariant::fromValue(ushort(44));
QTest::newRow("int") << "Int" << "i" << QVariant(42);
QTest::newRow("uint") << "UInt" << "u" << QVariant(42U);
QTest::newRow("qlonglong") << "LongLong" << "x" << QVariant(Q_INT64_C(42));
@ -1784,12 +1784,12 @@ void tst_QDBusAbstractAdaptor::typeMatching_data()
QTest::newRow("double") << "Double" << "d" << QVariant(2.5);
QTest::newRow("string") << "String" << "s" << QVariant("Hello, World!");
QTest::newRow("variant") << "Variant" << "v" << qVariantFromValue(QDBusVariant("Hello again!"));
QTest::newRow("variant") << "Variant" << "v" << QVariant::fromValue(QDBusVariant("Hello again!"));
QTest::newRow("list") << "List" << "av" << QVariant(QVariantList()
<< 42
<< QString("foo")
<< QByteArray("bar")
<< qVariantFromValue(QDBusVariant(QString("baz"))));
<< QVariant::fromValue(QDBusVariant(QString("baz"))));
QTest::newRow("stringlist") << "StringList" << "as" << QVariant(QStringList() << "Hello" << "world");
QTest::newRow("bytearray") << "ByteArray" << "ay" << QVariant(QByteArray("foo"));
@ -1798,24 +1798,24 @@ void tst_QDBusAbstractAdaptor::typeMatching_data()
map["The answer to life, the Universe and everything"] = 42u; // uint
map["In the beginning..."] = QString("There was nothing"); // string
map["but Unix came and said"] = QByteArray("\"Hello, World\""); // bytearray
map["two"] = qVariantFromValue(short(2)); // short
map["two"] = QVariant::fromValue(short(2)); // short
QTest::newRow("map") << "Map" << "a{sv}" << QVariant(map);
StringStringMap ssmap;
ssmap["a"] = "A";
ssmap["A"] = "a";
QTest::newRow("ssmap") << "SSMap" << "a{ss}" << qVariantFromValue(ssmap);
QTest::newRow("ssmap") << "SSMap" << "a{ss}" << QVariant::fromValue(ssmap);
LLDateTimeMap lldtmap;
lldtmap[-1] = QDateTime();
QDateTime now = QDateTime::currentDateTime();
lldtmap[now.toTime_t()] = now; // array of struct of int64 and struct of 3 ints and struct of 4 ints and int
QTest::newRow("lldtmap") << "LLDateTimeMap" << "a{x((iii)(iiii)i)}" << qVariantFromValue(lldtmap);
QTest::newRow("lldtmap") << "LLDateTimeMap" << "a{x((iii)(iiii)i)}" << QVariant::fromValue(lldtmap);
MyStruct s;
s.i = 42;
s.s = "A value";
QTest::newRow("struct") << "Struct" << "(is)" << qVariantFromValue(s);
QTest::newRow("struct") << "Struct" << "(is)" << QVariant::fromValue(s);
}
void tst_QDBusAbstractAdaptor::typeMatching()

8
tests/auto/dbus/qdbusabstractinterface/pinger.h
View File

@ -81,19 +81,19 @@ public:
inline RegisteredType complexProp() const
{ return qvariant_cast< RegisteredType >(property("complexProp")); }
inline void setComplexProp(RegisteredType value)
{ setProperty("complexProp", qVariantFromValue(value)); }
{ setProperty("complexProp", QVariant::fromValue(value)); }
Q_PROPERTY(QString stringProp READ stringProp WRITE setStringProp)
inline QString stringProp() const
{ return qvariant_cast< QString >(property("stringProp")); }
inline void setStringProp(const QString &value)
{ setProperty("stringProp", qVariantFromValue(value)); }
{ setProperty("stringProp", QVariant::fromValue(value)); }
Q_PROPERTY(QDBusVariant variantProp READ variantProp WRITE setVariantProp)
inline QDBusVariant variantProp() const
{ return qvariant_cast< QDBusVariant >(property("variantProp")); }
inline void setVariantProp(const QDBusVariant &value)
{ setProperty("variantProp", qVariantFromValue(value)); }
{ setProperty("variantProp", QVariant::fromValue(value)); }
public Q_SLOTS: // METHODS
inline QDBusPendingReply<RegisteredType> complexMethod()
@ -120,7 +120,7 @@ public Q_SLOTS: // METHODS
inline QDBusPendingReply<int> sleepMethod(int in0)
{
QList<QVariant> argumentList;
argumentList << qVariantFromValue(in0);
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QLatin1String("sleepMethod"), argumentList);
}

8
tests/auto/dbus/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
View File

@ -582,7 +582,7 @@ void tst_QDBusAbstractInterface::variantPropWrite()
QVERIFY2(p, "Not connected to D-Bus");
QDBusVariant expectedValue = QDBusVariant(Q_INT64_C(-47));
QVERIFY(p->setProperty("variantProp", qVariantFromValue(expectedValue)));
QVERIFY(p->setProperty("variantProp", QVariant::fromValue(expectedValue)));
QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant());
}
@ -603,7 +603,7 @@ void tst_QDBusAbstractInterface::complexPropWrite()
QVERIFY2(p, "Not connected to D-Bus");
RegisteredType expectedValue = RegisteredType("This is a value");
QVERIFY(p->setProperty("complexProp", qVariantFromValue(expectedValue)));
QVERIFY(p->setProperty("complexProp", QVariant::fromValue(expectedValue)));
QCOMPARE(targetObj.m_complexProp, expectedValue);
}
@ -652,7 +652,7 @@ void tst_QDBusAbstractInterface::variantPropWritePeer()
resetServer();
QDBusVariant expectedValue = QDBusVariant(Q_INT64_C(-47));
QVERIFY(p->setProperty("variantProp", qVariantFromValue(expectedValue)));
QVERIFY(p->setProperty("variantProp", QVariant::fromValue(expectedValue)));
QEXPECT_FAIL("", "QTBUG-24262 peer tests are broken", Abort);
QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant());
}
@ -676,7 +676,7 @@ void tst_QDBusAbstractInterface::complexPropWritePeer()
resetServer();
RegisteredType expectedValue = RegisteredType("This is a value");
QVERIFY(p->setProperty("complexProp", qVariantFromValue(expectedValue)));
QVERIFY(p->setProperty("complexProp", QVariant::fromValue(expectedValue)));
QEXPECT_FAIL("", "QTBUG-24262 peer tests are broken", Abort);
QCOMPARE(targetObj.m_complexProp, expectedValue);
}

14
tests/auto/dbus/qdbusinterface/tst_qdbusinterface.cpp
View File

@ -161,7 +161,7 @@ int prop1Peer()
void setComplexPropPeer(QList<int> val)
{
QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "setComplexProp");
req << qVariantFromValue(val);
req << QVariant::fromValue(val);
QDBusMessage reply = QDBusConnection::sessionBus().call(req);
}
@ -474,7 +474,7 @@ void tst_QDBusInterface::callMethod()
MyObject::callCount = 0;
// call a SLOT method
QDBusMessage reply = iface.call("ping", qVariantFromValue(QDBusVariant("foo")));
QDBusMessage reply = iface.call("ping", QVariant::fromValue(QDBusVariant("foo")));
QCOMPARE(MyObject::callCount, 1);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -493,7 +493,7 @@ void tst_QDBusInterface::callMethod()
QCOMPARE(dv.variant().toString(), QString("foo"));
// call an INVOKABLE method
reply = iface.call("ping_invokable", qVariantFromValue(QDBusVariant("bar")));
reply = iface.call("ping_invokable", QVariant::fromValue(QDBusVariant("bar")));
QCOMPARE(MyObject::callCount, 2);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -708,7 +708,7 @@ void tst_QDBusInterface::callMethodPeer()
resetPeer();
// call a SLOT method
QDBusMessage reply = iface.call("ping", qVariantFromValue(QDBusVariant("foo")));
QDBusMessage reply = iface.call("ping", QVariant::fromValue(QDBusVariant("foo")));
QCOMPARE(callCountPeer(), 1);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -728,7 +728,7 @@ void tst_QDBusInterface::callMethodPeer()
QCOMPARE(dv.variant().toString(), QString("foo"));
// call an INVOKABLE method
reply = iface.call("ping_invokable", qVariantFromValue(QDBusVariant("bar")));
reply = iface.call("ping_invokable", QVariant::fromValue(QDBusVariant("bar")));
QCOMPARE(callCountPeer(), 2);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -1066,7 +1066,7 @@ void tst_QDBusInterface::complexPropertyWrite()
obj.m_complexProp.clear();
MyObject::callCount = 0;
QVERIFY(iface.setProperty("complexProp", qVariantFromValue(arg)));
QVERIFY(iface.setProperty("complexProp", QVariant::fromValue(arg)));
QCOMPARE(MyObject::callCount, 1);
QCOMPARE(obj.m_complexProp, arg);
}
@ -1129,7 +1129,7 @@ void tst_QDBusInterface::complexPropertyWritePeer()
resetPeer();
QList<int> arg = QList<int>() << -47 << 42;
QVERIFY(iface.setProperty("complexProp", qVariantFromValue(arg)));
QVERIFY(iface.setProperty("complexProp", QVariant::fromValue(arg)));
QCOMPARE(callCountPeer(), 1);
QCOMPARE(complexPropPeer(), arg);
}

4
tests/auto/dbus/qdbuslocalcalls/tst_qdbuslocalcalls.cpp
View File

@ -185,7 +185,7 @@ void tst_QDBusLocalCalls::makeCallsVariant()
QFETCH(QVariant, value);
QDBusMessage callMsg = QDBusMessage::createMethodCall(conn.baseService(),
"/", QString(), "echo");
callMsg << qVariantFromValue(QDBusVariant(value));
callMsg << QVariant::fromValue(QDBusVariant(value));
QDBusMessage replyMsg = doCall(callMsg);
QCOMPARE(int(replyMsg.type()), int(QDBusMessage::ReplyMessage));
@ -222,7 +222,7 @@ void tst_QDBusLocalCalls::makeCallsComplex()
value << 1 << -42 << 47;
QDBusMessage callMsg = QDBusMessage::createMethodCall(conn.baseService(),
"/", QString(), "echo");
callMsg << qVariantFromValue(value);
callMsg << QVariant::fromValue(value);
QDBusMessage replyMsg = doCall(callMsg);
QCOMPARE(int(replyMsg.type()), int(QDBusMessage::ReplyMessage));

352
tests/auto/dbus/qdbusmarshall/tst_qdbusmarshall.cpp
View File

@ -182,9 +182,9 @@ void basicNumericTypes_data()
{
QTest::newRow("bool") << QVariant(false) << "b" << "false";
QTest::newRow("bool2") << QVariant(true) << "b" << "true";
QTest::newRow("byte") << qVariantFromValue(uchar(1)) << "y" << "1";
QTest::newRow("int16") << qVariantFromValue(short(2)) << "n" << "2";
QTest::newRow("uint16") << qVariantFromValue(ushort(3)) << "q" << "3";
QTest::newRow("byte") << QVariant::fromValue(uchar(1)) << "y" << "1";
QTest::newRow("int16") << QVariant::fromValue(short(2)) << "n" << "2";
QTest::newRow("uint16") << QVariant::fromValue(ushort(3)) << "q" << "3";
QTest::newRow("int") << QVariant(1) << "i" << "1";
QTest::newRow("uint") << QVariant(2U) << "u" << "2";
QTest::newRow("int64") << QVariant(Q_INT64_C(3)) << "x" << "3";
@ -195,8 +195,8 @@ void basicNumericTypes_data()
void basicStringTypes_data()
{
QTest::newRow("string") << QVariant("ping") << "s" << "\"ping\"";
QTest::newRow("objectpath") << qVariantFromValue(QDBusObjectPath("/org/kde")) << "o" << "[ObjectPath: /org/kde]";
QTest::newRow("signature") << qVariantFromValue(QDBusSignature("g")) << "g" << "[Signature: g]";
QTest::newRow("objectpath") << QVariant::fromValue(QDBusObjectPath("/org/kde")) << "o" << "[ObjectPath: /org/kde]";
QTest::newRow("signature") << QVariant::fromValue(QDBusSignature("g")) << "g" << "[Signature: g]";
QTest::newRow("emptystring") << QVariant("") << "s" << "\"\"";
QTest::newRow("nullstring") << QVariant(QString()) << "s" << "\"\"";
}
@ -210,17 +210,17 @@ void tst_QDBusMarshall::sendBasic_data()
basicStringTypes_data();
if (fileDescriptorPassing)
QTest::newRow("file-descriptor") << qVariantFromValue(QDBusUnixFileDescriptor(fileDescriptorForTest())) << "h" << "[Unix FD: valid]";
QTest::newRow("file-descriptor") << QVariant::fromValue(QDBusUnixFileDescriptor(fileDescriptorForTest())) << "h" << "[Unix FD: valid]";
}
void tst_QDBusMarshall::sendVariant_data()
{
sendBasic_data();
QTest::newRow("variant") << qVariantFromValue(QDBusVariant(1)) << "v" << "[Variant(int): 1]";
QTest::newRow("variant") << QVariant::fromValue(QDBusVariant(1)) << "v" << "[Variant(int): 1]";
QDBusVariant nested(1);
QTest::newRow("variant-variant") << qVariantFromValue(QDBusVariant(qVariantFromValue(nested))) << "v"
QTest::newRow("variant-variant") << QVariant::fromValue(QDBusVariant(QVariant::fromValue(nested))) << "v"
<< "[Variant(QDBusVariant): [Variant(int): 1]]";
}
@ -252,70 +252,70 @@ void tst_QDBusMarshall::sendArrays_data()
QTest::newRow("bytearray") << QVariant(bytearray) << "ay" << "{102, 111, 111}";
QList<bool> bools;
QTest::newRow("emptyboollist") << qVariantFromValue(bools) << "ab" << "[Argument: ab {}]";
QTest::newRow("emptyboollist") << QVariant::fromValue(bools) << "ab" << "[Argument: ab {}]";
bools << false << true << false;
QTest::newRow("boollist") << qVariantFromValue(bools) << "ab" << "[Argument: ab {false, true, false}]";
QTest::newRow("boollist") << QVariant::fromValue(bools) << "ab" << "[Argument: ab {false, true, false}]";
QList<short> shorts;
QTest::newRow("emptyshortlist") << qVariantFromValue(shorts) << "an" << "[Argument: an {}]";
QTest::newRow("emptyshortlist") << QVariant::fromValue(shorts) << "an" << "[Argument: an {}]";
shorts << 42 << -43 << 44 << 45 << -32768 << 32767;
QTest::newRow("shortlist") << qVariantFromValue(shorts) << "an"
QTest::newRow("shortlist") << QVariant::fromValue(shorts) << "an"
<< "[Argument: an {42, -43, 44, 45, -32768, 32767}]";
QList<ushort> ushorts;
QTest::newRow("emptyushortlist") << qVariantFromValue(ushorts) << "aq" << "[Argument: aq {}]";
QTest::newRow("emptyushortlist") << QVariant::fromValue(ushorts) << "aq" << "[Argument: aq {}]";
ushorts << 12u << 13u << 14u << 15 << 65535;
QTest::newRow("ushortlist") << qVariantFromValue(ushorts) << "aq" << "[Argument: aq {12, 13, 14, 15, 65535}]";
QTest::newRow("ushortlist") << QVariant::fromValue(ushorts) << "aq" << "[Argument: aq {12, 13, 14, 15, 65535}]";
QList<int> ints;
QTest::newRow("emptyintlist") << qVariantFromValue(ints) << "ai" << "[Argument: ai {}]";
QTest::newRow("emptyintlist") << QVariant::fromValue(ints) << "ai" << "[Argument: ai {}]";
ints << 42 << -43 << 44 << 45 << 2147483647 << -2147483647-1;
QTest::newRow("intlist") << qVariantFromValue(ints) << "ai" << "[Argument: ai {42, -43, 44, 45, 2147483647, -2147483648}]";
QTest::newRow("intlist") << QVariant::fromValue(ints) << "ai" << "[Argument: ai {42, -43, 44, 45, 2147483647, -2147483648}]";
QList<uint> uints;
QTest::newRow("emptyuintlist") << qVariantFromValue(uints) << "au" << "[Argument: au {}]";
QTest::newRow("emptyuintlist") << QVariant::fromValue(uints) << "au" << "[Argument: au {}]";
uints << uint(12) << uint(13) << uint(14) << 4294967295U;
QTest::newRow("uintlist") << qVariantFromValue(uints) << "au" << "[Argument: au {12, 13, 14, 4294967295}]";
QTest::newRow("uintlist") << QVariant::fromValue(uints) << "au" << "[Argument: au {12, 13, 14, 4294967295}]";
QList<qlonglong> llints;
QTest::newRow("emptyllintlist") << qVariantFromValue(llints) << "ax" << "[Argument: ax {}]";
QTest::newRow("emptyllintlist") << QVariant::fromValue(llints) << "ax" << "[Argument: ax {}]";
llints << Q_INT64_C(99) << Q_INT64_C(-100)
<< Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807);
QTest::newRow("llintlist") << qVariantFromValue(llints) << "ax"
QTest::newRow("llintlist") << QVariant::fromValue(llints) << "ax"
<< "[Argument: ax {99, -100, -9223372036854775808, 9223372036854775807}]";
QList<qulonglong> ullints;
QTest::newRow("emptyullintlist") << qVariantFromValue(ullints) << "at" << "[Argument: at {}]";
QTest::newRow("emptyullintlist") << QVariant::fromValue(ullints) << "at" << "[Argument: at {}]";
ullints << Q_UINT64_C(66) << Q_UINT64_C(67)
<< Q_UINT64_C(18446744073709551615);
QTest::newRow("ullintlist") << qVariantFromValue(ullints) << "at" << "[Argument: at {66, 67, 18446744073709551615}]";
QTest::newRow("ullintlist") << QVariant::fromValue(ullints) << "at" << "[Argument: at {66, 67, 18446744073709551615}]";
QList<double> doubles;
QTest::newRow("emptydoublelist") << qVariantFromValue(doubles) << "ad" << "[Argument: ad {}]";
QTest::newRow("emptydoublelist") << QVariant::fromValue(doubles) << "ad" << "[Argument: ad {}]";
doubles << 1.2 << 2.2 << 4.4
<< -std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::quiet_NaN();
QTest::newRow("doublelist") << qVariantFromValue(doubles) << "ad" << "[Argument: ad {1.2, 2.2, 4.4, -inf, inf, nan}]";
QTest::newRow("doublelist") << QVariant::fromValue(doubles) << "ad" << "[Argument: ad {1.2, 2.2, 4.4, -inf, inf, nan}]";
QList<QDBusObjectPath> objectPaths;
QTest::newRow("emptyobjectpathlist") << qVariantFromValue(objectPaths) << "ao" << "[Argument: ao {}]";
QTest::newRow("emptyobjectpathlist") << QVariant::fromValue(objectPaths) << "ao" << "[Argument: ao {}]";
objectPaths << QDBusObjectPath("/") << QDBusObjectPath("/foo");
QTest::newRow("objectpathlist") << qVariantFromValue(objectPaths) << "ao" << "[Argument: ao {[ObjectPath: /], [ObjectPath: /foo]}]";
QTest::newRow("objectpathlist") << QVariant::fromValue(objectPaths) << "ao" << "[Argument: ao {[ObjectPath: /], [ObjectPath: /foo]}]";
if (fileDescriptorPassing) {
QList<QDBusUnixFileDescriptor> fileDescriptors;
QTest::newRow("emptyfiledescriptorlist") << qVariantFromValue(fileDescriptors) << "ah" << "[Argument: ah {}]";
QTest::newRow("emptyfiledescriptorlist") << QVariant::fromValue(fileDescriptors) << "ah" << "[Argument: ah {}]";
fileDescriptors << QDBusUnixFileDescriptor(fileDescriptorForTest()) << QDBusUnixFileDescriptor(1);
QTest::newRow("filedescriptorlist") << qVariantFromValue(fileDescriptors) << "ah" << "[Argument: ah {[Unix FD: valid], [Unix FD: valid]}]";
QTest::newRow("filedescriptorlist") << QVariant::fromValue(fileDescriptors) << "ah" << "[Argument: ah {[Unix FD: valid], [Unix FD: valid]}]";
}
QVariantList variants;
QTest::newRow("emptyvariantlist") << QVariant(variants) << "av" << "[Argument: av {}]";
variants << QString("Hello") << QByteArray("World") << 42 << -43.0 << 44U << Q_INT64_C(-45)
<< Q_UINT64_C(46) << true << qVariantFromValue(short(-47))
<< qVariantFromValue(QDBusSignature("av"))
<< qVariantFromValue(QDBusVariant(qVariantFromValue(QDBusObjectPath("/"))));
<< Q_UINT64_C(46) << true << QVariant::fromValue(short(-47))
<< QVariant::fromValue(QDBusSignature("av"))
<< QVariant::fromValue(QDBusVariant(QVariant::fromValue(QDBusObjectPath("/"))));
QTest::newRow("variantlist") << QVariant(variants) << "av"
<< "[Argument: av {[Variant(QString): \"Hello\"], [Variant(QByteArray): {87, 111, 114, 108, 100}], [Variant(int): 42], [Variant(double): -43], [Variant(uint): 44], [Variant(qlonglong): -45], [Variant(qulonglong): 46], [Variant(bool): true], [Variant(short): -47], [Variant: [Signature: av]], [Variant: [Variant: [ObjectPath: /]]]}]";
}
@ -328,132 +328,132 @@ void tst_QDBusMarshall::sendArrayOfArrays_data()
// arrays:
QList<QStringList> strings;
QTest::newRow("empty-list-of-stringlist") << qVariantFromValue(strings) << "aas"
QTest::newRow("empty-list-of-stringlist") << QVariant::fromValue(strings) << "aas"
<< "[Argument: aas {}]";
strings << QStringList();
QTest::newRow("list-of-emptystringlist") << qVariantFromValue(strings) << "aas"
QTest::newRow("list-of-emptystringlist") << QVariant::fromValue(strings) << "aas"
<< "[Argument: aas {{}}]";
strings << (QStringList() << "hello" << "world")
<< (QStringList() << "hi" << "there")
<< (QStringList() << QString());
QTest::newRow("stringlist") << qVariantFromValue(strings) << "aas"
QTest::newRow("stringlist") << QVariant::fromValue(strings) << "aas"
<< "[Argument: aas {{}, {\"hello\", \"world\"}, {\"hi\", \"there\"}, {\"\"}}]";
QList<QByteArray> bytearray;
QTest::newRow("empty-list-of-bytearray") << qVariantFromValue(bytearray) << "aay"
QTest::newRow("empty-list-of-bytearray") << QVariant::fromValue(bytearray) << "aay"
<< "[Argument: aay {}]";
bytearray << QByteArray();
QTest::newRow("list-of-emptybytearray") << qVariantFromValue(bytearray) << "aay"
QTest::newRow("list-of-emptybytearray") << QVariant::fromValue(bytearray) << "aay"
<< "[Argument: aay {{}}]";
bytearray << "foo" << "bar" << "baz" << "" << QByteArray();
QTest::newRow("bytearray") << qVariantFromValue(bytearray) << "aay"
QTest::newRow("bytearray") << QVariant::fromValue(bytearray) << "aay"
<< "[Argument: aay {{}, {102, 111, 111}, {98, 97, 114}, {98, 97, 122}, {}, {}}]";
QList<QList<bool> > bools;
QTest::newRow("empty-list-of-boollist") << qVariantFromValue(bools) << "aab"
QTest::newRow("empty-list-of-boollist") << QVariant::fromValue(bools) << "aab"
<< "[Argument: aab {}]";
bools << QList<bool>();
QTest::newRow("list-of-emptyboollist") << qVariantFromValue(bools) << "aab"
QTest::newRow("list-of-emptyboollist") << QVariant::fromValue(bools) << "aab"
<< "[Argument: aab {[Argument: ab {}]}]";
bools << (QList<bool>() << false << true) << (QList<bool>() << false) << (QList<bool>());
QTest::newRow("boollist") << qVariantFromValue(bools) << "aab"
QTest::newRow("boollist") << QVariant::fromValue(bools) << "aab"
<< "[Argument: aab {[Argument: ab {}], [Argument: ab {false, true}], [Argument: ab {false}], [Argument: ab {}]}]";
QList<QList<short> > shorts;
QTest::newRow("empty-list-of-shortlist") << qVariantFromValue(shorts) << "aan"
QTest::newRow("empty-list-of-shortlist") << QVariant::fromValue(shorts) << "aan"
<< "[Argument: aan {}]";
shorts << QList<short>();
QTest::newRow("list-of-emptyshortlist") << qVariantFromValue(shorts) << "aan"
QTest::newRow("list-of-emptyshortlist") << QVariant::fromValue(shorts) << "aan"
<< "[Argument: aan {[Argument: an {}]}]";
shorts << (QList<short>() << 42 << -43 << 44 << 45)
<< (QList<short>() << -32768 << 32767)
<< (QList<short>());
QTest::newRow("shortlist") << qVariantFromValue(shorts) << "aan"
QTest::newRow("shortlist") << QVariant::fromValue(shorts) << "aan"
<< "[Argument: aan {[Argument: an {}], [Argument: an {42, -43, 44, 45}], [Argument: an {-32768, 32767}], [Argument: an {}]}]";
QList<QList<ushort> > ushorts;
QTest::newRow("empty-list-of-ushortlist") << qVariantFromValue(ushorts) << "aaq"
QTest::newRow("empty-list-of-ushortlist") << QVariant::fromValue(ushorts) << "aaq"
<< "[Argument: aaq {}]";
ushorts << QList<ushort>();
QTest::newRow("list-of-emptyushortlist") << qVariantFromValue(ushorts) << "aaq"
QTest::newRow("list-of-emptyushortlist") << QVariant::fromValue(ushorts) << "aaq"
<< "[Argument: aaq {[Argument: aq {}]}]";
ushorts << (QList<ushort>() << 12u << 13u << 14u << 15)
<< (QList<ushort>() << 65535)
<< (QList<ushort>());
QTest::newRow("ushortlist") << qVariantFromValue(ushorts) << "aaq"
QTest::newRow("ushortlist") << QVariant::fromValue(ushorts) << "aaq"
<< "[Argument: aaq {[Argument: aq {}], [Argument: aq {12, 13, 14, 15}], [Argument: aq {65535}], [Argument: aq {}]}]";
QList<QList<int> > ints;
QTest::newRow("empty-list-of-intlist") << qVariantFromValue(ints) << "aai"
QTest::newRow("empty-list-of-intlist") << QVariant::fromValue(ints) << "aai"
<< "[Argument: aai {}]";
ints << QList<int>();
QTest::newRow("list-of-emptyintlist") << qVariantFromValue(ints) << "aai"
QTest::newRow("list-of-emptyintlist") << QVariant::fromValue(ints) << "aai"
<< "[Argument: aai {[Argument: ai {}]}]";
ints << (QList<int>() << 42 << -43 << 44 << 45)
<< (QList<int>() << 2147483647 << -2147483647-1)
<< (QList<int>());
QTest::newRow("intlist") << qVariantFromValue(ints) << "aai"
QTest::newRow("intlist") << QVariant::fromValue(ints) << "aai"
<< "[Argument: aai {[Argument: ai {}], [Argument: ai {42, -43, 44, 45}], [Argument: ai {2147483647, -2147483648}], [Argument: ai {}]}]";
QList<QList<uint> > uints;
QTest::newRow("empty-list-of-uintlist") << qVariantFromValue(uints) << "aau"
QTest::newRow("empty-list-of-uintlist") << QVariant::fromValue(uints) << "aau"
<< "[Argument: aau {}]";
uints << QList<uint>();
QTest::newRow("list-of-emptyuintlist") << qVariantFromValue(uints) << "aau"
QTest::newRow("list-of-emptyuintlist") << QVariant::fromValue(uints) << "aau"
<< "[Argument: aau {[Argument: au {}]}]";
uints << (QList<uint>() << uint(12) << uint(13) << uint(14))
<< (QList<uint>() << 4294967295U)
<< (QList<uint>());
QTest::newRow("uintlist") << qVariantFromValue(uints) << "aau"
QTest::newRow("uintlist") << QVariant::fromValue(uints) << "aau"
<< "[Argument: aau {[Argument: au {}], [Argument: au {12, 13, 14}], [Argument: au {4294967295}], [Argument: au {}]}]";
QList<QList<qlonglong> > llints;
QTest::newRow("empty-list-of-llintlist") << qVariantFromValue(llints) << "aax"
QTest::newRow("empty-list-of-llintlist") << QVariant::fromValue(llints) << "aax"
<< "[Argument: aax {}]";
llints << QList<qlonglong>();
QTest::newRow("list-of-emptyllintlist") << qVariantFromValue(llints) << "aax"
QTest::newRow("list-of-emptyllintlist") << QVariant::fromValue(llints) << "aax"
<< "[Argument: aax {[Argument: ax {}]}]";
llints << (QList<qlonglong>() << Q_INT64_C(99) << Q_INT64_C(-100))
<< (QList<qlonglong>() << Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807))
<< (QList<qlonglong>());
QTest::newRow("llintlist") << qVariantFromValue(llints) << "aax"
QTest::newRow("llintlist") << QVariant::fromValue(llints) << "aax"
<< "[Argument: aax {[Argument: ax {}], [Argument: ax {99, -100}], [Argument: ax {-9223372036854775808, 9223372036854775807}], [Argument: ax {}]}]";
QList<QList<qulonglong> > ullints;
QTest::newRow("empty-list-of-ullintlist") << qVariantFromValue(ullints) << "aat"
QTest::newRow("empty-list-of-ullintlist") << QVariant::fromValue(ullints) << "aat"
<< "[Argument: aat {}]";
ullints << QList<qulonglong>();
QTest::newRow("list-of-emptyullintlist") << qVariantFromValue(ullints) << "aat"
QTest::newRow("list-of-emptyullintlist") << QVariant::fromValue(ullints) << "aat"
<< "[Argument: aat {[Argument: at {}]}]";
ullints << (QList<qulonglong>() << Q_UINT64_C(66) << Q_UINT64_C(67))
<< (QList<qulonglong>() << Q_UINT64_C(18446744073709551615))
<< (QList<qulonglong>());
QTest::newRow("ullintlist") << qVariantFromValue(ullints) << "aat"
QTest::newRow("ullintlist") << QVariant::fromValue(ullints) << "aat"
<< "[Argument: aat {[Argument: at {}], [Argument: at {66, 67}], [Argument: at {18446744073709551615}], [Argument: at {}]}]";
QList<QList<double> > doubles;
QTest::newRow("empty-list-ofdoublelist") << qVariantFromValue(doubles) << "aad"
QTest::newRow("empty-list-ofdoublelist") << QVariant::fromValue(doubles) << "aad"
<< "[Argument: aad {}]";
doubles << QList<double>();
QTest::newRow("list-of-emptydoublelist") << qVariantFromValue(doubles) << "aad"
QTest::newRow("list-of-emptydoublelist") << QVariant::fromValue(doubles) << "aad"
<< "[Argument: aad {[Argument: ad {}]}]";
doubles << (QList<double>() << 1.2 << 2.2 << 4.4)
<< (QList<double>() << -std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::quiet_NaN())
<< (QList<double>());
QTest::newRow("doublelist") << qVariantFromValue(doubles) << "aad"
QTest::newRow("doublelist") << QVariant::fromValue(doubles) << "aad"
<< "[Argument: aad {[Argument: ad {}], [Argument: ad {1.2, 2.2, 4.4}], [Argument: ad {-inf, inf, nan}], [Argument: ad {}]}]";
QList<QVariantList> variants;
QTest::newRow("emptyvariantlist") << qVariantFromValue(variants) << "aav"
QTest::newRow("emptyvariantlist") << QVariant::fromValue(variants) << "aav"
<< "[Argument: aav {}]";
variants << QVariantList();
QTest::newRow("emptyvariantlist") << qVariantFromValue(variants) << "aav"
QTest::newRow("emptyvariantlist") << QVariant::fromValue(variants) << "aav"
<< "[Argument: aav {[Argument: av {}]}]";
variants << (QVariantList() << QString("Hello") << QByteArray("World"))
<< (QVariantList() << 42 << -43.0 << 44U << Q_INT64_C(-45))
<< (QVariantList() << Q_UINT64_C(46) << true << qVariantFromValue(short(-47)));
QTest::newRow("variantlist") << qVariantFromValue(variants) << "aav"
<< (QVariantList() << Q_UINT64_C(46) << true << QVariant::fromValue(short(-47)));
QTest::newRow("variantlist") << QVariant::fromValue(variants) << "aav"
<< "[Argument: aav {[Argument: av {}], [Argument: av {[Variant(QString): \"Hello\"], [Variant(QByteArray): {87, 111, 114, 108, 100}]}], [Argument: av {[Variant(int): 42], [Variant(double): -43], [Variant(uint): 44], [Variant(qlonglong): -45]}], [Argument: av {[Variant(qulonglong): 46], [Variant(bool): true], [Variant(short): -47]}]}]";
}
@ -464,65 +464,65 @@ void tst_QDBusMarshall::sendMaps_data()
QTest::addColumn<QString>("stringResult");
QMap<int, QString> ismap;
QTest::newRow("empty-is-map") << qVariantFromValue(ismap) << "a{is}"
QTest::newRow("empty-is-map") << QVariant::fromValue(ismap) << "a{is}"
<< "[Argument: a{is} {}]";
ismap[1] = "a";
ismap[2000] = "b";
ismap[-47] = "c";
QTest::newRow("is-map") << qVariantFromValue(ismap) << "a{is}"
QTest::newRow("is-map") << QVariant::fromValue(ismap) << "a{is}"
<< "[Argument: a{is} {-47 = \"c\", 1 = \"a\", 2000 = \"b\"}]";
QMap<QString, QString> ssmap;
QTest::newRow("empty-ss-map") << qVariantFromValue(ssmap) << "a{ss}"
QTest::newRow("empty-ss-map") << QVariant::fromValue(ssmap) << "a{ss}"
<< "[Argument: a{ss} {}]";
ssmap["a"] = "a";
ssmap["c"] = "b";
ssmap["b"] = "c";
QTest::newRow("ss-map") << qVariantFromValue(ssmap) << "a{ss}"
QTest::newRow("ss-map") << QVariant::fromValue(ssmap) << "a{ss}"
<< "[Argument: a{ss} {\"a\" = \"a\", \"b\" = \"c\", \"c\" = \"b\"}]";
QVariantMap svmap;
QTest::newRow("empty-sv-map") << qVariantFromValue(svmap) << "a{sv}"
QTest::newRow("empty-sv-map") << QVariant::fromValue(svmap) << "a{sv}"
<< "[Argument: a{sv} {}]";
svmap["a"] = 1;
svmap["c"] = "b";
svmap["b"] = QByteArray("c");
svmap["d"] = 42U;
svmap["e"] = qVariantFromValue(short(-47));
svmap["f"] = qVariantFromValue(QDBusVariant(0));
QTest::newRow("sv-map1") << qVariantFromValue(svmap) << "a{sv}"
svmap["e"] = QVariant::fromValue(short(-47));
svmap["f"] = QVariant::fromValue(QDBusVariant(0));
QTest::newRow("sv-map1") << QVariant::fromValue(svmap) << "a{sv}"
<< "[Argument: a{sv} {\"a\" = [Variant(int): 1], \"b\" = [Variant(QByteArray): {99}], \"c\" = [Variant(QString): \"b\"], \"d\" = [Variant(uint): 42], \"e\" = [Variant(short): -47], \"f\" = [Variant: [Variant(int): 0]]}]";
QMap<QDBusObjectPath, QString> osmap;
QTest::newRow("empty-os-map") << qVariantFromValue(osmap) << "a{os}"
QTest::newRow("empty-os-map") << QVariant::fromValue(osmap) << "a{os}"
<< "[Argument: a{os} {}]";
osmap[QDBusObjectPath("/")] = "root";
osmap[QDBusObjectPath("/foo")] = "foo";
osmap[QDBusObjectPath("/bar/baz")] = "bar and baz";
QTest::newRow("os-map") << qVariantFromValue(osmap) << "a{os}"
QTest::newRow("os-map") << QVariant::fromValue(osmap) << "a{os}"
<< "[Argument: a{os} {[ObjectPath: /] = \"root\", [ObjectPath: /bar/baz] = \"bar and baz\", [ObjectPath: /foo] = \"foo\"}]";
QMap<QDBusSignature, QString> gsmap;
QTest::newRow("empty-gs-map") << qVariantFromValue(gsmap) << "a{gs}"
QTest::newRow("empty-gs-map") << QVariant::fromValue(gsmap) << "a{gs}"
<< "[Argument: a{gs} {}]";
gsmap[QDBusSignature("i")] = "int32";
gsmap[QDBusSignature("s")] = "string";
gsmap[QDBusSignature("a{gs}")] = "array of dict_entry of (signature, string)";
QTest::newRow("gs-map") << qVariantFromValue(gsmap) << "a{gs}"
QTest::newRow("gs-map") << QVariant::fromValue(gsmap) << "a{gs}"
<< "[Argument: a{gs} {[Signature: a{gs}] = \"array of dict_entry of (signature, string)\", [Signature: i] = \"int32\", [Signature: s] = \"string\"}]";
if (fileDescriptorPassing) {
svmap["zzfiledescriptor"] = qVariantFromValue(QDBusUnixFileDescriptor(fileDescriptorForTest()));
QTest::newRow("sv-map1-fd") << qVariantFromValue(svmap) << "a{sv}"
svmap["zzfiledescriptor"] = QVariant::fromValue(QDBusUnixFileDescriptor(fileDescriptorForTest()));
QTest::newRow("sv-map1-fd") << QVariant::fromValue(svmap) << "a{sv}"
<< "[Argument: a{sv} {\"a\" = [Variant(int): 1], \"b\" = [Variant(QByteArray): {99}], \"c\" = [Variant(QString): \"b\"], \"d\" = [Variant(uint): 42], \"e\" = [Variant(short): -47], \"f\" = [Variant: [Variant(int): 0]], \"zzfiledescriptor\" = [Variant(QDBusUnixFileDescriptor): [Unix FD: valid]]}]";
}
svmap.clear();
svmap["ismap"] = qVariantFromValue(ismap);
svmap["ssmap"] = qVariantFromValue(ssmap);
svmap["osmap"] = qVariantFromValue(osmap);
svmap["gsmap"] = qVariantFromValue(gsmap);
QTest::newRow("sv-map2") << qVariantFromValue(svmap) << "a{sv}"
svmap["ismap"] = QVariant::fromValue(ismap);
svmap["ssmap"] = QVariant::fromValue(ssmap);
svmap["osmap"] = QVariant::fromValue(osmap);
svmap["gsmap"] = QVariant::fromValue(gsmap);
QTest::newRow("sv-map2") << QVariant::fromValue(svmap) << "a{sv}"
<< "[Argument: a{sv} {\"gsmap\" = [Variant: [Argument: a{gs} {[Signature: a{gs}] = \"array of dict_entry of (signature, string)\", [Signature: i] = \"int32\", [Signature: s] = \"string\"}]], \"ismap\" = [Variant: [Argument: a{is} {-47 = \"c\", 1 = \"a\", 2000 = \"b\"}]], \"osmap\" = [Variant: [Argument: a{os} {[ObjectPath: /] = \"root\", [ObjectPath: /bar/baz] = \"bar and baz\", [ObjectPath: /foo] = \"foo\"}]], \"ssmap\" = [Variant: [Argument: a{ss} {\"a\" = \"a\", \"b\" = \"c\", \"c\" = \"b\"}]]}]";
}
@ -554,33 +554,33 @@ void tst_QDBusMarshall::sendStructs_data()
<< "[Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 12, 25, 0, 0], 0]";
MyStruct ms = { 1, "Hello, World" };
QTest::newRow("int-string") << qVariantFromValue(ms) << "(is)" << "[Argument: (is) 1, \"Hello, World\"]";
QTest::newRow("int-string") << QVariant::fromValue(ms) << "(is)" << "[Argument: (is) 1, \"Hello, World\"]";
MyVariantMapStruct mvms = { "Hello, World", QVariantMap() };
QTest::newRow("string-variantmap") << qVariantFromValue(mvms) << "(sa{sv})" << "[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {}]]";
QTest::newRow("string-variantmap") << QVariant::fromValue(mvms) << "(sa{sv})" << "[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {}]]";
// use only basic types, otherwise comparison will fail
mvms.map["int"] = 42;
mvms.map["uint"] = 42u;
mvms.map["short"] = qVariantFromValue<short>(-47);
mvms.map["short"] = QVariant::fromValue<short>(-47);
mvms.map["bytearray"] = QByteArray("Hello, world");
QTest::newRow("string-variantmap2") << qVariantFromValue(mvms) << "(sa{sv})" << "[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {\"bytearray\" = [Variant(QByteArray): {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100}], \"int\" = [Variant(int): 42], \"short\" = [Variant(short): -47], \"uint\" = [Variant(uint): 42]}]]";
QTest::newRow("string-variantmap2") << QVariant::fromValue(mvms) << "(sa{sv})" << "[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {\"bytearray\" = [Variant(QByteArray): {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100}], \"int\" = [Variant(int): 42], \"short\" = [Variant(short): -47], \"uint\" = [Variant(uint): 42]}]]";
QList<MyVariantMapStruct> list;
QTest::newRow("empty-list-of-string-variantmap") << qVariantFromValue(list) << "a(sa{sv})" << "[Argument: a(sa{sv}) {}]";
QTest::newRow("empty-list-of-string-variantmap") << QVariant::fromValue(list) << "a(sa{sv})" << "[Argument: a(sa{sv}) {}]";
list << mvms;
QTest::newRow("list-of-string-variantmap") << qVariantFromValue(list) << "a(sa{sv})" << "[Argument: a(sa{sv}) {[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {\"bytearray\" = [Variant(QByteArray): {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100}], \"int\" = [Variant(int): 42], \"short\" = [Variant(short): -47], \"uint\" = [Variant(uint): 42]}]]}]";
QTest::newRow("list-of-string-variantmap") << QVariant::fromValue(list) << "a(sa{sv})" << "[Argument: a(sa{sv}) {[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {\"bytearray\" = [Variant(QByteArray): {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100}], \"int\" = [Variant(int): 42], \"short\" = [Variant(short): -47], \"uint\" = [Variant(uint): 42]}]]}]";
if (fileDescriptorPassing) {
MyFileDescriptorStruct fds;
fds.fd = QDBusUnixFileDescriptor(fileDescriptorForTest());
QTest::newRow("fdstruct") << qVariantFromValue(fds) << "(h)" << "[Argument: (h) [Unix FD: valid]]";
QTest::newRow("fdstruct") << QVariant::fromValue(fds) << "(h)" << "[Argument: (h) [Unix FD: valid]]";
QList<MyFileDescriptorStruct> fdlist;
QTest::newRow("empty-list-of-fdstruct") << qVariantFromValue(fdlist) << "a(h)" << "[Argument: a(h) {}]";
QTest::newRow("empty-list-of-fdstruct") << QVariant::fromValue(fdlist) << "a(h)" << "[Argument: a(h) {}]";
fdlist << fds;
QTest::newRow("list-of-fdstruct") << qVariantFromValue(fdlist) << "a(h)" << "[Argument: a(h) {[Argument: (h) [Unix FD: valid]]}]";
QTest::newRow("list-of-fdstruct") << QVariant::fromValue(fdlist) << "a(h)" << "[Argument: a(h) {[Argument: (h) [Unix FD: valid]]}]";
}
}
@ -591,23 +591,23 @@ void tst_QDBusMarshall::sendComplex_data()
QTest::addColumn<QString>("stringResult");
QList<QDateTime> dtlist;
QTest::newRow("empty-datetimelist") << qVariantFromValue(dtlist) << "a((iii)(iiii)i)"
QTest::newRow("empty-datetimelist") << QVariant::fromValue(dtlist) << "a((iii)(iiii)i)"
<< "[Argument: a((iii)(iiii)i) {}]";
dtlist << QDateTime();
QTest::newRow("list-of-emptydatetime") << qVariantFromValue(dtlist) << "a((iii)(iiii)i)"
QTest::newRow("list-of-emptydatetime") << QVariant::fromValue(dtlist) << "a((iii)(iiii)i)"
<< "[Argument: a((iii)(iiii)i) {[Argument: ((iii)(iiii)i) [Argument: (iii) 0, 0, 0], [Argument: (iiii) -1, -1, -1, -1], 0]}]";
dtlist << QDateTime(QDate(1977, 9, 13), QTime(0, 0, 0))
<< QDateTime(QDate(2006, 6, 18), QTime(13, 14, 0));
QTest::newRow("datetimelist") << qVariantFromValue(dtlist) << "a((iii)(iiii)i)"
QTest::newRow("datetimelist") << QVariant::fromValue(dtlist) << "a((iii)(iiii)i)"
<< "[Argument: a((iii)(iiii)i) {[Argument: ((iii)(iiii)i) [Argument: (iii) 0, 0, 0], [Argument: (iiii) -1, -1, -1, -1], 0], [Argument: ((iii)(iiii)i) [Argument: (iii) 1977, 9, 13], [Argument: (iiii) 0, 0, 0, 0], 0], [Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 13, 14, 0, 0], 0]}]";
QMap<qlonglong, QDateTime> lldtmap;
QTest::newRow("empty-lldtmap") << qVariantFromValue(lldtmap) << "a{x((iii)(iiii)i)}"
QTest::newRow("empty-lldtmap") << QVariant::fromValue(lldtmap) << "a{x((iii)(iiii)i)}"
<< "[Argument: a{x((iii)(iiii)i)} {}]";
lldtmap[0] = QDateTime();
lldtmap[1] = QDateTime(QDate(1970, 1, 1), QTime(0, 0, 1), Qt::UTC);
lldtmap[1150629776] = QDateTime(QDate(2006, 6, 18), QTime(11, 22, 56), Qt::UTC);
QTest::newRow("lldtmap") << qVariantFromValue(lldtmap) << "a{x((iii)(iiii)i)}"
QTest::newRow("lldtmap") << QVariant::fromValue(lldtmap) << "a{x((iii)(iiii)i)}"
<< "[Argument: a{x((iii)(iiii)i)} {0 = [Argument: ((iii)(iiii)i) [Argument: (iii) 0, 0, 0], [Argument: (iiii) -1, -1, -1, -1], 0], 1 = [Argument: ((iii)(iiii)i) [Argument: (iii) 1970, 1, 1], [Argument: (iiii) 0, 0, 1, 0], 1], 1150629776 = [Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 11, 22, 56, 0], 1]}]";
@ -631,18 +631,18 @@ void tst_QDBusMarshall::sendComplex_data()
svmap["c"] = "b";
svmap["b"] = QByteArray("c");
svmap["d"] = 42U;
svmap["e"] = qVariantFromValue(short(-47));
svmap["f"] = qVariantFromValue(QDBusVariant(0));
svmap["e"] = QVariant::fromValue(short(-47));
svmap["f"] = QVariant::fromValue(QDBusVariant(0));
svmap["date"] = QDate(1977, 1, 1);
svmap["time"] = QTime(8, 58, 0);
svmap["datetime"] = QDateTime(QDate(13, 9, 2008), QTime(8, 59, 31));
svmap["pointf"] = QPointF(0.5, -0.5);
svmap["ismap"] = qVariantFromValue(ismap);
svmap["ssmap"] = qVariantFromValue(ssmap);
svmap["gsmap"] = qVariantFromValue(gsmap);
svmap["dtlist"] = qVariantFromValue(dtlist);
svmap["lldtmap"] = qVariantFromValue(lldtmap);
QTest::newRow("sv-map") << qVariantFromValue(svmap) << "a{sv}"
svmap["ismap"] = QVariant::fromValue(ismap);
svmap["ssmap"] = QVariant::fromValue(ssmap);
svmap["gsmap"] = QVariant::fromValue(gsmap);
svmap["dtlist"] = QVariant::fromValue(dtlist);
svmap["lldtmap"] = QVariant::fromValue(lldtmap);
QTest::newRow("sv-map") << QVariant::fromValue(svmap) << "a{sv}"
<< "[Argument: a{sv} {\"a\" = [Variant(int): 1], \"b\" = [Variant(QByteArray): {99}], \"c\" = [Variant(QString): \"b\"], \"d\" = [Variant(uint): 42], \"date\" = [Variant: [Argument: (iii) 1977, 1, 1]], \"datetime\" = [Variant: [Argument: ((iii)(iiii)i) [Argument: (iii) 0, 0, 0], [Argument: (iiii) 8, 59, 31, 0], 0]], \"dtlist\" = [Variant: [Argument: a((iii)(iiii)i) {[Argument: ((iii)(iiii)i) [Argument: (iii) 0, 0, 0], [Argument: (iiii) -1, -1, -1, -1], 0], [Argument: ((iii)(iiii)i) [Argument: (iii) 1977, 9, 13], [Argument: (iiii) 0, 0, 0, 0], 0], [Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 13, 14, 0, 0], 0]}]], \"e\" = [Variant(short): -47], \"f\" = [Variant: [Variant(int): 0]], \"gsmap\" = [Variant: [Argument: a{gs} {[Signature: a{gs}] = \"array of dict_entry of (signature, string)\", [Signature: i] = \"int32\", [Signature: s] = \"string\"}]], \"ismap\" = [Variant: [Argument: a{is} {-47 = \"c\", 1 = \"a\", 2000 = \"b\"}]], \"lldtmap\" = [Variant: [Argument: a{x((iii)(iiii)i)} {0 = [Argument: ((iii)(iiii)i) [Argument: (iii) 0, 0, 0], [Argument: (iiii) -1, -1, -1, -1], 0], 1 = [Argument: ((iii)(iiii)i) [Argument: (iii) 1970, 1, 1], [Argument: (iiii) 0, 0, 1, 0], 1], 1150629776 = [Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 11, 22, 56, 0], 1]}]], \"pointf\" = [Variant: [Argument: (dd) 0.5, -0.5]], \"ssmap\" = [Variant: [Argument: a{ss} {\"a\" = \"a\", \"b\" = \"c\", \"c\" = \"b\"}]], \"time\" = [Variant: [Argument: (iiii) 8, 58, 0, 0]]}]";
}
@ -657,83 +657,83 @@ void tst_QDBusMarshall::sendArgument_data()
arg = QDBusArgument();
arg << true;
QTest::newRow("bool") << qVariantFromValue(arg) << "b" << int(QDBusArgument::BasicType);;
QTest::newRow("bool") << QVariant::fromValue(arg) << "b" << int(QDBusArgument::BasicType);;
arg = QDBusArgument();
arg << false;
QTest::newRow("bool2") << qVariantFromValue(arg) << "b" << int(QDBusArgument::BasicType);
QTest::newRow("bool2") << QVariant::fromValue(arg) << "b" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << uchar(1);
QTest::newRow("byte") << qVariantFromValue(arg) << "y" << int(QDBusArgument::BasicType);
QTest::newRow("byte") << QVariant::fromValue(arg) << "y" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << short(2);
QTest::newRow("int16") << qVariantFromValue(arg) << "n" << int(QDBusArgument::BasicType);
QTest::newRow("int16") << QVariant::fromValue(arg) << "n" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << ushort(3);
QTest::newRow("uint16") << qVariantFromValue(arg) << "q" << int(QDBusArgument::BasicType);
QTest::newRow("uint16") << QVariant::fromValue(arg) << "q" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << 1;
QTest::newRow("int32") << qVariantFromValue(arg) << "i" << int(QDBusArgument::BasicType);
QTest::newRow("int32") << QVariant::fromValue(arg) << "i" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << 2U;
QTest::newRow("uint32") << qVariantFromValue(arg) << "u" << int(QDBusArgument::BasicType);
QTest::newRow("uint32") << QVariant::fromValue(arg) << "u" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << Q_INT64_C(3);
QTest::newRow("int64") << qVariantFromValue(arg) << "x" << int(QDBusArgument::BasicType);
QTest::newRow("int64") << QVariant::fromValue(arg) << "x" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << Q_UINT64_C(4);
QTest::newRow("uint64") << qVariantFromValue(arg) << "t" << int(QDBusArgument::BasicType);
QTest::newRow("uint64") << QVariant::fromValue(arg) << "t" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << 42.5;
QTest::newRow("double") << qVariantFromValue(arg) << "d" << int(QDBusArgument::BasicType);
QTest::newRow("double") << QVariant::fromValue(arg) << "d" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << QLatin1String("ping");
QTest::newRow("string") << qVariantFromValue(arg) << "s" << int(QDBusArgument::BasicType);
QTest::newRow("string") << QVariant::fromValue(arg) << "s" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << QDBusObjectPath("/org/kde");
QTest::newRow("objectpath") << qVariantFromValue(arg) << "o" << int(QDBusArgument::BasicType);
QTest::newRow("objectpath") << QVariant::fromValue(arg) << "o" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << QDBusSignature("g");
QTest::newRow("signature") << qVariantFromValue(arg) << "g" << int(QDBusArgument::BasicType);
QTest::newRow("signature") << QVariant::fromValue(arg) << "g" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << QLatin1String("");
QTest::newRow("emptystring") << qVariantFromValue(arg) << "s" << int(QDBusArgument::BasicType);
QTest::newRow("emptystring") << QVariant::fromValue(arg) << "s" << int(QDBusArgument::BasicType);
arg = QDBusArgument();
arg << QString();
QTest::newRow("nullstring") << qVariantFromValue(arg) << "s" << int(QDBusArgument::BasicType);
QTest::newRow("nullstring") << QVariant::fromValue(arg) << "s" << int(QDBusArgument::BasicType);
if (fileDescriptorPassing) {
arg = QDBusArgument();
arg << QDBusUnixFileDescriptor(fileDescriptorForTest());
QTest::newRow("filedescriptor") << qVariantFromValue(arg) << "h" << int(QDBusArgument::BasicType);
QTest::newRow("filedescriptor") << QVariant::fromValue(arg) << "h" << int(QDBusArgument::BasicType);
}
arg = QDBusArgument();
arg << QDBusVariant(1);
QTest::newRow("variant") << qVariantFromValue(arg) << "v" << int(QDBusArgument::VariantType);
QTest::newRow("variant") << QVariant::fromValue(arg) << "v" << int(QDBusArgument::VariantType);
arg = QDBusArgument();
arg << QDBusVariant(qVariantFromValue(QDBusVariant(1)));
QTest::newRow("variant-variant") << qVariantFromValue(arg) << "v" << int(QDBusArgument::VariantType);
arg << QDBusVariant(QVariant::fromValue(QDBusVariant(1)));
QTest::newRow("variant-variant") << QVariant::fromValue(arg) << "v" << int(QDBusArgument::VariantType);
arg = QDBusArgument();
arg.beginArray(QVariant::Int);
arg << 1 << 2 << 3 << -4;
arg.endArray();
QTest::newRow("array-of-int") << qVariantFromValue(arg) << "ai" << int(QDBusArgument::ArrayType);
QTest::newRow("array-of-int") << QVariant::fromValue(arg) << "ai" << int(QDBusArgument::ArrayType);
arg = QDBusArgument();
arg.beginMap(QVariant::Int, QVariant::UInt);
@ -744,13 +744,13 @@ void tst_QDBusMarshall::sendArgument_data()
arg << 3 << 4U;
arg.endMapEntry();
arg.endMap();
QTest::newRow("map") << qVariantFromValue(arg) << "a{iu}" << int(QDBusArgument::MapType);
QTest::newRow("map") << QVariant::fromValue(arg) << "a{iu}" << int(QDBusArgument::MapType);
arg = QDBusArgument();
arg.beginStructure();
arg << 1 << 2U << short(-3) << ushort(4) << 5.0 << false;
arg.endStructure();
QTest::newRow("structure") << qVariantFromValue(arg) << "(iunqdb)" << int(QDBusArgument::StructureType);
QTest::newRow("structure") << QVariant::fromValue(arg) << "(iunqdb)" << int(QDBusArgument::StructureType);
}
void tst_QDBusMarshall::sendBasic()
@ -790,7 +790,7 @@ void tst_QDBusMarshall::sendVariant()
QDBusMessage msg = QDBusMessage::createMethodCall(serviceName,
objectPath, interfaceName, "ping");
msg << qVariantFromValue(QDBusVariant(value));
msg << QVariant::fromValue(QDBusVariant(value));
QDBusMessage reply = con.call(msg);
// qDebug() << reply;
@ -851,7 +851,7 @@ void tst_QDBusMarshall::sendArgument()
sendArg.beginStructure();
sendArg.appendVariant(value);
sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg));
msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
reply = con.call(msg);
QCOMPARE(reply.signature(), QString("(%1)").arg(sig));
@ -883,7 +883,7 @@ void tst_QDBusMarshall::sendSignalErrors()
QVERIFY(con.isConnected());
QDBusMessage msg = QDBusMessage::createSignal("/foo", "local.interfaceName",
"signalName");
msg << qVariantFromValue(QDBusObjectPath());
msg << QVariant::fromValue(QDBusObjectPath());
QTest::ignoreMessage(QtWarningMsg, "QDBusConnection: error: could not send signal path \"/foo\" interface \"local.interfaceName\" member \"signalName\": Marshalling failed: Invalid object path passed in arguments");
QVERIFY(!con.send(msg));
@ -893,20 +893,20 @@ void tst_QDBusMarshall::sendSignalErrors()
QTest::ignoreMessage(QtWarningMsg, "QDBusObjectPath: invalid path \"abc\"");
path.setPath("abc");
msg << qVariantFromValue(path);
msg << QVariant::fromValue(path);
QTest::ignoreMessage(QtWarningMsg, "QDBusConnection: error: could not send signal path \"/foo\" interface \"local.interfaceName\" member \"signalName\": Marshalling failed: Invalid object path passed in arguments");
QVERIFY(!con.send(msg));
QDBusSignature sig;
msg.setArguments(QVariantList() << qVariantFromValue(sig));
msg.setArguments(QVariantList() << QVariant::fromValue(sig));
QTest::ignoreMessage(QtWarningMsg, "QDBusConnection: error: could not send signal path \"/foo\" interface \"local.interfaceName\" member \"signalName\": Marshalling failed: Invalid signature passed in arguments");
QVERIFY(!con.send(msg));
QTest::ignoreMessage(QtWarningMsg, "QDBusSignature: invalid signature \"a\"");
sig.setSignature("a");
msg.setArguments(QVariantList());
msg << qVariantFromValue(sig);
msg << QVariant::fromValue(sig);
QTest::ignoreMessage(QtWarningMsg, "QDBusConnection: error: could not send signal path \"/foo\" interface \"local.interfaceName\" member \"signalName\": Marshalling failed: Invalid signature passed in arguments");
QVERIFY(!con.send(msg));
}
@ -956,7 +956,7 @@ void tst_QDBusMarshall::sendCallErrors_data()
<< "Marshalling failed: Variant containing QVariant::Invalid passed in arguments"
<< "QDBusMarshaller: cannot add an invalid QVariant";
QTest::newRow("invalid-variant1") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusVariant()))
<< (QVariantList() << QVariant::fromValue(QDBusVariant()))
<< "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Variant containing QVariant::Invalid passed in arguments"
<< "QDBusMarshaller: cannot add a null QDBusVariant";
@ -970,20 +970,20 @@ void tst_QDBusMarshall::sendCallErrors_data()
// this type is known to the meta type system, but not registered with D-Bus
qRegisterMetaType<UnregisteredType>();
QTest::newRow("extra-unregistered") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(UnregisteredType()))
<< (QVariantList() << QVariant::fromValue(UnregisteredType()))
<< "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Unregistered type UnregisteredType passed in arguments"
<< QString("QDBusMarshaller: type `UnregisteredType' (%1) is not registered with D-BUS. Use qDBusRegisterMetaType to register it")
.arg(qMetaTypeId<UnregisteredType>());
QTest::newRow("invalid-object-path-arg") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusObjectPath()))
<< (QVariantList() << QVariant::fromValue(QDBusObjectPath()))
<< "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Invalid object path passed in arguments"
<< "";
QTest::newRow("invalid-signature-arg") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusSignature()))
<< (QVariantList() << QVariant::fromValue(QDBusSignature()))
<< "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Invalid signature passed in arguments"
<< "";
@ -991,7 +991,7 @@ void tst_QDBusMarshall::sendCallErrors_data()
// invalid file descriptor
if (fileDescriptorPassing) {
QTest::newRow("invalid-file-descriptor") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusUnixFileDescriptor(-1)))
<< (QVariantList() << QVariant::fromValue(QDBusUnixFileDescriptor(-1)))
<< "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Invalid file descriptor passed in arguments"
<< "";
@ -1200,7 +1200,7 @@ QVariant demarshallPrimitiveAs(const QDBusArgument& dbusArg)
{
T val;
dbusArg >> val;
return qVariantFromValue(val);
return QVariant::fromValue(val);
}
QVariant demarshallPrimitiveAs(int typeIndex, const QDBusArgument& dbusArg)
@ -1247,7 +1247,7 @@ void tst_QDBusMarshall::demarshallPrimitives()
sendArg.beginStructure();
sendArg.appendVariant(value);
sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg));
msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0));
@ -1279,15 +1279,15 @@ void tst_QDBusMarshall::demarshallStrings_data()
typedef QPair<QVariant, char> ValSigPair;
const QList<ValSigPair> nullStringTypes
= QList<ValSigPair>()
<< ValSigPair(qVariantFromValue(QString()), 's')
<< ValSigPair(qVariantFromValue(QDBusObjectPath()), 'o')
<< ValSigPair(qVariantFromValue(QDBusSignature()), 'g');
<< ValSigPair(QVariant::fromValue(QString()), 's')
<< ValSigPair(QVariant::fromValue(QDBusObjectPath()), 'o')
<< ValSigPair(QVariant::fromValue(QDBusSignature()), 'g');
foreach (ValSigPair valSigPair, nullStringTypes) {
QTest::newRow("bool(false)") << QVariant(false) << valSigPair.second << valSigPair.first;
QTest::newRow("bool(true)") << QVariant(true) << valSigPair.second << valSigPair.first;
QTest::newRow("byte") << qVariantFromValue(uchar(1)) << valSigPair.second << valSigPair.first;
QTest::newRow("int16") << qVariantFromValue(short(2)) << valSigPair.second << valSigPair.first;
QTest::newRow("uint16") << qVariantFromValue(ushort(3)) << valSigPair.second << valSigPair.first;
QTest::newRow("byte") << QVariant::fromValue(uchar(1)) << valSigPair.second << valSigPair.first;
QTest::newRow("int16") << QVariant::fromValue(short(2)) << valSigPair.second << valSigPair.first;
QTest::newRow("uint16") << QVariant::fromValue(ushort(3)) << valSigPair.second << valSigPair.first;
QTest::newRow("int") << QVariant(1) << valSigPair.second << valSigPair.first;
QTest::newRow("uint") << QVariant(2U) << valSigPair.second << valSigPair.first;
QTest::newRow("int64") << QVariant(Q_INT64_C(3)) << valSigPair.second << valSigPair.first;
@ -1299,32 +1299,32 @@ void tst_QDBusMarshall::demarshallStrings_data()
// to check released functionality is maintained even after checks have
// been added to string demarshalling
QTest::newRow("empty string->invalid objectpath") << QVariant("")
<< 'o' << qVariantFromValue(QDBusObjectPath());
<< 'o' << QVariant::fromValue(QDBusObjectPath());
QTest::newRow("null string->invalid objectpath") << QVariant(QString())
<< 'o' << qVariantFromValue(QDBusObjectPath());
<< 'o' << QVariant::fromValue(QDBusObjectPath());
QTest::newRow("string->invalid objectpath") << QVariant("invalid objectpath")
<< 'o' << qVariantFromValue(QDBusObjectPath());
<< 'o' << QVariant::fromValue(QDBusObjectPath());
QTest::newRow("string->valid objectpath") << QVariant("/org/kde")
<< 'o' << qVariantFromValue(QDBusObjectPath("/org/kde"));
<< 'o' << QVariant::fromValue(QDBusObjectPath("/org/kde"));
QTest::newRow("empty string->invalid signature") << QVariant("")
<< 'g' << qVariantFromValue(QDBusSignature());
<< 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("null string->invalid signature") << QVariant(QString())
<< 'g' << qVariantFromValue(QDBusSignature());
<< 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("string->invalid signature") << QVariant("_invalid signature")
<< 'g' << qVariantFromValue(QDBusSignature());
<< 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("string->valid signature") << QVariant("s")
<< 'g' << qVariantFromValue(QDBusSignature("s"));
<< 'g' << QVariant::fromValue(QDBusSignature("s"));
QTest::newRow("objectpath->string") << qVariantFromValue(QDBusObjectPath("/org/kde"))
<< 's' << qVariantFromValue(QString("/org/kde"));
QTest::newRow("objectpath->invalid signature") << qVariantFromValue(QDBusObjectPath("/org/kde"))
<< 'g' << qVariantFromValue(QDBusSignature());
QTest::newRow("objectpath->string") << QVariant::fromValue(QDBusObjectPath("/org/kde"))
<< 's' << QVariant::fromValue(QString("/org/kde"));
QTest::newRow("objectpath->invalid signature") << QVariant::fromValue(QDBusObjectPath("/org/kde"))
<< 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("signature->string") << qVariantFromValue(QDBusSignature("s"))
<< 's' << qVariantFromValue(QString("s"));
QTest::newRow("signature->invalid objectpath") << qVariantFromValue(QDBusSignature("s"))
<< 'o' << qVariantFromValue(QDBusObjectPath());
QTest::newRow("signature->string") << QVariant::fromValue(QDBusSignature("s"))
<< 's' << QVariant::fromValue(QString("s"));
QTest::newRow("signature->invalid objectpath") << QVariant::fromValue(QDBusSignature("s"))
<< 'o' << QVariant::fromValue(QDBusObjectPath());
}
QVariant demarshallAsString(const QDBusArgument& dbusArg, char targetSig)
@ -1338,12 +1338,12 @@ QVariant demarshallAsString(const QDBusArgument& dbusArg, char targetSig)
case 'o': {
QDBusObjectPath op;
dbusArg >> op;
return qVariantFromValue(op);
return QVariant::fromValue(op);
}
case 'g' : {
QDBusSignature sig;
dbusArg >> sig;
return qVariantFromValue(sig);
return QVariant::fromValue(sig);
}
default: {
return QVariant();
@ -1367,7 +1367,7 @@ void tst_QDBusMarshall::demarshallStrings()
sendArg.beginStructure();
sendArg.appendVariant(value);
sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg));
msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0));
@ -1391,15 +1391,15 @@ void tst_QDBusMarshall::demarshallInvalidStringList_data()
// Arrays of non-string type should not demarshall to a string list
QList<bool> bools;
QTest::newRow("emptyboollist") << qVariantFromValue(bools);
QTest::newRow("emptyboollist") << QVariant::fromValue(bools);
bools << false << true << false;
QTest::newRow("boollist") << qVariantFromValue(bools);
QTest::newRow("boollist") << QVariant::fromValue(bools);
// Structures should not demarshall to a QByteArray
QTest::newRow("struct of strings")
<< qVariantFromValue(QVariantList() << QString("foo") << QString("bar"));
<< QVariant::fromValue(QVariantList() << QString("foo") << QString("bar"));
QTest::newRow("struct of mixed types")
<< qVariantFromValue(QVariantList() << QString("foo") << int(42) << double(3.14));
<< QVariant::fromValue(QVariantList() << QString("foo") << int(42) << double(3.14));
}
void tst_QDBusMarshall::demarshallInvalidStringList()
@ -1416,7 +1416,7 @@ void tst_QDBusMarshall::demarshallInvalidStringList()
sendArg.beginStructure();
sendArg.appendVariant(value);
sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg));
msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0));
@ -1440,16 +1440,16 @@ void tst_QDBusMarshall::demarshallInvalidByteArray_data()
// Arrays of other types than byte should not demarshall to a QByteArray
QList<bool> bools;
QTest::newRow("empty array of bool") << qVariantFromValue(bools);
QTest::newRow("empty array of bool") << QVariant::fromValue(bools);
bools << true << false << true;
QTest::newRow("non-empty array of bool") << qVariantFromValue(bools);
QTest::newRow("non-empty array of bool") << QVariant::fromValue(bools);
// Structures should not demarshall to a QByteArray
QTest::newRow("struct of bytes")
<< qVariantFromValue(QVariantList() << uchar(1) << uchar(2));
<< QVariant::fromValue(QVariantList() << uchar(1) << uchar(2));
QTest::newRow("struct of mixed types")
<< qVariantFromValue(QVariantList() << int(42) << QString("foo") << double(3.14));
<< QVariant::fromValue(QVariantList() << int(42) << QString("foo") << double(3.14));
}
void tst_QDBusMarshall::demarshallInvalidByteArray()
@ -1466,7 +1466,7 @@ void tst_QDBusMarshall::demarshallInvalidByteArray()
sendArg.beginStructure();
sendArg.appendVariant(value);
sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg));
msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0));

6
tests/auto/gui/kernel/qclipboard/tst_qclipboard.cpp
View File

@ -158,7 +158,7 @@ void tst_QClipboard::testSignals()
QCOMPARE(selectionChangedSpy.count(), 0);
QCOMPARE(changedSpy.count(), 1);
QCOMPARE(changedSpy.at(0).count(), 1);
QCOMPARE(qVariantValue<QClipboard::Mode>(changedSpy.at(0).at(0)), QClipboard::Clipboard);
QCOMPARE(qvariant_cast<QClipboard::Mode>(changedSpy.at(0).at(0)), QClipboard::Clipboard);
changedSpy.clear();
@ -168,7 +168,7 @@ void tst_QClipboard::testSignals()
QCOMPARE(selectionChangedSpy.count(), 1);
QCOMPARE(changedSpy.count(), 1);
QCOMPARE(changedSpy.at(0).count(), 1);
QCOMPARE(qVariantValue<QClipboard::Mode>(changedSpy.at(0).at(0)), QClipboard::Selection);
QCOMPARE(qvariant_cast<QClipboard::Mode>(changedSpy.at(0).at(0)), QClipboard::Selection);
} else {
QCOMPARE(selectionChangedSpy.count(), 0);
}
@ -183,7 +183,7 @@ void tst_QClipboard::testSignals()
QCOMPARE(searchChangedSpy.count(), 1);
QCOMPARE(changedSpy.count(), 1);
QCOMPARE(changedSpy.at(0).count(), 1);
QCOMPARE(qVariantValue<QClipboard::Mode>(changedSpy.at(0).at(0)), QClipboard::FindBuffer);
QCOMPARE(qvariant_cast<QClipboard::Mode>(changedSpy.at(0).at(0)), QClipboard::FindBuffer);
} else {
QCOMPARE(searchChangedSpy.count(), 0);
}

6
tests/auto/gui/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
View File

@ -3358,13 +3358,13 @@ void tst_QMatrixNxN::properties()
QMatrix4x4 m1(uniqueValues4);
obj.setMatrix(m1);
QMatrix4x4 m2 = qVariantValue<QMatrix4x4>(obj.property("matrix"));
QMatrix4x4 m2 = qvariant_cast<QMatrix4x4>(obj.property("matrix"));
QVERIFY(isSame(m2, uniqueValues4));
QMatrix4x4 m3(transposedValues4);
obj.setProperty("matrix", qVariantFromValue(m3));
obj.setProperty("matrix", QVariant::fromValue(m3));
m2 = qVariantValue<QMatrix4x4>(obj.property("matrix"));
m2 = qvariant_cast<QMatrix4x4>(obj.property("matrix"));
QVERIFY(isSame(m2, transposedValues4));
}

6
tests/auto/gui/math3d/qquaternion/tst_qquaternion.cpp
View File

@ -855,16 +855,16 @@ void tst_QQuaternion::properties()
obj.setQuaternion(QQuaternion(6.0f, 7.0f, 8.0f, 9.0f));
QQuaternion q = qVariantValue<QQuaternion>(obj.property("quaternion"));
QQuaternion q = qvariant_cast<QQuaternion>(obj.property("quaternion"));
QCOMPARE(q.scalar(), (qreal)6.0f);
QCOMPARE(q.x(), (qreal)7.0f);
QCOMPARE(q.y(), (qreal)8.0f);
QCOMPARE(q.z(), (qreal)9.0f);
obj.setProperty("quaternion",
qVariantFromValue(QQuaternion(-6.0f, -7.0f, -8.0f, -9.0f)));
QVariant::fromValue(QQuaternion(-6.0f, -7.0f, -8.0f, -9.0f)));
q = qVariantValue<QQuaternion>(obj.property("quaternion"));
q = qvariant_cast<QQuaternion>(obj.property("quaternion"));
QCOMPARE(q.scalar(), (qreal)-6.0f);
QCOMPARE(q.x(), (qreal)-7.0f);
QCOMPARE(q.y(), (qreal)-8.0f);

18
tests/auto/gui/math3d/qvectornd/tst_qvectornd.cpp
View File

@ -2077,38 +2077,38 @@ void tst_QVectorND::properties()
obj.setVector3D(QVector3D(3.0f, 4.0f, 5.0f));
obj.setVector4D(QVector4D(6.0f, 7.0f, 8.0f, 9.0f));
QVector2D v2 = qVariantValue<QVector2D>(obj.property("vector2D"));
QVector2D v2 = qvariant_cast<QVector2D>(obj.property("vector2D"));
QCOMPARE(v2.x(), (qreal)1.0f);
QCOMPARE(v2.y(), (qreal)2.0f);
QVector3D v3 = qVariantValue<QVector3D>(obj.property("vector3D"));
QVector3D v3 = qvariant_cast<QVector3D>(obj.property("vector3D"));
QCOMPARE(v3.x(), (qreal)3.0f);
QCOMPARE(v3.y(), (qreal)4.0f);
QCOMPARE(v3.z(), (qreal)5.0f);
QVector4D v4 = qVariantValue<QVector4D>(obj.property("vector4D"));
QVector4D v4 = qvariant_cast<QVector4D>(obj.property("vector4D"));
QCOMPARE(v4.x(), (qreal)6.0f);
QCOMPARE(v4.y(), (qreal)7.0f);
QCOMPARE(v4.z(), (qreal)8.0f);
QCOMPARE(v4.w(), (qreal)9.0f);
obj.setProperty("vector2D",
qVariantFromValue(QVector2D(-1.0f, -2.0f)));
QVariant::fromValue(QVector2D(-1.0f, -2.0f)));
obj.setProperty("vector3D",
qVariantFromValue(QVector3D(-3.0f, -4.0f, -5.0f)));
QVariant::fromValue(QVector3D(-3.0f, -4.0f, -5.0f)));
obj.setProperty("vector4D",
qVariantFromValue(QVector4D(-6.0f, -7.0f, -8.0f, -9.0f)));
QVariant::fromValue(QVector4D(-6.0f, -7.0f, -8.0f, -9.0f)));
v2 = qVariantValue<QVector2D>(obj.property("vector2D"));
v2 = qvariant_cast<QVector2D>(obj.property("vector2D"));
QCOMPARE(v2.x(), (qreal)-1.0f);
QCOMPARE(v2.y(), (qreal)-2.0f);
v3 = qVariantValue<QVector3D>(obj.property("vector3D"));
v3 = qvariant_cast<QVector3D>(obj.property("vector3D"));
QCOMPARE(v3.x(), (qreal)-3.0f);
QCOMPARE(v3.y(), (qreal)-4.0f);
QCOMPARE(v3.z(), (qreal)-5.0f);
v4 = qVariantValue<QVector4D>(obj.property("vector4D"));
v4 = qvariant_cast<QVector4D>(obj.property("vector4D"));
QCOMPARE(v4.x(), (qreal)-6.0f);
QCOMPARE(v4.y(), (qreal)-7.0f);
QCOMPARE(v4.z(), (qreal)-8.0f);

22
tests/auto/network/access/qnetworkrequest/tst_qnetworkrequest.cpp
View File

@ -282,21 +282,21 @@ void tst_QNetworkRequest::setHeader_data()
cookie.setName("a");
cookie.setValue("b");
QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie"
<< "a=b";
QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b";
cookie.setPath("/");
QTest::newRow("Cookie-2") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie"
<< "a=b";
QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b; path=/";
@ -304,11 +304,11 @@ void tst_QNetworkRequest::setHeader_data()
cookie2.setName("c");
cookie2.setValue("d");
QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Cookie"
<< "a=b; c=d";
QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Set-Cookie"
<< "a=b; path=/, c=d";
}
@ -388,17 +388,17 @@ void tst_QNetworkRequest::rawHeaderParsing_data()
cookie.setName("a");
cookie.setValue("b");
QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie"
<< "a=b";
QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b";
cookie.setPath("/");
QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b; path=/";
@ -407,12 +407,12 @@ void tst_QNetworkRequest::rawHeaderParsing_data()
cookie2.setName("c");
cookie2.setValue("d");
QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Cookie"
<< "a=b; c=d";
cookie.setPath("/");
QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Set-Cookie"
<< "a=b; path=/, c=d";
}

10
tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
View File

@ -383,7 +383,7 @@ void tst_QLocalSocket::listenAndConnect()
QVERIFY(socket->error() != QLocalSocket::UnknownSocketError);
QCOMPARE(socket->state(), QLocalSocket::UnconnectedState);
//QVERIFY(socket->socketDescriptor() == -1);
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QLocalSocket::ServerNotFoundError);
}
@ -403,19 +403,19 @@ void tst_QLocalSocket::listenAndConnect()
QVERIFY(spyError.count() >= 0);
if (canListen) {
if (spyError.count() > 0)
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QLocalSocket::SocketTimeoutError);
} else {
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QLocalSocket::ServerNotFoundError);
}
// Check first and last state
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.first()[0]),
QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketState>(spyStateChanged.first()[0]),
QLocalSocket::ConnectingState);
if (canListen)
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.last()[0]),
QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketState>(spyStateChanged.last()[0]),
QLocalSocket::ConnectedState);
QCOMPARE(spyStateChanged.count(), 2);
QCOMPARE(spyReadyRead.count(), 0);

4
tests/auto/network/socket/qsocks5socketengine/tst_qsocks5socketengine.cpp
View File

@ -130,7 +130,7 @@ private slots:
{
QTcpSocket *client = nextPendingConnection();
connect(client, SIGNAL(readyRead()), SLOT(handleClientCommand()));
client->setProperty("pendingResponses", qVariantFromValue(responses));
client->setProperty("pendingResponses", QVariant::fromValue(responses));
}
void handleClientCommand()
@ -145,7 +145,7 @@ private slots:
client->disconnectFromHost();
else
client->write(pendingResponses.dequeue());
client->setProperty("pendingResponses", qVariantFromValue(pendingResponses));
client->setProperty("pendingResponses", QVariant::fromValue(pendingResponses));
}
};

6
tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
View File

@ -2212,9 +2212,9 @@ void tst_QTcpSocket::connectionRefused()
QCOMPARE(socket->error(), QAbstractSocket::ConnectionRefusedError);
QCOMPARE(stateSpy.count(), 3);
QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState);
QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(1).at(0)), QAbstractSocket::ConnectingState);
QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(2).at(0)), QAbstractSocket::UnconnectedState);
QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState);
QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(1).at(0)), QAbstractSocket::ConnectingState);
QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(2).at(0)), QAbstractSocket::UnconnectedState);
QCOMPARE(errorSpy.count(), 1);
delete socket;

4
tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
View File

@ -1793,8 +1793,8 @@ void tst_QSslSocket::peerVerifyError()
QVERIFY(!socket->waitForEncrypted(10000));
QVERIFY(!peerVerifyErrorSpy.isEmpty());
QVERIFY(!sslErrorsSpy.isEmpty());
QCOMPARE(qVariantValue<QSslError>(peerVerifyErrorSpy.last().at(0)).error(), QSslError::HostNameMismatch);
QCOMPARE(qVariantValue<QList<QSslError> >(sslErrorsSpy.at(0).at(0)).size(), peerVerifyErrorSpy.size());
QCOMPARE(qvariant_cast<QSslError>(peerVerifyErrorSpy.last().at(0)).error(), QSslError::HostNameMismatch);
QCOMPARE(qvariant_cast<QList<QSslError> >(sslErrorsSpy.at(0).at(0)).size(), peerVerifyErrorSpy.size());
}
void tst_QSslSocket::disconnectFromHostWhenConnecting()

14
tests/auto/other/modeltest/modeltest.cpp
View File

@ -414,27 +414,27 @@ void ModelTest::data()
// General Purpose roles that should return a QString
QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole );
if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QString> ( variant ) );
QVERIFY( variant.canConvert<QString>() );
}
variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );
if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QString> ( variant ) );
QVERIFY( variant.canConvert<QString>() );
}
variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );
if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QString> ( variant ) );
QVERIFY( variant.canConvert<QString>() );
}
// General Purpose roles that should return a QSize
variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );
if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QSize> ( variant ) );
QVERIFY( variant.canConvert<QSize>() );
}
// General Purpose roles that should return a QFont
QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole );
if ( fontVariant.isValid() ) {
QVERIFY( qVariantCanConvert<QFont> ( fontVariant ) );
QVERIFY( fontVariant.canConvert<QFont>() );
}
// Check that the alignment is one we know about
@ -447,12 +447,12 @@ void ModelTest::data()
// General Purpose roles that should return a QColor
QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole );
if ( colorVariant.isValid() ) {
QVERIFY( qVariantCanConvert<QColor> ( colorVariant ) );
QVERIFY( colorVariant.canConvert<QColor>() );
}
colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );
if ( colorVariant.isValid() ) {
QVERIFY( qVariantCanConvert<QColor> ( colorVariant ) );
QVERIFY( colorVariant.canConvert<QColor>() );
}
// Check that the "check state" is one we know about.

2
tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
View File

@ -2078,7 +2078,7 @@ void tst_QSqlDatabase::eventNotificationPSQL()
QCOMPARE(spy.count(), 1);
QList<QVariant> arguments = spy.takeFirst();
QCOMPARE(arguments.at(0).toString(), procedureName);
QCOMPARE(qVariantValue<QSqlDriver::NotificationSource>(arguments.at(1)), QSqlDriver::SelfSource);
QCOMPARE(qvariant_cast<QSqlDriver::NotificationSource>(arguments.at(1)), QSqlDriver::SelfSource);
QCOMPARE(qvariant_cast<QVariant>(arguments.at(2)).toString(), payload);
QVERIFY_SQL(driver, unsubscribeFromNotification(procedureName));
}

2
tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
View File

@ -3001,7 +3001,7 @@ void tst_QSqlQuery::QTBUG_551()
q.bindValue(":outp", outLst, QSql::Out);
QVERIFY_SQL(q, execBatch(QSqlQuery::ValuesAsColumns) );
res_outLst = qVariantValue<QVariantList>(q.boundValues()[":outp"]);
res_outLst = qvariant_cast<QVariantList>(q.boundValues()[":outp"]);
QCOMPARE(res_outLst[0].toString(), QLatin1String("1. Value is 0"));
QCOMPARE(res_outLst[1].toString(), QLatin1String("2. Value is 1"));
QCOMPARE(res_outLst[2].toString(), QLatin1String("3. Value is 2"));

14
tests/auto/tools/moc/tst_moc.cpp
View File

@ -860,13 +860,13 @@ void tst_Moc::namespaceTypeProperty()
QByteArray ba = QByteArray("points");
QVariant v = tst.property(ba);
QVERIFY(v.isValid());
myNS::Points p = qVariantValue<myNS::Points>(v);
myNS::Points p = qvariant_cast<myNS::Points>(v);
QCOMPARE(p.p1, 0xBEEF);
QCOMPARE(p.p2, 0xBABE);
p.p1 = 0xCAFE;
p.p2 = 0x1EE7;
QVERIFY(tst.setProperty(ba, qVariantFromValue(p)));
myNS::Points pp = qVariantValue<myNS::Points>(tst.property(ba));
QVERIFY(tst.setProperty(ba, QVariant::fromValue(p)));
myNS::Points pp = qvariant_cast<myNS::Points>(tst.property(ba));
QCOMPARE(p.p1, pp.p1);
QCOMPARE(p.p2, pp.p2);
}
@ -1181,16 +1181,16 @@ void tst_Moc::qprivateproperties()
PrivatePropertyTest test;
test.setProperty("foo", 1);
QCOMPARE(test.property("foo"), qVariantFromValue(1));
QCOMPARE(test.property("foo"), QVariant::fromValue(1));
test.setProperty("bar", 2);
QCOMPARE(test.property("bar"), qVariantFromValue(2));
QCOMPARE(test.property("bar"), QVariant::fromValue(2));
test.setProperty("plop", 3);
QCOMPARE(test.property("plop"), qVariantFromValue(3));
QCOMPARE(test.property("plop"), QVariant::fromValue(3));
test.setProperty("baz", 4);
QCOMPARE(test.property("baz"), qVariantFromValue(4));
QCOMPARE(test.property("baz"), QVariant::fromValue(4));
}

24
tests/auto/widgets/dialogs/qfiledialog/tst_qfiledialog.cpp
View File

@ -1061,11 +1061,11 @@ void tst_QFiledialog::historyBack()
QCOMPARE(backButton->isEnabled(), true);
QCOMPARE(forwardButton->isEnabled(), true);
QCOMPARE(spy.count(), 3);
QString currentPath = qVariantValue<QString>(spy.last().first());
QString currentPath = qvariant_cast<QString>(spy.last().first());
QCOMPARE(model->index(currentPath), model->index(temp));
backButton->click();
currentPath = qVariantValue<QString>(spy.last().first());
currentPath = qvariant_cast<QString>(spy.last().first());
QCOMPARE(currentPath, home);
QCOMPARE(backButton->isEnabled(), false);
QCOMPARE(forwardButton->isEnabled(), true);
@ -1101,39 +1101,39 @@ void tst_QFiledialog::historyForward()
backButton->click();
QCOMPARE(forwardButton->isEnabled(), true);
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(temp));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(temp));
forwardButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(desktop));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(desktop));
QCOMPARE(backButton->isEnabled(), true);
QCOMPARE(forwardButton->isEnabled(), false);
QCOMPARE(spy.count(), 4);
backButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(temp));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(temp));
QCOMPARE(backButton->isEnabled(), true);
backButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(home));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(home));
QCOMPARE(backButton->isEnabled(), false);
QCOMPARE(forwardButton->isEnabled(), true);
QCOMPARE(spy.count(), 6);
forwardButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(temp));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(temp));
backButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(home));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(home));
QCOMPARE(spy.count(), 8);
forwardButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(temp));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(temp));
forwardButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(desktop));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(desktop));
backButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(temp));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(temp));
backButton->click();
QCOMPARE(model->index(qVariantValue<QString>(spy.last().first())), model->index(home));
QCOMPARE(model->index(qvariant_cast<QString>(spy.last().first())), model->index(home));
fd.setDirectory(desktop);
QCOMPARE(forwardButton->isEnabled(), false);
}

80
tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp
View File

@ -2219,7 +2219,7 @@ void tst_QGraphicsItem::setMatrix()
QApplication::instance()->processEvents();
QCOMPARE(spy.count(), 3);
QList<QRectF> rlist = qVariantValue<QList<QRectF> >(spy.last().at(0));
QList<QRectF> rlist = qvariant_cast<QList<QRectF> >(spy.last().at(0));
QCOMPARE(rlist.size(), 3);
QCOMPARE(rlist.at(0), rotatedRect); // From item.setMatrix() (clearing rotated rect)
@ -4450,13 +4450,13 @@ protected:
break;
case QGraphicsItem::ItemMatrixChange: {
QVariant variant;
qVariantSetValue<QMatrix>(variant, matrix());
variant.setValue<QMatrix>(matrix());
oldValues << variant;
}
break;
case QGraphicsItem::ItemTransformChange: {
QVariant variant;
qVariantSetValue<QTransform>(variant, transform());
variant.setValue<QTransform>(transform());
oldValues << variant;
}
break;
@ -4478,7 +4478,7 @@ protected:
case QGraphicsItem::ItemSelectedHasChanged:
break;
case QGraphicsItem::ItemParentChange:
oldValues << qVariantFromValue<void *>(parentItem());
oldValues << QVariant::fromValue<void *>(parentItem());
break;
case QGraphicsItem::ItemParentHasChanged:
break;
@ -4489,11 +4489,11 @@ protected:
oldValues << children().size();
break;
case QGraphicsItem::ItemSceneChange:
oldValues << qVariantFromValue<QGraphicsScene *>(scene());
oldValues << QVariant::fromValue<QGraphicsScene *>(scene());
if (itemSceneChangeTargetScene
&& qVariantValue<QGraphicsScene *>(value)
&& itemSceneChangeTargetScene != qVariantValue<QGraphicsScene *>(value)) {
return qVariantFromValue<QGraphicsScene *>(itemSceneChangeTargetScene);
&& qvariant_cast<QGraphicsScene *>(value)
&& itemSceneChangeTargetScene != qvariant_cast<QGraphicsScene *>(value)) {
return QVariant::fromValue<QGraphicsScene *>(itemSceneChangeTargetScene);
}
return value;
case QGraphicsItem::ItemSceneHasChanged:
@ -4573,17 +4573,17 @@ void tst_QGraphicsItem::itemChange()
}
{
// ItemMatrixChange / ItemTransformHasChanged
qVariantSetValue<QMatrix>(tester.itemChangeReturnValue, QMatrix().rotate(90));
tester.itemChangeReturnValue.setValue<QMatrix>(QMatrix().rotate(90));
tester.setMatrix(QMatrix().translate(50, 0), true);
++changeCount; // notification sent too
QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(int(tester.changes.at(tester.changes.size() - 2)), int(QGraphicsItem::ItemMatrixChange));
QCOMPARE(int(tester.changes.last()), int(QGraphicsItem::ItemTransformHasChanged));
QCOMPARE(qVariantValue<QMatrix>(tester.values.at(tester.values.size() - 2)),
QCOMPARE(qvariant_cast<QMatrix>(tester.values.at(tester.values.size() - 2)),
QMatrix().translate(50, 0));
QCOMPARE(tester.values.last(), QVariant(QTransform(QMatrix().rotate(90))));
QVariant variant;
qVariantSetValue<QMatrix>(variant, QMatrix());
variant.setValue<QMatrix>(QMatrix());
QCOMPARE(tester.oldValues.last(), variant);
QCOMPARE(tester.matrix(), QMatrix().rotate(90));
}
@ -4593,19 +4593,19 @@ void tst_QGraphicsItem::itemChange()
++changeCount; // notification sent too
// ItemTransformChange / ItemTransformHasChanged
qVariantSetValue<QTransform>(tester.itemChangeReturnValue, QTransform().rotate(90));
tester.itemChangeReturnValue.setValue<QTransform>(QTransform().rotate(90));
tester.translate(50, 0);
++changeCount; // notification sent too
++changeCount;
QCOMPARE(tester.changes.size(), changeCount);
QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemTransformChange);
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemTransformHasChanged);
QCOMPARE(qVariantValue<QTransform>(tester.values.at(tester.values.size() - 2)),
QCOMPARE(qvariant_cast<QTransform>(tester.values.at(tester.values.size() - 2)),
QTransform().translate(50, 0));
QCOMPARE(qVariantValue<QTransform>(tester.values.at(tester.values.size() - 1)),
QCOMPARE(qvariant_cast<QTransform>(tester.values.at(tester.values.size() - 1)),
QTransform().rotate(90));
QVariant variant;
qVariantSetValue<QTransform>(variant, QTransform());
variant.setValue<QTransform>(QTransform());
QCOMPARE(tester.oldValues.last(), variant);
QCOMPARE(tester.transform(), QTransform().rotate(90));
}
@ -4690,9 +4690,9 @@ void tst_QGraphicsItem::itemChange()
QCOMPARE(tester.changes.size(), changeCount);
QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemFlagsChange);
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemFlagsHaveChanged);
QVariant expectedFlags = qVariantFromValue<quint32>(QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges));
QVariant expectedFlags = QVariant::fromValue<quint32>(QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges));
QCOMPARE(tester.values.at(tester.values.size() - 2), expectedFlags);
QCOMPARE(tester.values.at(tester.values.size() - 1), qVariantFromValue<quint32>((quint32)QGraphicsItem::ItemIsSelectable));
QCOMPARE(tester.values.at(tester.values.size() - 1), QVariant::fromValue<quint32>((quint32)QGraphicsItem::ItemIsSelectable));
}
{
// ItemSelectedChange
@ -4739,12 +4739,12 @@ void tst_QGraphicsItem::itemChange()
}
{
// ItemParentChange
qVariantSetValue<QGraphicsItem *>(tester.itemChangeReturnValue, 0);
tester.itemChangeReturnValue.setValue<QGraphicsItem *>(0);
tester.setParentItem(&testerHelper);
QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(tester.changes.last(), QGraphicsItem::ItemParentChange);
QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
QCOMPARE(qVariantValue<QGraphicsItem *>(tester.oldValues.last()), (QGraphicsItem *)0);
QCOMPARE(qvariant_cast<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
QCOMPARE(qvariant_cast<QGraphicsItem *>(tester.oldValues.last()), (QGraphicsItem *)0);
QCOMPARE(tester.parentItem(), (QGraphicsItem *)0);
}
{
@ -4771,14 +4771,14 @@ void tst_QGraphicsItem::itemChange()
testerHelper.setParentItem(&tester);
QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(tester.changes.last(), QGraphicsItem::ItemChildAddedChange);
QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
QCOMPARE(qvariant_cast<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
}
{
// ItemChildRemovedChange 1
testerHelper.setParentItem(0);
QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(tester.changes.last(), QGraphicsItem::ItemChildRemovedChange);
QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
QCOMPARE(qvariant_cast<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
// ItemChildRemovedChange 1
ItemChangeTester *test = new ItemChangeTester;
@ -4819,10 +4819,10 @@ void tst_QGraphicsItem::itemChange()
ItemChangeTester *child = new ItemChangeTester;
child->setParentItem(&parent);
QCOMPARE(parent.changes.last(), QGraphicsItem::ItemChildAddedChange);
QCOMPARE(qVariantValue<QGraphicsItem *>(parent.values.last()), (QGraphicsItem *)child);
QCOMPARE(qvariant_cast<QGraphicsItem *>(parent.values.last()), (QGraphicsItem *)child);
delete child;
QCOMPARE(parent.changes.last(), QGraphicsItem::ItemChildRemovedChange);
QCOMPARE(qVariantValue<QGraphicsItem *>(parent.values.last()), (QGraphicsItem *)child);
QCOMPARE(qvariant_cast<QGraphicsItem *>(parent.values.last()), (QGraphicsItem *)child);
}
{
// !!! Note: If this test crashes because of double-deletion, there's
@ -4841,8 +4841,8 @@ void tst_QGraphicsItem::itemChange()
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
// Item's old value was 0
// Item's current value is scene
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene);
scene2.addItem(&tester);
++changeCount; // ItemSceneChange (0) was: (scene)
++changeCount; // ItemSceneHasChanged (0)
@ -4858,16 +4858,16 @@ void tst_QGraphicsItem::itemChange()
// Item's last old value was scene
// Item's last current value is 0
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 2)), (QGraphicsScene *)&scene);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 1)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 4)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene2);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene2);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 2)), (QGraphicsScene *)&scene);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 1)), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 4)), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene2);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene2);
// Item's last old value was 0
// Item's last current value is scene2
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene2);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene2);
scene2.removeItem(&tester);
++changeCount; // ItemSceneChange (0) was: (scene2)
@ -4879,9 +4879,9 @@ void tst_QGraphicsItem::itemChange()
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
// Item's last old value was scene2
// Item's last current value is 0
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)&scene2);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)&scene2);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)0);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)0);
tester.itemSceneChangeTargetScene = &scene;
scene2.addItem(&tester);
@ -4890,9 +4890,9 @@ void tst_QGraphicsItem::itemChange()
++changeCount; // ItemSceneHasChanged (scene)
QCOMPARE(tester.values.size(), changeCount);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)&scene2);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)&scene2);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene);
QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene);
QCOMPARE(tester.scene(), &scene);
tester.itemSceneChangeTargetScene = 0;

2
tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp
View File

@ -2830,7 +2830,7 @@ void tst_QGraphicsScene::update()
// Check that the update region is correct
QCOMPARE(spy.count(), 1);
QRectF region;
foreach (QRectF rectF, qVariantValue<QList<QRectF> >(spy.at(0).at(0)))
foreach (QRectF rectF, qvariant_cast<QList<QRectF> >(spy.at(0).at(0)))
region |= rectF;
QCOMPARE(region, QRectF(-100, -100, 200, 200));
}

8
tests/auto/widgets/graphicsview/qgraphicswidget/tst_qgraphicswidget.cpp
View File

@ -3211,11 +3211,11 @@ void tst_QGraphicsWidget::itemChangeEvents()
break;
}
case QEvent::ParentAboutToChange: {
valueDuringEvents.insert(QEvent::ParentAboutToChange, qVariantFromValue(parentItem()));
valueDuringEvents.insert(QEvent::ParentAboutToChange, QVariant::fromValue(parentItem()));
break;
}
case QEvent::ParentChange: {
valueDuringEvents.insert(QEvent::ParentChange, qVariantFromValue(parentItem()));
valueDuringEvents.insert(QEvent::ParentChange, QVariant::fromValue(parentItem()));
break;
}
case QEvent::CursorChange: {
@ -3252,10 +3252,10 @@ void tst_QGraphicsWidget::itemChangeEvents()
TestGraphicsWidget *item = new TestGraphicsWidget;
item->setParentItem(parent);
// ParentAboutToChange should be triggered before the parent has changed
QTRY_COMPARE(qVariantValue<QGraphicsItem *>(item->valueDuringEvents.value(QEvent::ParentAboutToChange)),
QTRY_COMPARE(qvariant_cast<QGraphicsItem *>(item->valueDuringEvents.value(QEvent::ParentAboutToChange)),
static_cast<QGraphicsItem *>(0));
// ParentChange should be triggered after the parent has changed
QTRY_COMPARE(qVariantValue<QGraphicsItem *>(item->valueDuringEvents.value(QEvent::ParentChange)),
QTRY_COMPARE(qvariant_cast<QGraphicsItem *>(item->valueDuringEvents.value(QEvent::ParentChange)),
static_cast<QGraphicsItem *>(parent));
// ShowEvent should be triggered before the item is shown

50
tests/auto/widgets/kernel/qapplication/tst_qapplication.cpp
View File

@ -1466,8 +1466,8 @@ void tst_QApplication::focusChanged()
QApplication::setActiveWindow(&parent1); // needs this on twm (focus follows mouse)
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).count(), 2);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le1);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == 0);
@ -1476,8 +1476,8 @@ void tst_QApplication::focusChanged()
pb1.setFocus();
QCOMPARE(spy.count(), 1);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb1);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le1);
@ -1485,8 +1485,8 @@ void tst_QApplication::focusChanged()
lb1.setFocus();
QCOMPARE(spy.count(), 1);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &lb1);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb1);
@ -1494,8 +1494,8 @@ void tst_QApplication::focusChanged()
lb1.clearFocus();
QCOMPARE(spy.count(), 1);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == 0);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &lb1);
@ -1513,8 +1513,8 @@ void tst_QApplication::focusChanged()
parent2.show();
QApplication::setActiveWindow(&parent2); // needs this on twm (focus follows mouse)
QVERIFY(spy.count() > 0); // one for deactivation, one for activation on Windows
old = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(0));
now = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(1));
old = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(0));
now = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(1));
QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == 0);
@ -1547,8 +1547,8 @@ void tst_QApplication::focusChanged()
QVERIFY(now == QApplication::focusWidget());
} else {
QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2);
@ -1561,8 +1561,8 @@ void tst_QApplication::focusChanged()
} else {
tab.simulate(now);
QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb2);
@ -1575,8 +1575,8 @@ void tst_QApplication::focusChanged()
} else {
backtab.simulate(now);
QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2);
@ -1591,8 +1591,8 @@ void tst_QApplication::focusChanged()
} else {
backtab.simulate(now);
QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb2);
@ -1605,8 +1605,8 @@ void tst_QApplication::focusChanged()
QVERIFY(now == QApplication::focusWidget());
} else {
QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2);
@ -1614,8 +1614,8 @@ void tst_QApplication::focusChanged()
click.simulate(old);
QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1));
old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb2);
@ -1629,10 +1629,10 @@ void tst_QApplication::focusChanged()
//on windows, the change of focus is made in 2 steps
//(the focusChanged SIGNAL is emitted twice)
if (spy.count()==1)
old = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(0));
old = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(0));
else
old = qVariantValue<QWidget*>(spy.at(spy.count()-2).at(0));
now = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(1));
old = qvariant_cast<QWidget*>(spy.at(spy.count()-2).at(0));
now = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(1));
QVERIFY(now == &le1);
QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2);

10
tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
View File

@ -2049,7 +2049,7 @@ void tst_QDateTimeEdit::dateSignalChecking()
if (timesEmitted > 0) {
QList<QVariant> list = dateSpy.takeFirst();
QDate d;
d = qVariantValue<QDate>(list.at(0));
d = qvariant_cast<QDate>(list.at(0));
QCOMPARE(d, newDate);
}
QCOMPARE(dateTimeSpy.count(), timesEmitted);
@ -2085,7 +2085,7 @@ void tst_QDateTimeEdit::timeSignalChecking()
if (timesEmitted > 0) {
QList<QVariant> list = timeSpy.takeFirst();
QTime t;
t = qVariantValue<QTime>(list.at(0));
t = qvariant_cast<QTime>(list.at(0));
QCOMPARE(t, newTime);
}
QCOMPARE(dateTimeSpy.count(), timesEmitted);
@ -2135,21 +2135,21 @@ void tst_QDateTimeEdit::dateTimeSignalChecking()
QCOMPARE(timesDateEmitted, 1);
QList<QVariant> list = dateSpy.takeFirst();
QDate d;
d = qVariantValue<QDate>(list.at(0));
d = qvariant_cast<QDate>(list.at(0));
QCOMPARE(d, newDateTime.date());
}
QCOMPARE(timeSpy.count(), timesTimeEmitted);
if (timesTimeEmitted > 0) {
QList<QVariant> list = timeSpy.takeFirst();
QTime t;
t = qVariantValue<QTime>(list.at(0));
t = qvariant_cast<QTime>(list.at(0));
QCOMPARE(t, newDateTime.time());
}
QCOMPARE(dateTimeSpy.count(), timesDateTimeEmitted);
if (timesDateTimeEmitted > 0) {
QList<QVariant> list = dateTimeSpy.takeFirst();
QDateTime dt;
dt = qVariantValue<QDateTime>(list.at(0));
dt = qvariant_cast<QDateTime>(list.at(0));
QCOMPARE(dt, newDateTime);
}
}

2
tests/benchmarks/corelib/kernel/qvariant/tst_qvariant.cpp
View File

@ -188,7 +188,7 @@ static void variantSetValue(T d)
QVariant v;
QBENCHMARK {
for(int i = 0; i < ITERATION_COUNT; ++i) {
qVariantSetValue(v, d);
v.setValue(d);
}
}
}

8
tests/benchmarks/dbus/qdbusperformance/tst_qdbusperformance.cpp
View File

@ -168,13 +168,13 @@ void tst_QDBusPerformance::oneWay_data()
QByteArray ba(256, 'a');
while (ba.size() < 8193) {
QTest::newRow(QString("%1-byteArray").arg(ba.size()).toAscii()) << qVariantFromValue(ba) << ba.size();
QTest::newRow(QString("%1-byteArray").arg(ba.size()).toAscii()) << QVariant::fromValue(ba) << ba.size();
ba += ba;
}
QString s(256, QLatin1Char('a'));
while (s.size() < 8193) {
QTest::newRow(QString("%1-string").arg(s.size()).toAscii()) << qVariantFromValue(s) << s.size();
QTest::newRow(QString("%1-string").arg(s.size()).toAscii()) << QVariant::fromValue(s) << s.size();
s += s;
}
}
@ -197,7 +197,7 @@ void tst_QDBusPerformance::oneWayVariant()
QFETCH(QVariant, data);
QFETCH(int, size);
QVERIFY(executeTest("size", size, qVariantFromValue(QDBusVariant(data))));
QVERIFY(executeTest("size", size, QVariant::fromValue(QDBusVariant(data))));
}
void tst_QDBusPerformance::roundTrip_data()
@ -223,7 +223,7 @@ void tst_QDBusPerformance::roundTripVariant()
QFETCH(QVariant, data);
QFETCH(int, size);
QVERIFY(executeTest("echo", size, qVariantFromValue(QDBusVariant(data))));
QVERIFY(executeTest("echo", size, QVariant::fromValue(QDBusVariant(data))));
}
QTEST_MAIN(tst_QDBusPerformance)

8
tests/manual/bearerex/bearerex.cpp
View File

@ -90,7 +90,7 @@ void BearerEx::showConfigurations()
font.setUnderline(true);
listItem->setFont(font);
listItem->setText(" UserChoice");
listItem->setData(Qt::UserRole, qVariantFromValue(defaultConfig));
listItem->setData(Qt::UserRole, QVariant::fromValue(defaultConfig));
listWidget->addItem(listItem);
}
@ -121,7 +121,7 @@ void BearerEx::showConfigurations()
listItem->setFont(font);
}
listItem->setText(text);
listItem->setData(Qt::UserRole, qVariantFromValue(configurations[i]));
listItem->setData(Qt::UserRole, QVariant::fromValue(configurations[i]));
listWidget->addItem(listItem);
}
}
@ -143,7 +143,7 @@ void BearerEx::on_showDetailsButton_clicked()
return;
}
QNetworkConfiguration networkConfiguration = qVariantValue<QNetworkConfiguration>(item->data(Qt::UserRole));
QNetworkConfiguration networkConfiguration = qvariant_cast<QNetworkConfiguration>(item->data(Qt::UserRole));
DetailedInfoDialog infoDialog(&networkConfiguration,this);
infoDialog.exec();
}
@ -154,7 +154,7 @@ void BearerEx::on_createSessionButton_clicked()
if (!item) {
return;
}
QNetworkConfiguration networkConfiguration = qVariantValue<QNetworkConfiguration>(item->data(Qt::UserRole));
QNetworkConfiguration networkConfiguration = qvariant_cast<QNetworkConfiguration>(item->data(Qt::UserRole));
int newTabIndex = mainTabWidget->count();
SessionTab* newTab = new SessionTab(&networkConfiguration,&m_NetworkConfigurationManager,eventListWidget,newTabIndex-1);
QString label = QString("S")+QString::number(newTabIndex-1);