1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions 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: case DBUS_TYPE_UNIX_FD:
if (capabilities & QDBusConnection::UnixFileDescriptorPassing) if (capabilities & QDBusConnection::UnixFileDescriptorPassing)
return qVariantFromValue(toUnixFileDescriptor()); return QVariant::fromValue(toUnixFileDescriptor());
// fall through // fall through
default: default:

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

@ -544,7 +544,7 @@ QSize ValueExtractor::sizeValue(const Declaration &decl)
else else
x[1] = x[0]; x[1] = x[0];
QList<QVariant> v; 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; decl.d->parsed = v;
return QSize(lengthValueFromData(x[0], f), lengthValueFromData(x[1], f)); 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(); downloadZerocopyBuffer = downloadBufferPointer.data();
downloadBufferCurrentSize = 0; downloadBufferCurrentSize = 0;
downloadBufferMaximumSize = contentLength; downloadBufferMaximumSize = contentLength;
q->setAttribute(QNetworkRequest::DownloadBufferAttribute, qVariantFromValue<QSharedPointer<char> > (downloadBufferPointer)); q->setAttribute(QNetworkRequest::DownloadBufferAttribute, QVariant::fromValue<QSharedPointer<char> > (downloadBufferPointer));
} }
q->setAttribute(QNetworkRequest::HttpPipeliningWasUsedAttribute, pu); 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 downloadBuffer = new char[downloadBufferMaximumSize]; // throws if allocation fails
downloadBufferPointer = QSharedPointer<char>(downloadBuffer, downloadBufferDeleter); 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(); downloadBuffer = downloadBufferPointer.data();
downloadBufferCurrentSize = 0; downloadBufferCurrentSize = 0;
downloadBufferMaximumSize = size; 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)); // this->setProperty("Active", QVariant(on));
return setProp("Active", qVariantFromValue(on)); return setProp("Active", QVariant::fromValue(on));
} }
bool QOfonoPrimaryDataContextInterface::setApn(const QString &name) bool QOfonoPrimaryDataContextInterface::setApn(const QString &name)
@ -855,7 +855,7 @@ QVariantMap QOfonoPrimaryDataContextInterface::getProperties()
bool QOfonoPrimaryDataContextInterface::setProp(const QString &property, const QVariant &var) bool QOfonoPrimaryDataContextInterface::setProp(const QString &property, const QVariant &var)
{ {
QList<QVariant> args; QList<QVariant> args;
args << qVariantFromValue(property) << qVariantFromValue(QDBusVariant(var)); args << QVariant::fromValue(property) << QVariant::fromValue(QDBusVariant(var));
QDBusMessage reply = this->callWithArgumentList(QDBus::AutoDetect, QDBusMessage reply = this->callWithArgumentList(QDBus::AutoDetect,
QLatin1String("SetProperty"), QLatin1String("SetProperty"),

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

@ -153,7 +153,7 @@ protected:
return QMimeData::retrieveData(mimetype, preferredType); return QMimeData::retrieveData(mimetype, preferredType);
const QByteArray data = readClipboardBuff(mimetype.toUtf8().constData()); const QByteArray data = readClipboardBuff(mimetype.toUtf8().constData());
return qVariantFromValue(data); return QVariant::fromValue(data);
} }
private Q_SLOTS: 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 MYSQL_VERSION_ID >= 40108
if(d->preparedQuery) 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 else
#endif #endif
return QVariant::fromValue(d->result); 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(groupStateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(group.state(), QAnimationGroup::Stopped); QCOMPARE(group.state(), QAnimationGroup::Stopped);
@ -160,9 +160,9 @@ void tst_QAnimationGroup::emptyGroup()
group.start(); group.start();
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(2).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(2).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(3).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(groupStateChangedSpy.at(3).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(group.state(), 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(); group.start();
//all the animations should be started //all the animations should be started
QCOMPARE(spy1.count(), 1); 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(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(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(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 group.setCurrentTime(1500); //anim1 should be finished
QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 2); 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(spy2.count(), 1); //no change
QCOMPARE(spy3.count(), 1); //no change QCOMPARE(spy3.count(), 1); //no change
QCOMPARE(spy4.count(), 1); //no change QCOMPARE(spy4.count(), 1); //no change
@ -290,7 +290,7 @@ void tst_QParallelAnimationGroup::stateChanged()
QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 2); //no change QCOMPARE(spy1.count(), 2); //no change
QCOMPARE(spy2.count(), 2); 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(spy3.count(), 1); //no change
QCOMPARE(spy4.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(spy1.count(), 2); //no change
QCOMPARE(spy2.count(), 2); //no change QCOMPARE(spy2.count(), 2); //no change
QCOMPARE(spy3.count(), 2); 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(spy4.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped); QCOMPARE(qvariant_cast<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
//cleanup //cleanup
spy1.clear(); spy1.clear();
@ -318,22 +318,22 @@ void tst_QParallelAnimationGroup::stateChanged()
QCOMPARE(spy1.count(), 0); QCOMPARE(spy1.count(), 0);
QCOMPARE(spy2.count(), 0); QCOMPARE(spy2.count(), 0);
QCOMPARE(spy3.count(), 1); 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(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 group.setCurrentTime(1500); //anim2 should be started
QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 0); //no change QCOMPARE(spy1.count(), 0); //no change
QCOMPARE(spy2.count(), 1); 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(spy3.count(), 1); //no change
QCOMPARE(spy4.count(), 1); //no change QCOMPARE(spy4.count(), 1); //no change
group.setCurrentTime(500); //anim1 is finally also started group.setCurrentTime(500); //anim1 is finally also started
QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(group.state(), QAnimationGroup::Running);
QCOMPARE(spy1.count(), 1); 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(spy2.count(), 1); //no change
QCOMPARE(spy3.count(), 1); //no change QCOMPARE(spy3.count(), 1); //no change
QCOMPARE(spy4.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 group.setCurrentTime(0); //everything should be stopped
QCOMPARE(group.state(), QAnimationGroup::Stopped); QCOMPARE(group.state(), QAnimationGroup::Stopped);
QCOMPARE(spy1.count(), 2); 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(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(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(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() void tst_QParallelAnimationGroup::clearGroup()
@ -455,9 +455,9 @@ void tst_QParallelAnimationGroup::updateChildrenWithRunningGroup()
QCOMPARE(groupStateChangedSpy.count(), 1); QCOMPARE(groupStateChangedSpy.count(), 1);
QCOMPARE(childStateChangedSpy.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); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
// starting directly a running child will not have any effect // starting directly a running child will not have any effect
@ -620,11 +620,11 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
anim2.start(); anim2.start();
anim2.pause(); anim2.pause();
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(1).first()),
QAnimationGroup::Paused); QAnimationGroup::Paused);
QCOMPARE(group.state(), QAnimationGroup::Stopped); QCOMPARE(group.state(), QAnimationGroup::Stopped);
@ -634,15 +634,15 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
group.start(); group.start();
QCOMPARE(stateChangedSpy1.count(), 3); QCOMPARE(stateChangedSpy1.count(), 3);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(2).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(stateChangedSpy2.count(), 4); QCOMPARE(stateChangedSpy2.count(), 4);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(group.state(), QAnimationGroup::Running);
@ -694,19 +694,19 @@ void tst_QParallelAnimationGroup::zeroDurationAnimation()
group.start(); group.start();
QCOMPARE(stateChangedSpy1.count(), 2); QCOMPARE(stateChangedSpy1.count(), 2);
QCOMPARE(finishedSpy1.count(), 1); QCOMPARE(finishedSpy1.count(), 1);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(stateChangedSpy2.count(), 1); QCOMPARE(stateChangedSpy2.count(), 1);
QCOMPARE(finishedSpy2.count(), 0); QCOMPARE(finishedSpy2.count(), 0);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(stateChangedSpy3.count(), 1); QCOMPARE(stateChangedSpy3.count(), 1);
QCOMPARE(finishedSpy3.count(), 0); QCOMPARE(finishedSpy3.count(), 0);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy3.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy3.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
@ -770,9 +770,9 @@ void tst_QParallelAnimationGroup::stopUncontrolledAnimations()
group.start(); group.start();
QCOMPARE(stateChangedSpy.count(), 2); QCOMPARE(stateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(group.state(), QAnimationGroup::Running);
@ -1000,10 +1000,10 @@ void tst_QParallelAnimationGroup::pauseResume()
new TestAnimation2(500, &group); new TestAnimation2(500, &group);
group.start(); group.start();
QCOMPARE(spy.count(), 1); //the animation should have been started 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 group.setCurrentTime(250); //end of first animation
QCOMPARE(spy.count(), 2); //the animation should have been stopped 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(); group.pause();
QCOMPARE(spy.count(), 2); //this shouldn't have changed QCOMPARE(spy.count(), 2); //this shouldn't have changed
group.resume(); 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) 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) QVariant xaxisQPointInterpolator(const QPointF &f, const QPointF &t, qreal progress)
@ -714,21 +714,21 @@ void tst_QPropertyAnimation::interpolated()
{ {
QObject o; QObject o;
o.setProperty("point", QPointF()); //this will avoid warnings o.setProperty("point", QPointF()); //this will avoid warnings
o.setProperty("number", qVariantFromValue<Number>(Number(42))); o.setProperty("number", QVariant::fromValue<Number>(Number(42)));
QCOMPARE(qVariantValue<Number>(o.property("number")), Number(42)); QCOMPARE(qvariant_cast<Number>(o.property("number")), Number(42));
{ {
qRegisterAnimationInterpolator<Number>(numberInterpolator); qRegisterAnimationInterpolator<Number>(numberInterpolator);
QPropertyAnimation anim(&o, "number"); QPropertyAnimation anim(&o, "number");
anim.setStartValue(qVariantFromValue<Number>(Number(0))); anim.setStartValue(QVariant::fromValue<Number>(Number(0)));
anim.setEndValue(qVariantFromValue<Number>(Number(100))); anim.setEndValue(QVariant::fromValue<Number>(Number(100)));
anim.setDuration(1000); anim.setDuration(1000);
anim.start(); anim.start();
anim.pause(); anim.pause();
anim.setCurrentTime(100); anim.setCurrentTime(100);
Number t(qVariantValue<Number>(o.property("number"))); Number t(qvariant_cast<Number>(o.property("number")));
QCOMPARE(t, Number(10)); QCOMPARE(t, Number(10));
anim.setCurrentTime(500); anim.setCurrentTime(500);
QCOMPARE(qVariantValue<Number>(o.property("number")), Number(50)); QCOMPARE(qvariant_cast<Number>(o.property("number")), Number(50));
} }
{ {
qRegisterAnimationInterpolator<QPointF>(xaxisQPointInterpolator); qRegisterAnimationInterpolator<QPointF>(xaxisQPointInterpolator);
@ -861,16 +861,16 @@ void tst_QPropertyAnimation::zeroDurationStart()
//let's check the first state change //let's check the first state change
const QVariantList firstChange = spy.first(); const QVariantList firstChange = spy.first();
//old state //old state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Stopped); QCOMPARE(qvariant_cast<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Stopped);
//new state //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 //let's check the first state change
const QVariantList secondChange = spy.last(); const QVariantList secondChange = spy.last();
//old state //old state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Running); QCOMPARE(qvariant_cast<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Running);
//new state //new state
QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Stopped); QCOMPARE(qvariant_cast<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Stopped);
} }
#define Pause 1 #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); QList<QVariant> args = spy.at(i);
QAbstractAnimation::State st = expectedStates.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) { if (equals && actual != st) {
equals = false; equals = false;
break; break;
@ -608,7 +608,7 @@ static bool compareStates(const QSignalSpy& spy, const StateList &expectedStates
} }
if (i < spy.count()) { if (i < spy.count()) {
QList<QVariant> args = spy.at(i); 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()) if (!a.isEmpty())
a += QLatin1String(", "); a += QLatin1String(", ");
if (int(actual) >= 0 && int(actual) <= 2) { if (int(actual) >= 0 && int(actual) <= 2) {
@ -677,20 +677,20 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
<< QAbstractAnimation::Running << QAbstractAnimation::Running
<< QAbstractAnimation::Stopped))); << QAbstractAnimation::Stopped)));
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(1).first()),
QAnimationGroup::Paused); QAnimationGroup::Paused);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(2).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(3).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(a1StateChangedSpy.at(4).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
QAnimationGroup::Paused); QAnimationGroup::Paused);
group.resume(); group.resume();
@ -711,7 +711,7 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
QVERIFY(a3_s_o1->currentLoopTime() >= 1); QVERIFY(a3_s_o1->currentLoopTime() >= 1);
QCOMPARE(seqStateChangedSpy.count(), 3); // Running,Paused,Running 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); QAnimationGroup::Running);
group.pause(); group.pause();
@ -732,13 +732,13 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
QVERIFY(a3_s_o1->currentLoopTime() >= 1); QVERIFY(a3_s_o1->currentLoopTime() >= 1);
QCOMPARE(seqStateChangedSpy.count(), 4); // Running,Paused,Running,Paused 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); QAnimationGroup::Paused);
group.stop(); group.stop();
QCOMPARE(seqStateChangedSpy.count(), 5); // Running,Paused,Running,Paused,Stopped 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); QAnimationGroup::Stopped);
} }
@ -782,25 +782,25 @@ void tst_QSequentialAnimationGroup::restart()
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
QCOMPARE(animsStateChanged[i]->count(), 4); 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); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(2).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(animsStateChanged[i]->at(3).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
} }
QCOMPARE(seqStateChangedSpy.count(), 2); QCOMPARE(seqStateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(seqCurrentAnimChangedSpy.count(), 6); QCOMPARE(seqCurrentAnimChangedSpy.count(), 6);
for(int i=0; i<seqCurrentAnimChangedSpy.count(); i++) 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(); group.start();
@ -1124,9 +1124,9 @@ void tst_QSequentialAnimationGroup::updateChildrenWithRunningGroup()
QCOMPARE(groupStateChangedSpy.count(), 1); QCOMPARE(groupStateChangedSpy.count(), 1);
QCOMPARE(childStateChangedSpy.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); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
// starting directly a running child will not have any effect // starting directly a running child will not have any effect
@ -1317,9 +1317,9 @@ void tst_QSequentialAnimationGroup::startGroupWithRunningChild()
QCOMPARE(anim2->state(), QAnimationGroup::Running); QCOMPARE(anim2->state(), QAnimationGroup::Running);
QCOMPARE(stateChangedSpy2.count(), 4); QCOMPARE(stateChangedSpy2.count(), 4);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
group.stop(); group.stop();
@ -1357,9 +1357,9 @@ void tst_QSequentialAnimationGroup::zeroDurationAnimation()
group.start(); group.start();
QCOMPARE(stateChangedSpy.count(), 2); QCOMPARE(stateChangedSpy.count(), 2);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
QAnimationGroup::Running); QAnimationGroup::Running);
QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()), QCOMPARE(qvariant_cast<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
QAnimationGroup::Stopped); QAnimationGroup::Stopped);
QCOMPARE(anim1->state(), 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; process = 0;
QCOMPARE(spy.count(), 3); QCOMPARE(spy.count(), 3);
QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting); QCOMPARE(qvariant_cast<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting);
QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(1).at(0)), QProcess::Running); QCOMPARE(qvariant_cast<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(2).at(0)), QProcess::NotRunning);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void tst_QProcess::execute() void tst_QProcess::execute()
@ -331,9 +331,9 @@ void tst_QProcess::crashTest()
process = 0; process = 0;
QCOMPARE(stateSpy.count(), 3); QCOMPARE(stateSpy.count(), 3);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting); QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(1).at(0)), QProcess::Running); QCOMPARE(qvariant_cast<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(2).at(0)), QProcess::NotRunning);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -1571,8 +1571,8 @@ void tst_QProcess::failToStart()
int it = j * attempts + i + 1; int it = j * attempts + i + 1;
QCOMPARE(stateSpy.count(), it * 2); QCOMPARE(stateSpy.count(), it * 2);
QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(it * 2 - 2).at(0)), QProcess::Starting); QCOMPARE(qvariant_cast<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 - 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) \ #define testVal(key, val, tp, rtype) \
{ \ { \
QSettings settings1(format, QSettings::UserScope, "software.org", "KillerAPP"); \ QSettings settings1(format, QSettings::UserScope, "software.org", "KillerAPP"); \
settings1.setValue(key, qVariantFromValue(val)); \ settings1.setValue(key, QVariant::fromValue(val)); \
} \ } \
QConfFile::clearCache(); \ QConfFile::clearCache(); \
{ \ { \
@ -1055,7 +1055,7 @@ void tst_QSettings::testVariantTypes()
QList<QVariant> l3; QList<QVariant> l3;
QDate date = QDate::currentDate(); QDate date = QDate::currentDate();
QTime time = QTime::currentTime(); 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; << QVariant(QSize(4, 56)) << QVariant(QPoint(4, 2)) << true << false << date << time;
testVal("key3", l3, QVariantList, List); 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 // General Purpose roles
QVariant variant = currentModel->data(currentModel->index(0,0), Qt::ToolTipRole); QVariant variant = currentModel->data(currentModel->index(0,0), Qt::ToolTipRole);
if (variant.isValid()) { if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QString>(variant)); QVERIFY(variant.canConvert<QString>());
} }
variant = currentModel->data(currentModel->index(0,0), Qt::StatusTipRole); variant = currentModel->data(currentModel->index(0,0), Qt::StatusTipRole);
if (variant.isValid()) { if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QString>(variant)); QVERIFY(variant.canConvert<QString>());
} }
variant = currentModel->data(currentModel->index(0,0), Qt::WhatsThisRole); variant = currentModel->data(currentModel->index(0,0), Qt::WhatsThisRole);
if (variant.isValid()) { if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QString>(variant)); QVERIFY(variant.canConvert<QString>());
} }
variant = currentModel->data(currentModel->index(0,0), Qt::SizeHintRole); variant = currentModel->data(currentModel->index(0,0), Qt::SizeHintRole);
if (variant.isValid()) { if (variant.isValid()) {
QVERIFY(qVariantCanConvert<QSize>(variant)); QVERIFY(variant.canConvert<QSize>());
} }
// Appearance roles // Appearance roles
QVariant fontVariant = currentModel->data(currentModel->index(0,0), Qt::FontRole); QVariant fontVariant = currentModel->data(currentModel->index(0,0), Qt::FontRole);
if (fontVariant.isValid()) { if (fontVariant.isValid()) {
QVERIFY(qVariantCanConvert<QFont>(fontVariant)); QVERIFY(fontVariant.canConvert<QFont>());
} }
QVariant textAlignmentVariant = currentModel->data(currentModel->index(0,0), Qt::TextAlignmentRole); 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); QVariant colorVariant = currentModel->data(currentModel->index(0,0), Qt::BackgroundColorRole);
if (colorVariant.isValid()) { if (colorVariant.isValid()) {
QVERIFY(qVariantCanConvert<QColor>(colorVariant)); QVERIFY(colorVariant.canConvert<QColor>());
} }
colorVariant = currentModel->data(currentModel->index(0,0), Qt::TextColorRole); colorVariant = currentModel->data(currentModel->index(0,0), Qt::TextColorRole);
if (colorVariant.isValid()) { if (colorVariant.isValid()) {
QVERIFY(qVariantCanConvert<QColor>(colorVariant)); QVERIFY(colorVariant.canConvert<QColor>());
} }
QVariant checkStateVariant = currentModel->data(currentModel->index(0,0), Qt::CheckStateRole); 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() void tst_QMetaType::namespaces()
{ {
TestSpace::Foo nf = { 11.12 }; TestSpace::Foo nf = { 11.12 };
QVariant v = qVariantFromValue(nf); QVariant v = QVariant::fromValue(nf);
QCOMPARE(qvariant_cast<TestSpace::Foo>(v).d, 11.12); 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; CustomType *customPointer = 0;
QVariant customVariant = object.property("custom"); QVariant customVariant = object.property("custom");
customPointer = qVariantValue<CustomType *>(customVariant); customPointer = qvariant_cast<CustomType *>(customVariant);
QCOMPARE(customPointer, object.custom()); QCOMPARE(customPointer, object.custom());
CustomType custom; CustomType custom;
customPointer = &custom; customPointer = &custom;
qVariantSetValue(customVariant, customPointer); customVariant.setValue(customPointer);
property = mo->property(mo->indexOfProperty("custom")); property = mo->property(mo->indexOfProperty("custom"));
QVERIFY(property.isWritable()); QVERIFY(property.isWritable());
@ -2068,7 +2068,7 @@ void tst_QObject::property()
QCOMPARE(object.custom(), customPointer); QCOMPARE(object.custom(), customPointer);
customVariant = object.property("custom"); customVariant = object.property("custom");
customPointer = qVariantValue<CustomType *>(customVariant); customPointer = qvariant_cast<CustomType *>(customVariant);
QCOMPARE(object.custom(), customPointer); QCOMPARE(object.custom(), customPointer);
// this enum property has a meta type, but it's not yet registered, so we know this fails // 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"); var = object.property("priority");
QVERIFY(!var.isNull()); QVERIFY(!var.isNull());
QVERIFY(qVariantCanConvert<PropertyObject::Priority>(var)); QVERIFY(var.canConvert<PropertyObject::Priority>());
QCOMPARE(qVariantValue<PropertyObject::Priority>(var), PropertyObject::High); QCOMPARE(qvariant_cast<PropertyObject::Priority>(var), PropertyObject::High);
object.setPriority(PropertyObject::Low); 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)); 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")); 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())); QVERIFY(!object.setProperty("priority", QVariant()));
var = object.property("priority"); var = object.property("priority");
QCOMPARE(qVariantValue<PropertyObject::Priority>(var), PropertyObject::High); QCOMPARE(qvariant_cast<PropertyObject::Priority>(var), PropertyObject::High);
object.setPriority(PropertyObject::Low); 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); 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"); qRegisterMetaType<CustomString>("CustomString");
QVERIFY(mo->indexOfProperty("customString") != -1); QVERIFY(mo->indexOfProperty("customString") != -1);
@ -3002,10 +3002,10 @@ void tst_QObject::floatProperty()
QVERIFY(prop.isValid()); QVERIFY(prop.isValid());
QVERIFY(prop.type() == uint(QMetaType::type("float"))); QVERIFY(prop.type() == uint(QMetaType::type("float")));
QVERIFY(!prop.write(&obj, QVariant("Hello"))); 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); QVariant v = prop.read(&obj);
QVERIFY(int(v.userType()) == QMetaType::Float); QVERIFY(int(v.userType()) == QMetaType::Float);
QVERIFY(qVariantValue<float>(v) == 128.0f); QVERIFY(qvariant_cast<float>(v) == 128.0f);
} }
void tst_QObject::qrealProperty() void tst_QObject::qrealProperty()
@ -3018,15 +3018,15 @@ void tst_QObject::qrealProperty()
QVERIFY(prop.type() == uint(QMetaType::type("qreal"))); QVERIFY(prop.type() == uint(QMetaType::type("qreal")));
QVERIFY(!prop.write(&obj, QVariant("Hello"))); 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); QVariant v = prop.read(&obj);
QCOMPARE(v.userType(), qMetaTypeId<qreal>()); 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); v = prop.read(&obj);
QCOMPARE(v.userType(), qMetaTypeId<qreal>()); QCOMPARE(v.userType(), qMetaTypeId<qreal>());
QVERIFY(qVariantValue<qreal>(v) == 127.0); QVERIFY(qvariant_cast<qreal>(v) == 127.0);
} }
class DynamicPropertyObject : public PropertyObject 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)); QVariant var(QBitArray(0));
QTest::newRow("BitArray") 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 << 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") 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 << 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") 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 << 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()); var = QVariant(QByteArray());
QTest::newRow("ByteArray") 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 << 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") 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; << 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 #ifndef QT_NO_CURSOR
var = qVariantFromValue(QCursor()); var = QVariant::fromValue(QCursor());
QTest::newRow("Cursor") 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; << 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 #endif
@ -541,13 +541,13 @@ void tst_QVariant::canConvert_data()
var = QVariant(0.1f); var = QVariant(0.1f);
QTest::newRow("Float") 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 << 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") 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 << 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") 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 << 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") 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 << 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); var = QVariant((int)1);
@ -556,7 +556,7 @@ void tst_QVariant::canConvert_data()
var = QVariant(); var = QVariant();
QTest::newRow("Invalid") 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 << 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") 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 << 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>()); var = QVariant(QList<QVariant>());
@ -568,16 +568,16 @@ void tst_QVariant::canConvert_data()
var = QVariant(QMap<QString,QVariant>()); var = QVariant(QMap<QString,QVariant>());
QTest::newRow("Map") 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 << 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") 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 << 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") 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 << 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") 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 << 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") 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 << 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()); var = QVariant(QPoint());
@ -586,13 +586,13 @@ void tst_QVariant::canConvert_data()
var = QVariant(QRect()); var = QVariant(QRect());
QTest::newRow("Rect") 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 << 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") 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 << 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()); var = QVariant(QSize());
QTest::newRow("Size") 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 << 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") 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 << 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()); var = QVariant(QString());
@ -713,7 +713,7 @@ void tst_QVariant::toInt_data()
QTest::newRow( "signedint-string" ) << QVariant( QString("-123") ) << -123 << true; QTest::newRow( "signedint-string" ) << QVariant( QString("-123") ) << -123 << true;
QTest::newRow( "signedlonglong0" ) << QVariant( (qlonglong)-34 ) << -34 << true; QTest::newRow( "signedlonglong0" ) << QVariant( (qlonglong)-34 ) << -34 << true;
QTest::newRow( "QChar" ) << QVariant(QChar('a')) << int('a') << 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, ' '); QByteArray bytearray(4, ' ');
bytearray[0] = 'T'; bytearray[0] = 'T';
bytearray[1] = 'e'; bytearray[1] = 'e';
@ -1020,7 +1020,7 @@ void tst_QVariant::toColor()
QFETCH( QColor, result ); QFETCH( QColor, result );
QVERIFY( value.isValid() ); QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Color ) ); QVERIFY( value.canConvert( QVariant::Color ) );
QColor d = qVariantValue<QColor>(value); QColor d = qvariant_cast<QColor>(value);
QCOMPARE( d, result ); QCOMPARE( d, result );
} }
@ -1044,7 +1044,7 @@ void tst_QVariant::toPixmap()
QFETCH( QPixmap, result ); QFETCH( QPixmap, result );
QVERIFY( value.isValid() ); QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Pixmap ) ); QVERIFY( value.canConvert( QVariant::Pixmap ) );
QPixmap d = qVariantValue<QPixmap>(value); QPixmap d = qvariant_cast<QPixmap>(value);
QCOMPARE( d, result ); QCOMPARE( d, result );
} }
@ -1064,7 +1064,7 @@ void tst_QVariant::toImage()
QFETCH( QImage, result ); QFETCH( QImage, result );
QVERIFY( value.isValid() ); QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Image ) ); QVERIFY( value.canConvert( QVariant::Image ) );
QImage d = qVariantValue<QImage>(value); QImage d = qvariant_cast<QImage>(value);
QCOMPARE( d, result ); QCOMPARE( d, result );
} }
@ -1086,7 +1086,7 @@ void tst_QVariant::toBrush()
QFETCH( QBrush, result ); QFETCH( QBrush, result );
QVERIFY( value.isValid() ); QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Brush ) ); QVERIFY( value.canConvert( QVariant::Brush ) );
QBrush d = qVariantValue<QBrush>(value); QBrush d = qvariant_cast<QBrush>(value);
QCOMPARE( d, result ); QCOMPARE( d, result );
} }
@ -1105,7 +1105,7 @@ void tst_QVariant::toFont()
QFETCH( QFont, result ); QFETCH( QFont, result );
QVERIFY( value.isValid() ); QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Font ) ); QVERIFY( value.canConvert( QVariant::Font ) );
QFont d = qVariantValue<QFont>(value); QFont d = qvariant_cast<QFont>(value);
QCOMPARE( d, result ); QCOMPARE( d, result );
} }
@ -1129,7 +1129,7 @@ void tst_QVariant::toKeySequence()
QFETCH( QKeySequence, result ); QFETCH( QKeySequence, result );
QVERIFY( value.isValid() ); QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::KeySequence ) ); QVERIFY( value.canConvert( QVariant::KeySequence ) );
QKeySequence d = qVariantValue<QKeySequence>(value); QKeySequence d = qvariant_cast<QKeySequence>(value);
QCOMPARE( d, result ); 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( "qdate" ) << QVariant( QDate( 2002, 1, 1 ) ) << QString( "2002-01-01" );
QTest::newRow( "qtime" ) << QVariant( QTime( 12, 34, 56 ) ) << QString( "12:34:56" ); 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( "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 #ifndef Q_OS_MAC
<< QString( "Ctrl+A" ); << QString( "Ctrl+A" );
#else #else
@ -1299,8 +1299,8 @@ void tst_QVariant::toString_data()
#endif #endif
QFont font( "times", 12 ); QFont font( "times", 12 );
QTest::newRow( "qfont" ) << qVariantFromValue( font ) << QString("times,12,-1,5,50,0,0,0,0,0"); QTest::newRow( "qfont" ) << QVariant::fromValue( font ) << QString("times,12,-1,5,50,0,0,0,0,0");
QTest::newRow( "qcolor" ) << qVariantFromValue( QColor( 10, 10, 10 ) ) << QString( "#0a0a0a" ); QTest::newRow( "qcolor" ) << QVariant::fromValue( QColor( 10, 10, 10 ) ) << QString( "#0a0a0a" );
QTest::newRow( "llong" ) << QVariant( (qlonglong)Q_INT64_C(123456789012) ) << QTest::newRow( "llong" ) << QVariant( (qlonglong)Q_INT64_C(123456789012) ) <<
QString( "123456789012" ); QString( "123456789012" );
} }
@ -1407,10 +1407,10 @@ void tst_QVariant::toRegularExpression()
void tst_QVariant::matrix() void tst_QVariant::matrix()
{ {
QVariant variant; QVariant variant;
QMatrix matrix = qVariantValue<QMatrix>(variant); QMatrix matrix = qvariant_cast<QMatrix>(variant);
QVERIFY(matrix.isIdentity()); QVERIFY(matrix.isIdentity());
qVariantSetValue(variant, QMatrix().rotate(90)); variant.setValue(QMatrix().rotate(90));
QCOMPARE(QMatrix().rotate(90), qVariantValue<QMatrix>(variant)); QCOMPARE(QMatrix().rotate(90), qvariant_cast<QMatrix>(variant));
void *mmatrix = QMetaType::create(QVariant::Matrix, 0); void *mmatrix = QMetaType::create(QVariant::Matrix, 0);
QVERIFY(mmatrix); QVERIFY(mmatrix);
@ -1420,12 +1420,12 @@ void tst_QVariant::matrix()
void tst_QVariant::matrix4x4() void tst_QVariant::matrix4x4()
{ {
QVariant variant; QVariant variant;
QMatrix4x4 matrix = qVariantValue<QMatrix4x4>(variant); QMatrix4x4 matrix = qvariant_cast<QMatrix4x4>(variant);
QVERIFY(matrix.isIdentity()); QVERIFY(matrix.isIdentity());
QMatrix4x4 m; QMatrix4x4 m;
m.scale(2.0f); m.scale(2.0f);
qVariantSetValue(variant, m); variant.setValue(m);
QCOMPARE(m, qVariantValue<QMatrix4x4>(variant)); QCOMPARE(m, qvariant_cast<QMatrix4x4>(variant));
void *mmatrix = QMetaType::create(QVariant::Matrix4x4, 0); void *mmatrix = QMetaType::create(QVariant::Matrix4x4, 0);
QVERIFY(mmatrix); QVERIFY(mmatrix);
@ -1435,10 +1435,10 @@ void tst_QVariant::matrix4x4()
void tst_QVariant::transform() void tst_QVariant::transform()
{ {
QVariant variant; QVariant variant;
QTransform matrix = qVariantValue<QTransform>(variant); QTransform matrix = qvariant_cast<QTransform>(variant);
QVERIFY(matrix.isIdentity()); QVERIFY(matrix.isIdentity());
qVariantSetValue(variant, QTransform().rotate(90)); variant.setValue(QTransform().rotate(90));
QCOMPARE(QTransform().rotate(90), qVariantValue<QTransform>(variant)); QCOMPARE(QTransform().rotate(90), qvariant_cast<QTransform>(variant));
void *mmatrix = QMetaType::create(QVariant::Transform, 0); void *mmatrix = QMetaType::create(QVariant::Transform, 0);
QVERIFY(mmatrix); QVERIFY(mmatrix);
@ -1449,10 +1449,10 @@ void tst_QVariant::transform()
void tst_QVariant::vector2D() void tst_QVariant::vector2D()
{ {
QVariant variant; QVariant variant;
QVector2D vector = qVariantValue<QVector2D>(variant); QVector2D vector = qvariant_cast<QVector2D>(variant);
QVERIFY(vector.isNull()); QVERIFY(vector.isNull());
qVariantSetValue(variant, QVector2D(0.1, 0.2)); variant.setValue(QVector2D(0.1, 0.2));
QCOMPARE(QVector2D(0.1, 0.2), qVariantValue<QVector2D>(variant)); QCOMPARE(QVector2D(0.1, 0.2), qvariant_cast<QVector2D>(variant));
void *pvector = QMetaType::create(QVariant::Vector2D, 0); void *pvector = QMetaType::create(QVariant::Vector2D, 0);
QVERIFY(pvector); QVERIFY(pvector);
@ -1462,10 +1462,10 @@ void tst_QVariant::vector2D()
void tst_QVariant::vector3D() void tst_QVariant::vector3D()
{ {
QVariant variant; QVariant variant;
QVector3D vector = qVariantValue<QVector3D>(variant); QVector3D vector = qvariant_cast<QVector3D>(variant);
QVERIFY(vector.isNull()); QVERIFY(vector.isNull());
qVariantSetValue(variant, QVector3D(0.1, 0.2, 0.3)); variant.setValue(QVector3D(0.1, 0.2, 0.3));
QCOMPARE(QVector3D(0.1, 0.2, 0.3), qVariantValue<QVector3D>(variant)); QCOMPARE(QVector3D(0.1, 0.2, 0.3), qvariant_cast<QVector3D>(variant));
void *pvector = QMetaType::create(QVariant::Vector3D, 0); void *pvector = QMetaType::create(QVariant::Vector3D, 0);
QVERIFY(pvector); QVERIFY(pvector);
@ -1475,10 +1475,10 @@ void tst_QVariant::vector3D()
void tst_QVariant::vector4D() void tst_QVariant::vector4D()
{ {
QVariant variant; QVariant variant;
QVector4D vector = qVariantValue<QVector4D>(variant); QVector4D vector = qvariant_cast<QVector4D>(variant);
QVERIFY(vector.isNull()); QVERIFY(vector.isNull());
qVariantSetValue(variant, QVector4D(0.1, 0.2, 0.3, 0.4)); variant.setValue(QVector4D(0.1, 0.2, 0.3, 0.4));
QCOMPARE(QVector4D(0.1, 0.2, 0.3, 0.4), qVariantValue<QVector4D>(variant)); QCOMPARE(QVector4D(0.1, 0.2, 0.3, 0.4), qvariant_cast<QVector4D>(variant));
void *pvector = QMetaType::create(QVariant::Vector4D, 0); void *pvector = QMetaType::create(QVariant::Vector4D, 0);
QVERIFY(pvector); QVERIFY(pvector);
@ -1488,10 +1488,10 @@ void tst_QVariant::vector4D()
void tst_QVariant::quaternion() void tst_QVariant::quaternion()
{ {
QVariant variant; QVariant variant;
QQuaternion quaternion = qVariantValue<QQuaternion>(variant); QQuaternion quaternion = qvariant_cast<QQuaternion>(variant);
QVERIFY(quaternion.isIdentity()); QVERIFY(quaternion.isIdentity());
qVariantSetValue(variant, QQuaternion(0.1, 0.2, 0.3, 0.4)); variant.setValue(QQuaternion(0.1, 0.2, 0.3, 0.4));
QCOMPARE(QQuaternion(0.1, 0.2, 0.3, 0.4), qVariantValue<QQuaternion>(variant)); QCOMPARE(QQuaternion(0.1, 0.2, 0.3, 0.4), qvariant_cast<QQuaternion>(variant));
void *pquaternion = QMetaType::create(QVariant::Quaternion, 0); void *pquaternion = QMetaType::create(QVariant::Quaternion, 0);
QVERIFY(pquaternion); QVERIFY(pquaternion);
@ -1548,14 +1548,14 @@ void tst_QVariant::writeToReadFromDataStream_data()
bytearray[3] = 't'; bytearray[3] = 't';
bytearray[4] = '\0'; bytearray[4] = '\0';
QTest::newRow( "bytearray_valid" ) << QVariant( bytearray ) << false; 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 ); QBitmap bitmap( 10, 10 );
bitmap.fill( Qt::red ); bitmap.fill( Qt::red );
QTest::newRow( "bitmap_valid" ) << qVariantFromValue( bitmap ) << false; QTest::newRow( "bitmap_valid" ) << QVariant::fromValue( bitmap ) << false;
QTest::newRow( "brush_valid" ) << qVariantFromValue( QBrush( Qt::red ) ) << false; QTest::newRow( "brush_valid" ) << QVariant::fromValue( QBrush( Qt::red ) ) << false;
QTest::newRow( "color_valid" ) << qVariantFromValue( QColor( Qt::red ) ) << false; QTest::newRow( "color_valid" ) << QVariant::fromValue( QColor( Qt::red ) ) << false;
#ifndef QT_NO_CURSOR #ifndef QT_NO_CURSOR
QTest::newRow( "cursor_valid" ) << qVariantFromValue( QCursor( Qt::PointingHandCursor ) ) << false; QTest::newRow( "cursor_valid" ) << QVariant::fromValue( QCursor( Qt::PointingHandCursor ) ) << false;
#endif #endif
QTest::newRow( "date_invalid" ) << QVariant( QDate() ) << true; QTest::newRow( "date_invalid" ) << QVariant( QDate() ) << true;
QTest::newRow( "date_valid" ) << QVariant( QDate( 2002, 07, 06 ) ) << false; 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( "datetime_valid" ) << QVariant( QDateTime( QDate( 2002, 07, 06 ), QTime( 14, 0, 0 ) ) ) << false;
QTest::newRow( "double_valid" ) << QVariant( 123.456 ) << false; QTest::newRow( "double_valid" ) << QVariant( 123.456 ) << false;
QTest::newRow( "float_valid" ) << QVariant( 123.456f ) << false; QTest::newRow( "float_valid" ) << QVariant( 123.456f ) << false;
QTest::newRow( "font_valid" ) << qVariantFromValue( QFont( "times", 12 ) ) << false; QTest::newRow( "font_valid" ) << QVariant::fromValue( QFont( "times", 12 ) ) << false;
QTest::newRow( "pixmap_invalid" ) << qVariantFromValue( QPixmap() ) << true; QTest::newRow( "pixmap_invalid" ) << QVariant::fromValue( QPixmap() ) << true;
QPixmap pixmap( 10, 10 ); QPixmap pixmap( 10, 10 );
pixmap.fill( Qt::red ); 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( "iconset_valid" ) << QVariant( QIcon( pixmap ) ) << false;
QTest::newRow( "image_invalid" ) << qVariantFromValue( QImage() ) << true; QTest::newRow( "image_invalid" ) << QVariant::fromValue( QImage() ) << true;
QTest::newRow( "keysequence_valid" ) << qVariantFromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) ) << false; QTest::newRow( "keysequence_valid" ) << QVariant::fromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) ) << false;
QTest::newRow( "int_valid" ) << QVariant( -123 ) << false; QTest::newRow( "int_valid" ) << QVariant( -123 ) << false;
typedef QMap<QString, QVariant> variantsMap; typedef QMap<QString, QVariant> variantsMap;
variantsMap vMap; variantsMap vMap;
@ -1579,15 +1579,15 @@ void tst_QVariant::writeToReadFromDataStream_data()
vMap.insert( "double", QVariant( 3.45 ) ); vMap.insert( "double", QVariant( 3.45 ) );
vMap.insert( "float", QVariant( 3.45f ) ); vMap.insert( "float", QVariant( 3.45f ) );
QTest::newRow( "map_valid" ) << QVariant( vMap ) << false; QTest::newRow( "map_valid" ) << QVariant( vMap ) << false;
QTest::newRow( "palette_valid" ) << qVariantFromValue(QPalette(QColor("turquoise"))) << false; QTest::newRow( "palette_valid" ) << QVariant::fromValue(QPalette(QColor("turquoise"))) << false;
QTest::newRow( "pen_valid" ) << qVariantFromValue( QPen( Qt::red ) ) << false; QTest::newRow( "pen_valid" ) << QVariant::fromValue( QPen( Qt::red ) ) << false;
QTest::newRow( "pointarray_invalid" ) << qVariantFromValue( QPolygon() ) << true; QTest::newRow( "pointarray_invalid" ) << QVariant::fromValue( QPolygon() ) << true;
QTest::newRow( "pointarray_valid" ) << qVariantFromValue( QPolygon( QRect( 10, 10, 20, 20 ) ) ) << false; QTest::newRow( "pointarray_valid" ) << QVariant::fromValue( QPolygon( QRect( 10, 10, 20, 20 ) ) ) << false;
QTest::newRow( "region_invalid" ) << qVariantFromValue( QRegion() ) << true; QTest::newRow( "region_invalid" ) << QVariant::fromValue( QRegion() ) << true;
QTest::newRow( "region_valid" ) << qVariantFromValue( QRegion( 10, 10, 20, 20 ) ) << false; QTest::newRow( "region_valid" ) << QVariant::fromValue( QRegion( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "sizepolicy_valid" ) << qVariantFromValue( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ) << false; QTest::newRow( "sizepolicy_valid" ) << QVariant::fromValue( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ) << false;
QTest::newRow( "point_invalid" ) << qVariantFromValue( QPoint() ) << true; QTest::newRow( "point_invalid" ) << QVariant::fromValue( QPoint() ) << true;
QTest::newRow( "point_valid" ) << qVariantFromValue( QPoint( 10, 10 ) ) << false; QTest::newRow( "point_valid" ) << QVariant::fromValue( QPoint( 10, 10 ) ) << false;
QTest::newRow( "rect_invalid" ) << QVariant( QRect() ) << true; QTest::newRow( "rect_invalid" ) << QVariant( QRect() ) << true;
QTest::newRow( "rect_valid" ) << QVariant( QRect( 10, 10, 20, 20 ) ) << false; QTest::newRow( "rect_valid" ) << QVariant( QRect( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "size_invalid" ) << QVariant( QSize( 0, 0 ) ) << true; QTest::newRow( "size_invalid" ) << QVariant( QSize( 0, 0 ) ) << true;
@ -2132,7 +2132,7 @@ void tst_QVariant::userType()
{ {
QVariant userVar; QVariant userVar;
qVariantSetValue(userVar, data); userVar.setValue(data);
QCOMPARE(userVar.type(), QVariant::UserType); QCOMPARE(userVar.type(), QVariant::UserType);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType>()); QCOMPARE(userVar.userType(), qMetaTypeId<MyType>());
@ -2143,7 +2143,7 @@ void tst_QVariant::userType()
QVariant userVar2(userVar); QVariant userVar2(userVar);
QVERIFY(userVar == userVar2); QVERIFY(userVar == userVar2);
qVariantSetValue(userVar2, data2); userVar2.setValue(data2);
QVERIFY(userVar != userVar2); QVERIFY(userVar != userVar2);
const MyType *varData = static_cast<const MyType *>(userVar.constData()); const MyType *varData = static_cast<const MyType *>(userVar.constData());
@ -2152,7 +2152,7 @@ void tst_QVariant::userType()
QCOMPARE(varData->text, data.text); QCOMPARE(varData->text, data.text);
QVariant userVar3; QVariant userVar3;
qVariantSetValue(userVar3, data2); userVar3.setValue(data2);
userVar3 = userVar2; userVar3 = userVar2;
QVERIFY(userVar2 == userVar3); QVERIFY(userVar2 == userVar3);
@ -2161,7 +2161,7 @@ void tst_QVariant::userType()
QCOMPARE(instanceCount, 2); QCOMPARE(instanceCount, 2);
{ {
QVariant userVar; QVariant userVar;
qVariantSetValue(userVar, &data); userVar.setValue(&data);
QCOMPARE(userVar.type(), QVariant::UserType); QCOMPARE(userVar.type(), QVariant::UserType);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType*>()); QCOMPARE(userVar.userType(), qMetaTypeId<MyType*>());
@ -2172,7 +2172,7 @@ void tst_QVariant::userType()
QVariant userVar2(userVar); QVariant userVar2(userVar);
QVERIFY(userVar == userVar2); QVERIFY(userVar == userVar2);
qVariantSetValue(userVar2, &data2); userVar2.setValue(&data2);
QVERIFY(userVar != userVar2); QVERIFY(userVar != userVar2);
MyType * const*varData = reinterpret_cast<MyType *const *>(userVar.constData()); MyType * const*varData = reinterpret_cast<MyType *const *>(userVar.constData());
@ -2180,7 +2180,7 @@ void tst_QVariant::userType()
QCOMPARE(*varData, &data); QCOMPARE(*varData, &data);
QVariant userVar3; QVariant userVar3;
qVariantSetValue(userVar3, &data2); userVar3.setValue(&data2);
/* This check is correct now. userVar2 contains a pointer to data2 and so /* This check is correct now. userVar2 contains a pointer to data2 and so
* does userVar3. */ * does userVar3. */
@ -2192,7 +2192,7 @@ void tst_QVariant::userType()
QCOMPARE(instanceCount, 2); QCOMPARE(instanceCount, 2);
QVariant myCarrier; QVariant myCarrier;
qVariantSetValue(myCarrier, data); myCarrier.setValue(data);
QCOMPARE(instanceCount, 3); QCOMPARE(instanceCount, 3);
{ {
QVariant second = myCarrier; QVariant second = myCarrier;
@ -2203,7 +2203,7 @@ void tst_QVariant::userType()
QCOMPARE(instanceCount, 3); QCOMPARE(instanceCount, 3);
MyType data3(0, "null"); MyType data3(0, "null");
data3 = qVariantValue<MyType>(myCarrier); data3 = qvariant_cast<MyType>(myCarrier);
QCOMPARE(data3.number, 1); QCOMPARE(data3.number, 1);
QCOMPARE(data3.text, (const char *)"eins"); QCOMPARE(data3.text, (const char *)"eins");
#ifndef Q_CC_SUN #ifndef Q_CC_SUN
@ -2216,7 +2216,7 @@ void tst_QVariant::userType()
const MyType data(3, "drei"); const MyType data(3, "drei");
QVariant myCarrier; QVariant myCarrier;
qVariantSetValue(myCarrier, data); myCarrier.setValue(data);
QCOMPARE(myCarrier.typeName(), "MyType"); QCOMPARE(myCarrier.typeName(), "MyType");
const MyType data2 = qvariant_cast<MyType>(myCarrier); const MyType data2 = qvariant_cast<MyType>(myCarrier);
@ -2228,7 +2228,7 @@ void tst_QVariant::userType()
short s = 42; short s = 42;
QVariant myCarrier; QVariant myCarrier;
qVariantSetValue(myCarrier, s); myCarrier.setValue(s);
QCOMPARE((int)qvariant_cast<short>(myCarrier), 42); QCOMPARE((int)qvariant_cast<short>(myCarrier), 42);
} }
@ -2236,7 +2236,7 @@ void tst_QVariant::userType()
qlonglong ll = Q_INT64_C(42); qlonglong ll = Q_INT64_C(42);
QVariant myCarrier; QVariant myCarrier;
qVariantSetValue(myCarrier, ll); myCarrier.setValue(ll);
QCOMPARE(qvariant_cast<int>(myCarrier), 42); QCOMPARE(qvariant_cast<int>(myCarrier), 42);
} }
@ -2257,14 +2257,14 @@ void tst_QVariant::podUserType()
pod.a = 10; pod.a = 10;
pod.b = 20; pod.b = 20;
QVariant pod_as_variant = qVariantFromValue(pod); QVariant pod_as_variant = QVariant::fromValue(pod);
MyTypePOD pod2 = qvariant_cast<MyTypePOD>(pod_as_variant); MyTypePOD pod2 = qvariant_cast<MyTypePOD>(pod_as_variant);
QCOMPARE(pod.a, pod2.a); QCOMPARE(pod.a, pod2.a);
QCOMPARE(pod.b, pod2.b); QCOMPARE(pod.b, pod2.b);
qVariantSetValue(pod_as_variant, pod); pod_as_variant.setValue(pod);
pod2 = qVariantValue<MyTypePOD>(pod_as_variant); pod2 = qvariant_cast<MyTypePOD>(pod_as_variant);
QCOMPARE(pod.a, pod2.a); QCOMPARE(pod.a, pod2.a);
QCOMPARE(pod.b, pod2.b); QCOMPARE(pod.b, pod2.b);
@ -2331,7 +2331,7 @@ void tst_QVariant::data()
v = f; v = f;
QVERIFY(v.data()); QVERIFY(v.data());
QCOMPARE(*static_cast<float *>(v.data()), qVariantValue<float>(v)); QCOMPARE(*static_cast<float *>(v.data()), qvariant_cast<float>(v));
v = ll; v = ll;
QVERIFY(v.data()); QVERIFY(v.data());
@ -2410,12 +2410,12 @@ void tst_QVariant::variant_to()
QStringList sl; QStringList sl;
sl << QLatin1String("blah"); sl << QLatin1String("blah");
qVariantSetValue(v3, sl); v3.setValue(sl);
Foo foo; Foo foo;
foo.i = 42; foo.i = 42;
qVariantSetValue(v4, foo); v4.setValue(foo);
QCOMPARE(qvariant_cast<double>(v1), 4.2); QCOMPARE(qvariant_cast<double>(v1), 4.2);
QCOMPARE(qvariant_cast<float>(v1), 4.2f); QCOMPARE(qvariant_cast<float>(v1), 4.2f);
@ -2430,7 +2430,7 @@ void tst_QVariant::variant_to()
QCOMPARE(qvariant_cast<int>(v1), 4); 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<int>(n), 42);
QCOMPARE(qvariant_cast<uint>(n), 42u); QCOMPARE(qvariant_cast<uint>(n), 42u);
QCOMPARE(qvariant_cast<double>(n), 42.0); 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<short>(n), short(42));
QCOMPARE(qvariant_cast<ushort>(n), ushort(42)); QCOMPARE(qvariant_cast<ushort>(n), ushort(42));
n = qVariantFromValue(43l); n = QVariant::fromValue(43l);
QCOMPARE(qvariant_cast<int>(n), 43); QCOMPARE(qvariant_cast<int>(n), 43);
QCOMPARE(qvariant_cast<uint>(n), 43u); QCOMPARE(qvariant_cast<uint>(n), 43u);
QCOMPARE(qvariant_cast<double>(n), 43.0); 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<ulong>(n), 44ul);
QCOMPARE(qvariant_cast<float>(n), 44.0f); 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; }; struct Blah { int i; };
@ -2502,10 +2502,10 @@ void tst_QVariant::url()
QVariant v3(str); //built with a QString QVariant v3(str); //built with a QString
QCOMPARE(v2.toUrl(), url); QCOMPARE(v2.toUrl(), url);
QVERIFY(qVariantCanConvert<QUrl>(v3)); QVERIFY(v3.canConvert<QUrl>());
QCOMPARE(v2.toUrl(), v3.toUrl()); QCOMPARE(v2.toUrl(), v3.toUrl());
QVERIFY(qVariantCanConvert<QString>(v2)); QVERIFY(v2.canConvert<QString>());
QCOMPARE(v2.toString(), str); QCOMPARE(v2.toString(), str);
QCOMPARE(v3.toString(), str); QCOMPARE(v3.toString(), str);
} }
@ -2514,7 +2514,7 @@ void tst_QVariant::globalColor()
{ {
QVariant variant(Qt::blue); QVariant variant(Qt::blue);
QVERIFY(variant.type() == QVariant::Color); QVERIFY(variant.type() == QVariant::Color);
QVERIFY(qVariantValue<QColor>(variant) == QColor(Qt::blue)); QVERIFY(qvariant_cast<QColor>(variant) == QColor(Qt::blue));
} }
void tst_QVariant::variantMap() void tst_QVariant::variantMap()
@ -2687,7 +2687,7 @@ void tst_QVariant::convertToQUint8() const
* It's of type QVariant::Int. */ * It's of type QVariant::Int. */
const QVariant v0 = anInt; const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<qint8>(v0)); QVERIFY(v0.canConvert<qint8>());
QCOMPARE(int(qvariant_cast<qint8>(v0)), 32); QCOMPARE(int(qvariant_cast<qint8>(v0)), 32);
QCOMPARE(int(v0.toInt()), 32); QCOMPARE(int(v0.toInt()), 32);
QCOMPARE(v0.toString(), QString("32")); QCOMPARE(v0.toString(), QString("32"));
@ -2705,7 +2705,7 @@ void tst_QVariant::convertToQUint8() const
const quint8 anInt = 32; const quint8 anInt = 32;
const QVariant v0 = anInt; const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<quint8>(v0)); QVERIFY(v0.canConvert<quint8>());
QCOMPARE(int(qvariant_cast<quint8>(v0)), 32); QCOMPARE(int(qvariant_cast<quint8>(v0)), 32);
QCOMPARE(int(v0.toUInt()), 32); QCOMPARE(int(v0.toUInt()), 32);
QCOMPARE(v0.toString(), QString("32")); QCOMPARE(v0.toString(), QString("32"));
@ -2716,7 +2716,7 @@ void tst_QVariant::convertToQUint8() const
const qint16 anInt = 32; const qint16 anInt = 32;
const QVariant v0 = anInt; const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<qint16>(v0)); QVERIFY(v0.canConvert<qint16>());
QCOMPARE(int(qvariant_cast<qint16>(v0)), 32); QCOMPARE(int(qvariant_cast<qint16>(v0)), 32);
QCOMPARE(int(v0.toInt()), 32); QCOMPARE(int(v0.toInt()), 32);
QCOMPARE(v0.toString(), QString("32")); QCOMPARE(v0.toString(), QString("32"));
@ -2727,7 +2727,7 @@ void tst_QVariant::convertToQUint8() const
const quint16 anInt = 32; const quint16 anInt = 32;
const QVariant v0 = anInt; const QVariant v0 = anInt;
QVERIFY(qVariantCanConvert<quint16>(v0)); QVERIFY(v0.canConvert<quint16>());
QCOMPARE(int(qvariant_cast<quint16>(v0)), 32); QCOMPARE(int(qvariant_cast<quint16>(v0)), 32);
QCOMPARE(int(v0.toUInt()), 32); QCOMPARE(int(v0.toUInt()), 32);
QCOMPARE(v0.toString(), QString("32")); QCOMPARE(v0.toString(), QString("32"));
@ -2742,8 +2742,8 @@ void tst_QVariant::comparePointers() const
MyClass myClass; MyClass myClass;
QVariant v = qVariantFromValue<void *>(&myClass); QVariant v = QVariant::fromValue<void *>(&myClass);
QVariant v2 = qVariantFromValue<void *>(&myClass); QVariant v2 = QVariant::fromValue<void *>(&myClass);
QCOMPARE(v, v2); QCOMPARE(v, v2);
} }
@ -2758,15 +2758,15 @@ void tst_QVariant::voidStar() const
void *p2 = p1; void *p2 = p1;
QVariant v1, v2; QVariant v1, v2;
v1 = qVariantFromValue(p1); v1 = QVariant::fromValue(p1);
v2 = v1; v2 = v1;
QVERIFY(v1 == v2); QVERIFY(v1 == v2);
v2 = qVariantFromValue(p2); v2 = QVariant::fromValue(p2);
QVERIFY(v1 == v2); QVERIFY(v1 == v2);
p2 = 0; p2 = 0;
v2 = qVariantFromValue(p2); v2 = QVariant::fromValue(p2);
QVERIFY(v1 != v2); QVERIFY(v1 != v2);
} }
@ -2775,14 +2775,14 @@ void tst_QVariant::dataStar() const
qRegisterMetaType<Data*>(); qRegisterMetaType<Data*>();
Data *p1 = new Data; Data *p1 = new Data;
QVariant v1 = qVariantFromValue(p1); QVariant v1 = QVariant::fromValue(p1);
QCOMPARE(v1.userType(), qMetaTypeId<Data*>()); QCOMPARE(v1.userType(), qMetaTypeId<Data*>());
QCOMPARE(qvariant_cast<Data*>(v1), p1); QCOMPARE(qvariant_cast<Data*>(v1), p1);
QVariant v2 = v1; QVariant v2 = v1;
QVERIFY(v1 == v2); QVERIFY(v1 == v2);
v2 = qVariantFromValue(p1); v2 = QVariant::fromValue(p1);
QVERIFY(v1 == v2); QVERIFY(v1 == v2);
delete p1; delete p1;
} }
@ -2820,10 +2820,10 @@ void tst_QVariant::canConvertQStringList_data() const
template<typename T> void convertMetaType() template<typename T> void convertMetaType()
{ {
QVERIFY(qVariantFromValue<T>(10).isValid()); QVERIFY(QVariant::fromValue<T>(10).isValid());
QVERIFY(qVariantFromValue<T>(10).canConvert(QVariant::Int)); QVERIFY(QVariant::fromValue<T>(10).canConvert(QVariant::Int));
QCOMPARE(qVariantFromValue<T>(10).toInt(), 10); QCOMPARE(QVariant::fromValue<T>(10).toInt(), 10);
QCOMPARE(qVariantFromValue<T>(10), qVariantFromValue<T>(10)); QCOMPARE(QVariant::fromValue<T>(10), QVariant::fromValue<T>(10));
} }
#define CONVERT_META_TYPE(Type) \ #define CONVERT_META_TYPE(Type) \
@ -2947,11 +2947,11 @@ void tst_QVariant::compareCustomTypes() const
WontCompare f1; WontCompare f1;
f1.x = 0; f1.x = 0;
const QVariant variant1(qVariantFromValue(f1)); const QVariant variant1(QVariant::fromValue(f1));
WontCompare f2; WontCompare f2;
f2.x = 0; f2.x = 0;
const QVariant variant2(qVariantFromValue(f2)); const QVariant variant2(QVariant::fromValue(f2));
/* We compare pointers. */ /* We compare pointers. */
QVERIFY(variant1 != variant2); QVERIFY(variant1 != variant2);
@ -2973,10 +2973,10 @@ void tst_QVariant::copyingUserTypes() const
QVariant var; QVariant var;
QVariant var3; QVariant var3;
const QHostAddress ha("127.0.0.1"); const QHostAddress ha("127.0.0.1");
qVariantSetValue(var, ha); var.setValue(ha);
var3 = var; var3 = var;
QCOMPARE(qVariantValue<QHostAddress>(var3), ha); QCOMPARE(qvariant_cast<QHostAddress>(var3), ha);
} }
void tst_QVariant::convertBoolToByteArray() const void tst_QVariant::convertBoolToByteArray() const
@ -2987,7 +2987,7 @@ void tst_QVariant::convertBoolToByteArray() const
const QVariant variant(input); const QVariant variant(input);
QCOMPARE(qVariantCanConvert<bool>(variant), canConvert); QCOMPARE(variant.canConvert<bool>(), canConvert);
if(canConvert) { if(canConvert) {
/* Just call this function so we run the code path. */ /* Just call this function so we run the code path. */
@ -3055,7 +3055,7 @@ void tst_QVariant::convertByteArrayToBool() const
const QVariant variant(input); const QVariant variant(input);
QCOMPARE(variant.type(), QVariant::Bool); QCOMPARE(variant.type(), QVariant::Bool);
QCOMPARE(variant.toBool(), input); QCOMPARE(variant.toBool(), input);
QVERIFY(qVariantCanConvert<bool>(variant)); QVERIFY(variant.canConvert<bool>());
QCOMPARE(variant.toByteArray(), output); QCOMPARE(variant.toByteArray(), output);
} }
@ -3130,7 +3130,7 @@ void tst_QVariant::setValue()
QVERIFY( !v1.isDetached() ); QVERIFY( !v1.isDetached() );
QVERIFY( !v2.isDetached() ); QVERIFY( !v2.isDetached() );
qVariantSetValue(v2, 3); //set an integer value v2.setValue(3); //set an integer value
QVERIFY( v1.isDetached() ); QVERIFY( v1.isDetached() );
QVERIFY( v2.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(qvariant_cast<T>(v2), qvariant_cast<T>(v));
QCOMPARE(v2.toString(), toString); QCOMPARE(v2.toString(), toString);
v3 = qVariantFromValue(orig); v3 = QVariant::fromValue(orig);
QVERIFY(v3.isValid()); QVERIFY(v3.isValid());
QCOMPARE(v3.isNull(), isNull); 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); 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.type(), QEasingCurve::InOutBack);
QCOMPARE(easing.overshoot(), overshoot); QCOMPARE(easing.overshoot(), overshoot);
QCOMPARE(easing.amplitude(), amplitude); QCOMPARE(easing.amplitude(), amplitude);
@ -538,9 +538,9 @@ void tst_QEasingCurve::properties()
period = linear.period(); period = linear.period();
obj.setProperty("easing", 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.type(), QEasingCurve::Linear);
QCOMPARE(easing.overshoot(), overshoot); QCOMPARE(easing.overshoot(), overshoot);
QCOMPARE(easing.amplitude(), amplitude); QCOMPARE(easing.amplitude(), amplitude);

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

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

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

@ -81,19 +81,19 @@ public:
inline RegisteredType complexProp() const inline RegisteredType complexProp() const
{ return qvariant_cast< RegisteredType >(property("complexProp")); } { return qvariant_cast< RegisteredType >(property("complexProp")); }
inline void setComplexProp(RegisteredType value) inline void setComplexProp(RegisteredType value)
{ setProperty("complexProp", qVariantFromValue(value)); } { setProperty("complexProp", QVariant::fromValue(value)); }
Q_PROPERTY(QString stringProp READ stringProp WRITE setStringProp) Q_PROPERTY(QString stringProp READ stringProp WRITE setStringProp)
inline QString stringProp() const inline QString stringProp() const
{ return qvariant_cast< QString >(property("stringProp")); } { return qvariant_cast< QString >(property("stringProp")); }
inline void setStringProp(const QString &value) inline void setStringProp(const QString &value)
{ setProperty("stringProp", qVariantFromValue(value)); } { setProperty("stringProp", QVariant::fromValue(value)); }
Q_PROPERTY(QDBusVariant variantProp READ variantProp WRITE setVariantProp) Q_PROPERTY(QDBusVariant variantProp READ variantProp WRITE setVariantProp)
inline QDBusVariant variantProp() const inline QDBusVariant variantProp() const
{ return qvariant_cast< QDBusVariant >(property("variantProp")); } { return qvariant_cast< QDBusVariant >(property("variantProp")); }
inline void setVariantProp(const QDBusVariant &value) inline void setVariantProp(const QDBusVariant &value)
{ setProperty("variantProp", qVariantFromValue(value)); } { setProperty("variantProp", QVariant::fromValue(value)); }
public Q_SLOTS: // METHODS public Q_SLOTS: // METHODS
inline QDBusPendingReply<RegisteredType> complexMethod() inline QDBusPendingReply<RegisteredType> complexMethod()
@ -120,7 +120,7 @@ public Q_SLOTS: // METHODS
inline QDBusPendingReply<int> sleepMethod(int in0) inline QDBusPendingReply<int> sleepMethod(int in0)
{ {
QList<QVariant> argumentList; QList<QVariant> argumentList;
argumentList << qVariantFromValue(in0); argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QLatin1String("sleepMethod"), argumentList); 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"); QVERIFY2(p, "Not connected to D-Bus");
QDBusVariant expectedValue = QDBusVariant(Q_INT64_C(-47)); 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()); QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant());
} }
@ -603,7 +603,7 @@ void tst_QDBusAbstractInterface::complexPropWrite()
QVERIFY2(p, "Not connected to D-Bus"); QVERIFY2(p, "Not connected to D-Bus");
RegisteredType expectedValue = RegisteredType("This is a value"); 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); QCOMPARE(targetObj.m_complexProp, expectedValue);
} }
@ -652,7 +652,7 @@ void tst_QDBusAbstractInterface::variantPropWritePeer()
resetServer(); resetServer();
QDBusVariant expectedValue = QDBusVariant(Q_INT64_C(-47)); 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); QEXPECT_FAIL("", "QTBUG-24262 peer tests are broken", Abort);
QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant()); QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant());
} }
@ -676,7 +676,7 @@ void tst_QDBusAbstractInterface::complexPropWritePeer()
resetServer(); resetServer();
RegisteredType expectedValue = RegisteredType("This is a value"); 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); QEXPECT_FAIL("", "QTBUG-24262 peer tests are broken", Abort);
QCOMPARE(targetObj.m_complexProp, expectedValue); 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) void setComplexPropPeer(QList<int> val)
{ {
QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "setComplexProp"); QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "setComplexProp");
req << qVariantFromValue(val); req << QVariant::fromValue(val);
QDBusMessage reply = QDBusConnection::sessionBus().call(req); QDBusMessage reply = QDBusConnection::sessionBus().call(req);
} }
@ -474,7 +474,7 @@ void tst_QDBusInterface::callMethod()
MyObject::callCount = 0; MyObject::callCount = 0;
// call a SLOT method // 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(MyObject::callCount, 1);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -493,7 +493,7 @@ void tst_QDBusInterface::callMethod()
QCOMPARE(dv.variant().toString(), QString("foo")); QCOMPARE(dv.variant().toString(), QString("foo"));
// call an INVOKABLE method // 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(MyObject::callCount, 2);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -708,7 +708,7 @@ void tst_QDBusInterface::callMethodPeer()
resetPeer(); resetPeer();
// call a SLOT method // 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(callCountPeer(), 1);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -728,7 +728,7 @@ void tst_QDBusInterface::callMethodPeer()
QCOMPARE(dv.variant().toString(), QString("foo")); QCOMPARE(dv.variant().toString(), QString("foo"));
// call an INVOKABLE method // 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(callCountPeer(), 2);
QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
@ -1066,7 +1066,7 @@ void tst_QDBusInterface::complexPropertyWrite()
obj.m_complexProp.clear(); obj.m_complexProp.clear();
MyObject::callCount = 0; MyObject::callCount = 0;
QVERIFY(iface.setProperty("complexProp", qVariantFromValue(arg))); QVERIFY(iface.setProperty("complexProp", QVariant::fromValue(arg)));
QCOMPARE(MyObject::callCount, 1); QCOMPARE(MyObject::callCount, 1);
QCOMPARE(obj.m_complexProp, arg); QCOMPARE(obj.m_complexProp, arg);
} }
@ -1129,7 +1129,7 @@ void tst_QDBusInterface::complexPropertyWritePeer()
resetPeer(); resetPeer();
QList<int> arg = QList<int>() << -47 << 42; QList<int> arg = QList<int>() << -47 << 42;
QVERIFY(iface.setProperty("complexProp", qVariantFromValue(arg))); QVERIFY(iface.setProperty("complexProp", QVariant::fromValue(arg)));
QCOMPARE(callCountPeer(), 1); QCOMPARE(callCountPeer(), 1);
QCOMPARE(complexPropPeer(), arg); QCOMPARE(complexPropPeer(), arg);
} }

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

@ -185,7 +185,7 @@ void tst_QDBusLocalCalls::makeCallsVariant()
QFETCH(QVariant, value); QFETCH(QVariant, value);
QDBusMessage callMsg = QDBusMessage::createMethodCall(conn.baseService(), QDBusMessage callMsg = QDBusMessage::createMethodCall(conn.baseService(),
"/", QString(), "echo"); "/", QString(), "echo");
callMsg << qVariantFromValue(QDBusVariant(value)); callMsg << QVariant::fromValue(QDBusVariant(value));
QDBusMessage replyMsg = doCall(callMsg); QDBusMessage replyMsg = doCall(callMsg);
QCOMPARE(int(replyMsg.type()), int(QDBusMessage::ReplyMessage)); QCOMPARE(int(replyMsg.type()), int(QDBusMessage::ReplyMessage));
@ -222,7 +222,7 @@ void tst_QDBusLocalCalls::makeCallsComplex()
value << 1 << -42 << 47; value << 1 << -42 << 47;
QDBusMessage callMsg = QDBusMessage::createMethodCall(conn.baseService(), QDBusMessage callMsg = QDBusMessage::createMethodCall(conn.baseService(),
"/", QString(), "echo"); "/", QString(), "echo");
callMsg << qVariantFromValue(value); callMsg << QVariant::fromValue(value);
QDBusMessage replyMsg = doCall(callMsg); QDBusMessage replyMsg = doCall(callMsg);
QCOMPARE(int(replyMsg.type()), int(QDBusMessage::ReplyMessage)); 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("bool") << QVariant(false) << "b" << "false";
QTest::newRow("bool2") << QVariant(true) << "b" << "true"; QTest::newRow("bool2") << QVariant(true) << "b" << "true";
QTest::newRow("byte") << qVariantFromValue(uchar(1)) << "y" << "1"; QTest::newRow("byte") << QVariant::fromValue(uchar(1)) << "y" << "1";
QTest::newRow("int16") << qVariantFromValue(short(2)) << "n" << "2"; QTest::newRow("int16") << QVariant::fromValue(short(2)) << "n" << "2";
QTest::newRow("uint16") << qVariantFromValue(ushort(3)) << "q" << "3"; QTest::newRow("uint16") << QVariant::fromValue(ushort(3)) << "q" << "3";
QTest::newRow("int") << QVariant(1) << "i" << "1"; QTest::newRow("int") << QVariant(1) << "i" << "1";
QTest::newRow("uint") << QVariant(2U) << "u" << "2"; QTest::newRow("uint") << QVariant(2U) << "u" << "2";
QTest::newRow("int64") << QVariant(Q_INT64_C(3)) << "x" << "3"; QTest::newRow("int64") << QVariant(Q_INT64_C(3)) << "x" << "3";
@ -195,8 +195,8 @@ void basicNumericTypes_data()
void basicStringTypes_data() void basicStringTypes_data()
{ {
QTest::newRow("string") << QVariant("ping") << "s" << "\"ping\""; QTest::newRow("string") << QVariant("ping") << "s" << "\"ping\"";
QTest::newRow("objectpath") << qVariantFromValue(QDBusObjectPath("/org/kde")) << "o" << "[ObjectPath: /org/kde]"; QTest::newRow("objectpath") << QVariant::fromValue(QDBusObjectPath("/org/kde")) << "o" << "[ObjectPath: /org/kde]";
QTest::newRow("signature") << qVariantFromValue(QDBusSignature("g")) << "g" << "[Signature: g]"; QTest::newRow("signature") << QVariant::fromValue(QDBusSignature("g")) << "g" << "[Signature: g]";
QTest::newRow("emptystring") << QVariant("") << "s" << "\"\""; QTest::newRow("emptystring") << QVariant("") << "s" << "\"\"";
QTest::newRow("nullstring") << QVariant(QString()) << "s" << "\"\""; QTest::newRow("nullstring") << QVariant(QString()) << "s" << "\"\"";
} }
@ -210,17 +210,17 @@ void tst_QDBusMarshall::sendBasic_data()
basicStringTypes_data(); basicStringTypes_data();
if (fileDescriptorPassing) 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() void tst_QDBusMarshall::sendVariant_data()
{ {
sendBasic_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); 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]]"; << "[Variant(QDBusVariant): [Variant(int): 1]]";
} }
@ -252,70 +252,70 @@ void tst_QDBusMarshall::sendArrays_data()
QTest::newRow("bytearray") << QVariant(bytearray) << "ay" << "{102, 111, 111}"; QTest::newRow("bytearray") << QVariant(bytearray) << "ay" << "{102, 111, 111}";
QList<bool> bools; QList<bool> bools;
QTest::newRow("emptyboollist") << qVariantFromValue(bools) << "ab" << "[Argument: ab {}]"; QTest::newRow("emptyboollist") << QVariant::fromValue(bools) << "ab" << "[Argument: ab {}]";
bools << false << true << false; 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; 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; 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}]"; << "[Argument: an {42, -43, 44, 45, -32768, 32767}]";
QList<ushort> ushorts; 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; 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; 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; 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; 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; 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; 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) llints << Q_INT64_C(99) << Q_INT64_C(-100)
<< Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807); << 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}]"; << "[Argument: ax {99, -100, -9223372036854775808, 9223372036854775807}]";
QList<qulonglong> ullints; 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) ullints << Q_UINT64_C(66) << Q_UINT64_C(67)
<< Q_UINT64_C(18446744073709551615); << 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; 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 doubles << 1.2 << 2.2 << 4.4
<< -std::numeric_limits<double>::infinity() << -std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::infinity() << std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::quiet_NaN(); << 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; QList<QDBusObjectPath> objectPaths;
QTest::newRow("emptyobjectpathlist") << qVariantFromValue(objectPaths) << "ao" << "[Argument: ao {}]"; QTest::newRow("emptyobjectpathlist") << QVariant::fromValue(objectPaths) << "ao" << "[Argument: ao {}]";
objectPaths << QDBusObjectPath("/") << QDBusObjectPath("/foo"); 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) { if (fileDescriptorPassing) {
QList<QDBusUnixFileDescriptor> fileDescriptors; 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); 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; QVariantList variants;
QTest::newRow("emptyvariantlist") << QVariant(variants) << "av" << "[Argument: av {}]"; QTest::newRow("emptyvariantlist") << QVariant(variants) << "av" << "[Argument: av {}]";
variants << QString("Hello") << QByteArray("World") << 42 << -43.0 << 44U << Q_INT64_C(-45) variants << QString("Hello") << QByteArray("World") << 42 << -43.0 << 44U << Q_INT64_C(-45)
<< Q_UINT64_C(46) << true << qVariantFromValue(short(-47)) << Q_UINT64_C(46) << true << QVariant::fromValue(short(-47))
<< qVariantFromValue(QDBusSignature("av")) << QVariant::fromValue(QDBusSignature("av"))
<< qVariantFromValue(QDBusVariant(qVariantFromValue(QDBusObjectPath("/")))); << QVariant::fromValue(QDBusVariant(QVariant::fromValue(QDBusObjectPath("/"))));
QTest::newRow("variantlist") << QVariant(variants) << "av" 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: /]]]}]"; << "[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: // arrays:
QList<QStringList> strings; QList<QStringList> strings;
QTest::newRow("empty-list-of-stringlist") << qVariantFromValue(strings) << "aas" QTest::newRow("empty-list-of-stringlist") << QVariant::fromValue(strings) << "aas"
<< "[Argument: aas {}]"; << "[Argument: aas {}]";
strings << QStringList(); strings << QStringList();
QTest::newRow("list-of-emptystringlist") << qVariantFromValue(strings) << "aas" QTest::newRow("list-of-emptystringlist") << QVariant::fromValue(strings) << "aas"
<< "[Argument: aas {{}}]"; << "[Argument: aas {{}}]";
strings << (QStringList() << "hello" << "world") strings << (QStringList() << "hello" << "world")
<< (QStringList() << "hi" << "there") << (QStringList() << "hi" << "there")
<< (QStringList() << QString()); << (QStringList() << QString());
QTest::newRow("stringlist") << qVariantFromValue(strings) << "aas" QTest::newRow("stringlist") << QVariant::fromValue(strings) << "aas"
<< "[Argument: aas {{}, {\"hello\", \"world\"}, {\"hi\", \"there\"}, {\"\"}}]"; << "[Argument: aas {{}, {\"hello\", \"world\"}, {\"hi\", \"there\"}, {\"\"}}]";
QList<QByteArray> bytearray; QList<QByteArray> bytearray;
QTest::newRow("empty-list-of-bytearray") << qVariantFromValue(bytearray) << "aay" QTest::newRow("empty-list-of-bytearray") << QVariant::fromValue(bytearray) << "aay"
<< "[Argument: aay {}]"; << "[Argument: aay {}]";
bytearray << QByteArray(); bytearray << QByteArray();
QTest::newRow("list-of-emptybytearray") << qVariantFromValue(bytearray) << "aay" QTest::newRow("list-of-emptybytearray") << QVariant::fromValue(bytearray) << "aay"
<< "[Argument: aay {{}}]"; << "[Argument: aay {{}}]";
bytearray << "foo" << "bar" << "baz" << "" << QByteArray(); 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}, {}, {}}]"; << "[Argument: aay {{}, {102, 111, 111}, {98, 97, 114}, {98, 97, 122}, {}, {}}]";
QList<QList<bool> > bools; 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 {}]"; << "[Argument: aab {}]";
bools << QList<bool>(); bools << QList<bool>();
QTest::newRow("list-of-emptyboollist") << qVariantFromValue(bools) << "aab" QTest::newRow("list-of-emptyboollist") << QVariant::fromValue(bools) << "aab"
<< "[Argument: aab {[Argument: ab {}]}]"; << "[Argument: aab {[Argument: ab {}]}]";
bools << (QList<bool>() << false << true) << (QList<bool>() << false) << (QList<bool>()); 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 {}]}]"; << "[Argument: aab {[Argument: ab {}], [Argument: ab {false, true}], [Argument: ab {false}], [Argument: ab {}]}]";
QList<QList<short> > shorts; 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 {}]"; << "[Argument: aan {}]";
shorts << QList<short>(); shorts << QList<short>();
QTest::newRow("list-of-emptyshortlist") << qVariantFromValue(shorts) << "aan" QTest::newRow("list-of-emptyshortlist") << QVariant::fromValue(shorts) << "aan"
<< "[Argument: aan {[Argument: an {}]}]"; << "[Argument: aan {[Argument: an {}]}]";
shorts << (QList<short>() << 42 << -43 << 44 << 45) shorts << (QList<short>() << 42 << -43 << 44 << 45)
<< (QList<short>() << -32768 << 32767) << (QList<short>() << -32768 << 32767)
<< (QList<short>()); << (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 {}]}]"; << "[Argument: aan {[Argument: an {}], [Argument: an {42, -43, 44, 45}], [Argument: an {-32768, 32767}], [Argument: an {}]}]";
QList<QList<ushort> > ushorts; 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 {}]"; << "[Argument: aaq {}]";
ushorts << QList<ushort>(); ushorts << QList<ushort>();
QTest::newRow("list-of-emptyushortlist") << qVariantFromValue(ushorts) << "aaq" QTest::newRow("list-of-emptyushortlist") << QVariant::fromValue(ushorts) << "aaq"
<< "[Argument: aaq {[Argument: aq {}]}]"; << "[Argument: aaq {[Argument: aq {}]}]";
ushorts << (QList<ushort>() << 12u << 13u << 14u << 15) ushorts << (QList<ushort>() << 12u << 13u << 14u << 15)
<< (QList<ushort>() << 65535) << (QList<ushort>() << 65535)
<< (QList<ushort>()); << (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 {}]}]"; << "[Argument: aaq {[Argument: aq {}], [Argument: aq {12, 13, 14, 15}], [Argument: aq {65535}], [Argument: aq {}]}]";
QList<QList<int> > ints; 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 {}]"; << "[Argument: aai {}]";
ints << QList<int>(); ints << QList<int>();
QTest::newRow("list-of-emptyintlist") << qVariantFromValue(ints) << "aai" QTest::newRow("list-of-emptyintlist") << QVariant::fromValue(ints) << "aai"
<< "[Argument: aai {[Argument: ai {}]}]"; << "[Argument: aai {[Argument: ai {}]}]";
ints << (QList<int>() << 42 << -43 << 44 << 45) ints << (QList<int>() << 42 << -43 << 44 << 45)
<< (QList<int>() << 2147483647 << -2147483647-1) << (QList<int>() << 2147483647 << -2147483647-1)
<< (QList<int>()); << (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 {}]}]"; << "[Argument: aai {[Argument: ai {}], [Argument: ai {42, -43, 44, 45}], [Argument: ai {2147483647, -2147483648}], [Argument: ai {}]}]";
QList<QList<uint> > uints; 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 {}]"; << "[Argument: aau {}]";
uints << QList<uint>(); uints << QList<uint>();
QTest::newRow("list-of-emptyuintlist") << qVariantFromValue(uints) << "aau" QTest::newRow("list-of-emptyuintlist") << QVariant::fromValue(uints) << "aau"
<< "[Argument: aau {[Argument: au {}]}]"; << "[Argument: aau {[Argument: au {}]}]";
uints << (QList<uint>() << uint(12) << uint(13) << uint(14)) uints << (QList<uint>() << uint(12) << uint(13) << uint(14))
<< (QList<uint>() << 4294967295U) << (QList<uint>() << 4294967295U)
<< (QList<uint>()); << (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 {}]}]"; << "[Argument: aau {[Argument: au {}], [Argument: au {12, 13, 14}], [Argument: au {4294967295}], [Argument: au {}]}]";
QList<QList<qlonglong> > llints; 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 {}]"; << "[Argument: aax {}]";
llints << QList<qlonglong>(); llints << QList<qlonglong>();
QTest::newRow("list-of-emptyllintlist") << qVariantFromValue(llints) << "aax" QTest::newRow("list-of-emptyllintlist") << QVariant::fromValue(llints) << "aax"
<< "[Argument: aax {[Argument: ax {}]}]"; << "[Argument: aax {[Argument: ax {}]}]";
llints << (QList<qlonglong>() << Q_INT64_C(99) << Q_INT64_C(-100)) llints << (QList<qlonglong>() << Q_INT64_C(99) << Q_INT64_C(-100))
<< (QList<qlonglong>() << Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807)) << (QList<qlonglong>() << Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807))
<< (QList<qlonglong>()); << (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 {}]}]"; << "[Argument: aax {[Argument: ax {}], [Argument: ax {99, -100}], [Argument: ax {-9223372036854775808, 9223372036854775807}], [Argument: ax {}]}]";
QList<QList<qulonglong> > ullints; 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 {}]"; << "[Argument: aat {}]";
ullints << QList<qulonglong>(); ullints << QList<qulonglong>();
QTest::newRow("list-of-emptyullintlist") << qVariantFromValue(ullints) << "aat" QTest::newRow("list-of-emptyullintlist") << QVariant::fromValue(ullints) << "aat"
<< "[Argument: aat {[Argument: at {}]}]"; << "[Argument: aat {[Argument: at {}]}]";
ullints << (QList<qulonglong>() << Q_UINT64_C(66) << Q_UINT64_C(67)) ullints << (QList<qulonglong>() << Q_UINT64_C(66) << Q_UINT64_C(67))
<< (QList<qulonglong>() << Q_UINT64_C(18446744073709551615)) << (QList<qulonglong>() << Q_UINT64_C(18446744073709551615))
<< (QList<qulonglong>()); << (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 {}]}]"; << "[Argument: aat {[Argument: at {}], [Argument: at {66, 67}], [Argument: at {18446744073709551615}], [Argument: at {}]}]";
QList<QList<double> > doubles; QList<QList<double> > doubles;
QTest::newRow("empty-list-ofdoublelist") << qVariantFromValue(doubles) << "aad" QTest::newRow("empty-list-ofdoublelist") << QVariant::fromValue(doubles) << "aad"
<< "[Argument: aad {}]"; << "[Argument: aad {}]";
doubles << QList<double>(); doubles << QList<double>();
QTest::newRow("list-of-emptydoublelist") << qVariantFromValue(doubles) << "aad" QTest::newRow("list-of-emptydoublelist") << QVariant::fromValue(doubles) << "aad"
<< "[Argument: aad {[Argument: ad {}]}]"; << "[Argument: aad {[Argument: ad {}]}]";
doubles << (QList<double>() << 1.2 << 2.2 << 4.4) doubles << (QList<double>() << 1.2 << 2.2 << 4.4)
<< (QList<double>() << -std::numeric_limits<double>::infinity() << (QList<double>() << -std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::infinity() << std::numeric_limits<double>::infinity()
<< std::numeric_limits<double>::quiet_NaN()) << std::numeric_limits<double>::quiet_NaN())
<< (QList<double>()); << (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 {}]}]"; << "[Argument: aad {[Argument: ad {}], [Argument: ad {1.2, 2.2, 4.4}], [Argument: ad {-inf, inf, nan}], [Argument: ad {}]}]";
QList<QVariantList> variants; QList<QVariantList> variants;
QTest::newRow("emptyvariantlist") << qVariantFromValue(variants) << "aav" QTest::newRow("emptyvariantlist") << QVariant::fromValue(variants) << "aav"
<< "[Argument: aav {}]"; << "[Argument: aav {}]";
variants << QVariantList(); variants << QVariantList();
QTest::newRow("emptyvariantlist") << qVariantFromValue(variants) << "aav" QTest::newRow("emptyvariantlist") << QVariant::fromValue(variants) << "aav"
<< "[Argument: aav {[Argument: av {}]}]"; << "[Argument: aav {[Argument: av {}]}]";
variants << (QVariantList() << QString("Hello") << QByteArray("World")) variants << (QVariantList() << QString("Hello") << QByteArray("World"))
<< (QVariantList() << 42 << -43.0 << 44U << Q_INT64_C(-45)) << (QVariantList() << 42 << -43.0 << 44U << Q_INT64_C(-45))
<< (QVariantList() << Q_UINT64_C(46) << true << qVariantFromValue(short(-47))); << (QVariantList() << Q_UINT64_C(46) << true << QVariant::fromValue(short(-47)));
QTest::newRow("variantlist") << qVariantFromValue(variants) << "aav" 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]}]}]"; << "[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"); QTest::addColumn<QString>("stringResult");
QMap<int, QString> ismap; 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} {}]"; << "[Argument: a{is} {}]";
ismap[1] = "a"; ismap[1] = "a";
ismap[2000] = "b"; ismap[2000] = "b";
ismap[-47] = "c"; 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\"}]"; << "[Argument: a{is} {-47 = \"c\", 1 = \"a\", 2000 = \"b\"}]";
QMap<QString, QString> ssmap; 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} {}]"; << "[Argument: a{ss} {}]";
ssmap["a"] = "a"; ssmap["a"] = "a";
ssmap["c"] = "b"; ssmap["c"] = "b";
ssmap["b"] = "c"; 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\"}]"; << "[Argument: a{ss} {\"a\" = \"a\", \"b\" = \"c\", \"c\" = \"b\"}]";
QVariantMap svmap; QVariantMap svmap;
QTest::newRow("empty-sv-map") << qVariantFromValue(svmap) << "a{sv}" QTest::newRow("empty-sv-map") << QVariant::fromValue(svmap) << "a{sv}"
<< "[Argument: a{sv} {}]"; << "[Argument: a{sv} {}]";
svmap["a"] = 1; svmap["a"] = 1;
svmap["c"] = "b"; svmap["c"] = "b";
svmap["b"] = QByteArray("c"); svmap["b"] = QByteArray("c");
svmap["d"] = 42U; svmap["d"] = 42U;
svmap["e"] = qVariantFromValue(short(-47)); svmap["e"] = QVariant::fromValue(short(-47));
svmap["f"] = qVariantFromValue(QDBusVariant(0)); svmap["f"] = QVariant::fromValue(QDBusVariant(0));
QTest::newRow("sv-map1") << qVariantFromValue(svmap) << "a{sv}" 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]]}]"; << "[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; 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} {}]"; << "[Argument: a{os} {}]";
osmap[QDBusObjectPath("/")] = "root"; osmap[QDBusObjectPath("/")] = "root";
osmap[QDBusObjectPath("/foo")] = "foo"; osmap[QDBusObjectPath("/foo")] = "foo";
osmap[QDBusObjectPath("/bar/baz")] = "bar and baz"; 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\"}]"; << "[Argument: a{os} {[ObjectPath: /] = \"root\", [ObjectPath: /bar/baz] = \"bar and baz\", [ObjectPath: /foo] = \"foo\"}]";
QMap<QDBusSignature, QString> gsmap; 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} {}]"; << "[Argument: a{gs} {}]";
gsmap[QDBusSignature("i")] = "int32"; gsmap[QDBusSignature("i")] = "int32";
gsmap[QDBusSignature("s")] = "string"; gsmap[QDBusSignature("s")] = "string";
gsmap[QDBusSignature("a{gs}")] = "array of dict_entry of (signature, 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\"}]"; << "[Argument: a{gs} {[Signature: a{gs}] = \"array of dict_entry of (signature, string)\", [Signature: i] = \"int32\", [Signature: s] = \"string\"}]";
if (fileDescriptorPassing) { if (fileDescriptorPassing) {
svmap["zzfiledescriptor"] = qVariantFromValue(QDBusUnixFileDescriptor(fileDescriptorForTest())); svmap["zzfiledescriptor"] = QVariant::fromValue(QDBusUnixFileDescriptor(fileDescriptorForTest()));
QTest::newRow("sv-map1-fd") << qVariantFromValue(svmap) << "a{sv}" 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]]}]"; << "[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.clear();
svmap["ismap"] = qVariantFromValue(ismap); svmap["ismap"] = QVariant::fromValue(ismap);
svmap["ssmap"] = qVariantFromValue(ssmap); svmap["ssmap"] = QVariant::fromValue(ssmap);
svmap["osmap"] = qVariantFromValue(osmap); svmap["osmap"] = QVariant::fromValue(osmap);
svmap["gsmap"] = qVariantFromValue(gsmap); svmap["gsmap"] = QVariant::fromValue(gsmap);
QTest::newRow("sv-map2") << qVariantFromValue(svmap) << "a{sv}" 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\"}]]}]"; << "[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]"; << "[Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 12, 25, 0, 0], 0]";
MyStruct ms = { 1, "Hello, World" }; 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() }; 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 // use only basic types, otherwise comparison will fail
mvms.map["int"] = 42; mvms.map["int"] = 42;
mvms.map["uint"] = 42u; mvms.map["uint"] = 42u;
mvms.map["short"] = qVariantFromValue<short>(-47); mvms.map["short"] = QVariant::fromValue<short>(-47);
mvms.map["bytearray"] = QByteArray("Hello, world"); 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; 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; 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) { if (fileDescriptorPassing) {
MyFileDescriptorStruct fds; MyFileDescriptorStruct fds;
fds.fd = QDBusUnixFileDescriptor(fileDescriptorForTest()); 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; 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; 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"); QTest::addColumn<QString>("stringResult");
QList<QDateTime> dtlist; 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) {}]"; << "[Argument: a((iii)(iiii)i) {}]";
dtlist << QDateTime(); 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]}]"; << "[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)) dtlist << QDateTime(QDate(1977, 9, 13), QTime(0, 0, 0))
<< QDateTime(QDate(2006, 6, 18), QTime(13, 14, 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]}]"; << "[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; 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)} {}]"; << "[Argument: a{x((iii)(iiii)i)} {}]";
lldtmap[0] = QDateTime(); lldtmap[0] = QDateTime();
lldtmap[1] = QDateTime(QDate(1970, 1, 1), QTime(0, 0, 1), Qt::UTC); 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); 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]}]"; << "[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["c"] = "b";
svmap["b"] = QByteArray("c"); svmap["b"] = QByteArray("c");
svmap["d"] = 42U; svmap["d"] = 42U;
svmap["e"] = qVariantFromValue(short(-47)); svmap["e"] = QVariant::fromValue(short(-47));
svmap["f"] = qVariantFromValue(QDBusVariant(0)); svmap["f"] = QVariant::fromValue(QDBusVariant(0));
svmap["date"] = QDate(1977, 1, 1); svmap["date"] = QDate(1977, 1, 1);
svmap["time"] = QTime(8, 58, 0); svmap["time"] = QTime(8, 58, 0);
svmap["datetime"] = QDateTime(QDate(13, 9, 2008), QTime(8, 59, 31)); svmap["datetime"] = QDateTime(QDate(13, 9, 2008), QTime(8, 59, 31));
svmap["pointf"] = QPointF(0.5, -0.5); svmap["pointf"] = QPointF(0.5, -0.5);
svmap["ismap"] = qVariantFromValue(ismap); svmap["ismap"] = QVariant::fromValue(ismap);
svmap["ssmap"] = qVariantFromValue(ssmap); svmap["ssmap"] = QVariant::fromValue(ssmap);
svmap["gsmap"] = qVariantFromValue(gsmap); svmap["gsmap"] = QVariant::fromValue(gsmap);
svmap["dtlist"] = qVariantFromValue(dtlist); svmap["dtlist"] = QVariant::fromValue(dtlist);
svmap["lldtmap"] = qVariantFromValue(lldtmap); svmap["lldtmap"] = QVariant::fromValue(lldtmap);
QTest::newRow("sv-map") << qVariantFromValue(svmap) << "a{sv}" 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]]}]"; << "[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 = QDBusArgument();
arg << true; arg << true;
QTest::newRow("bool") << qVariantFromValue(arg) << "b" << int(QDBusArgument::BasicType);; QTest::newRow("bool") << QVariant::fromValue(arg) << "b" << int(QDBusArgument::BasicType);;
arg = QDBusArgument(); arg = QDBusArgument();
arg << false; arg << false;
QTest::newRow("bool2") << qVariantFromValue(arg) << "b" << int(QDBusArgument::BasicType); QTest::newRow("bool2") << QVariant::fromValue(arg) << "b" << int(QDBusArgument::BasicType);
arg = QDBusArgument(); arg = QDBusArgument();
arg << uchar(1); 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 = QDBusArgument();
arg << short(2); 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 = QDBusArgument();
arg << ushort(3); 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 = QDBusArgument();
arg << 1; arg << 1;
QTest::newRow("int32") << qVariantFromValue(arg) << "i" << int(QDBusArgument::BasicType); QTest::newRow("int32") << QVariant::fromValue(arg) << "i" << int(QDBusArgument::BasicType);
arg = QDBusArgument(); arg = QDBusArgument();
arg << 2U; arg << 2U;
QTest::newRow("uint32") << qVariantFromValue(arg) << "u" << int(QDBusArgument::BasicType); QTest::newRow("uint32") << QVariant::fromValue(arg) << "u" << int(QDBusArgument::BasicType);
arg = QDBusArgument(); arg = QDBusArgument();
arg << Q_INT64_C(3); 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 = QDBusArgument();
arg << Q_UINT64_C(4); 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 = QDBusArgument();
arg << 42.5; 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 = QDBusArgument();
arg << QLatin1String("ping"); 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 = QDBusArgument();
arg << QDBusObjectPath("/org/kde"); 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 = QDBusArgument();
arg << QDBusSignature("g"); 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 = QDBusArgument();
arg << QLatin1String(""); arg << QLatin1String("");
QTest::newRow("emptystring") << qVariantFromValue(arg) << "s" << int(QDBusArgument::BasicType); QTest::newRow("emptystring") << QVariant::fromValue(arg) << "s" << int(QDBusArgument::BasicType);
arg = QDBusArgument(); arg = QDBusArgument();
arg << QString(); arg << QString();
QTest::newRow("nullstring") << qVariantFromValue(arg) << "s" << int(QDBusArgument::BasicType); QTest::newRow("nullstring") << QVariant::fromValue(arg) << "s" << int(QDBusArgument::BasicType);
if (fileDescriptorPassing) { if (fileDescriptorPassing) {
arg = QDBusArgument(); arg = QDBusArgument();
arg << QDBusUnixFileDescriptor(fileDescriptorForTest()); 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 = QDBusArgument();
arg << QDBusVariant(1); 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 = QDBusArgument();
arg << QDBusVariant(qVariantFromValue(QDBusVariant(1))); arg << QDBusVariant(QVariant::fromValue(QDBusVariant(1)));
QTest::newRow("variant-variant") << qVariantFromValue(arg) << "v" << int(QDBusArgument::VariantType); QTest::newRow("variant-variant") << QVariant::fromValue(arg) << "v" << int(QDBusArgument::VariantType);
arg = QDBusArgument(); arg = QDBusArgument();
arg.beginArray(QVariant::Int); arg.beginArray(QVariant::Int);
arg << 1 << 2 << 3 << -4; arg << 1 << 2 << 3 << -4;
arg.endArray(); 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 = QDBusArgument();
arg.beginMap(QVariant::Int, QVariant::UInt); arg.beginMap(QVariant::Int, QVariant::UInt);
@ -744,13 +744,13 @@ void tst_QDBusMarshall::sendArgument_data()
arg << 3 << 4U; arg << 3 << 4U;
arg.endMapEntry(); arg.endMapEntry();
arg.endMap(); 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 = QDBusArgument();
arg.beginStructure(); arg.beginStructure();
arg << 1 << 2U << short(-3) << ushort(4) << 5.0 << false; arg << 1 << 2U << short(-3) << ushort(4) << 5.0 << false;
arg.endStructure(); 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() void tst_QDBusMarshall::sendBasic()
@ -790,7 +790,7 @@ void tst_QDBusMarshall::sendVariant()
QDBusMessage msg = QDBusMessage::createMethodCall(serviceName, QDBusMessage msg = QDBusMessage::createMethodCall(serviceName,
objectPath, interfaceName, "ping"); objectPath, interfaceName, "ping");
msg << qVariantFromValue(QDBusVariant(value)); msg << QVariant::fromValue(QDBusVariant(value));
QDBusMessage reply = con.call(msg); QDBusMessage reply = con.call(msg);
// qDebug() << reply; // qDebug() << reply;
@ -851,7 +851,7 @@ void tst_QDBusMarshall::sendArgument()
sendArg.beginStructure(); sendArg.beginStructure();
sendArg.appendVariant(value); sendArg.appendVariant(value);
sendArg.endStructure(); sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg)); msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
reply = con.call(msg); reply = con.call(msg);
QCOMPARE(reply.signature(), QString("(%1)").arg(sig)); QCOMPARE(reply.signature(), QString("(%1)").arg(sig));
@ -883,7 +883,7 @@ void tst_QDBusMarshall::sendSignalErrors()
QVERIFY(con.isConnected()); QVERIFY(con.isConnected());
QDBusMessage msg = QDBusMessage::createSignal("/foo", "local.interfaceName", QDBusMessage msg = QDBusMessage::createSignal("/foo", "local.interfaceName",
"signalName"); "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"); 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)); QVERIFY(!con.send(msg));
@ -893,20 +893,20 @@ void tst_QDBusMarshall::sendSignalErrors()
QTest::ignoreMessage(QtWarningMsg, "QDBusObjectPath: invalid path \"abc\""); QTest::ignoreMessage(QtWarningMsg, "QDBusObjectPath: invalid path \"abc\"");
path.setPath("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"); 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)); QVERIFY(!con.send(msg));
QDBusSignature sig; 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"); 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)); QVERIFY(!con.send(msg));
QTest::ignoreMessage(QtWarningMsg, "QDBusSignature: invalid signature \"a\""); QTest::ignoreMessage(QtWarningMsg, "QDBusSignature: invalid signature \"a\"");
sig.setSignature("a"); sig.setSignature("a");
msg.setArguments(QVariantList()); 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"); 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)); QVERIFY(!con.send(msg));
} }
@ -956,7 +956,7 @@ void tst_QDBusMarshall::sendCallErrors_data()
<< "Marshalling failed: Variant containing QVariant::Invalid passed in arguments" << "Marshalling failed: Variant containing QVariant::Invalid passed in arguments"
<< "QDBusMarshaller: cannot add an invalid QVariant"; << "QDBusMarshaller: cannot add an invalid QVariant";
QTest::newRow("invalid-variant1") << serviceName << objectPath << interfaceName << "ping" QTest::newRow("invalid-variant1") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusVariant())) << (QVariantList() << QVariant::fromValue(QDBusVariant()))
<< "org.freedesktop.DBus.Error.Failed" << "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Variant containing QVariant::Invalid passed in arguments" << "Marshalling failed: Variant containing QVariant::Invalid passed in arguments"
<< "QDBusMarshaller: cannot add a null QDBusVariant"; << "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 // this type is known to the meta type system, but not registered with D-Bus
qRegisterMetaType<UnregisteredType>(); qRegisterMetaType<UnregisteredType>();
QTest::newRow("extra-unregistered") << serviceName << objectPath << interfaceName << "ping" QTest::newRow("extra-unregistered") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(UnregisteredType())) << (QVariantList() << QVariant::fromValue(UnregisteredType()))
<< "org.freedesktop.DBus.Error.Failed" << "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Unregistered type UnregisteredType passed in arguments" << "Marshalling failed: Unregistered type UnregisteredType passed in arguments"
<< QString("QDBusMarshaller: type `UnregisteredType' (%1) is not registered with D-BUS. Use qDBusRegisterMetaType to register it") << QString("QDBusMarshaller: type `UnregisteredType' (%1) is not registered with D-BUS. Use qDBusRegisterMetaType to register it")
.arg(qMetaTypeId<UnregisteredType>()); .arg(qMetaTypeId<UnregisteredType>());
QTest::newRow("invalid-object-path-arg") << serviceName << objectPath << interfaceName << "ping" QTest::newRow("invalid-object-path-arg") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusObjectPath())) << (QVariantList() << QVariant::fromValue(QDBusObjectPath()))
<< "org.freedesktop.DBus.Error.Failed" << "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Invalid object path passed in arguments" << "Marshalling failed: Invalid object path passed in arguments"
<< ""; << "";
QTest::newRow("invalid-signature-arg") << serviceName << objectPath << interfaceName << "ping" QTest::newRow("invalid-signature-arg") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusSignature())) << (QVariantList() << QVariant::fromValue(QDBusSignature()))
<< "org.freedesktop.DBus.Error.Failed" << "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Invalid signature passed in arguments" << "Marshalling failed: Invalid signature passed in arguments"
<< ""; << "";
@ -991,7 +991,7 @@ void tst_QDBusMarshall::sendCallErrors_data()
// invalid file descriptor // invalid file descriptor
if (fileDescriptorPassing) { if (fileDescriptorPassing) {
QTest::newRow("invalid-file-descriptor") << serviceName << objectPath << interfaceName << "ping" QTest::newRow("invalid-file-descriptor") << serviceName << objectPath << interfaceName << "ping"
<< (QVariantList() << qVariantFromValue(QDBusUnixFileDescriptor(-1))) << (QVariantList() << QVariant::fromValue(QDBusUnixFileDescriptor(-1)))
<< "org.freedesktop.DBus.Error.Failed" << "org.freedesktop.DBus.Error.Failed"
<< "Marshalling failed: Invalid file descriptor passed in arguments" << "Marshalling failed: Invalid file descriptor passed in arguments"
<< ""; << "";
@ -1200,7 +1200,7 @@ QVariant demarshallPrimitiveAs(const QDBusArgument& dbusArg)
{ {
T val; T val;
dbusArg >> val; dbusArg >> val;
return qVariantFromValue(val); return QVariant::fromValue(val);
} }
QVariant demarshallPrimitiveAs(int typeIndex, const QDBusArgument& dbusArg) QVariant demarshallPrimitiveAs(int typeIndex, const QDBusArgument& dbusArg)
@ -1247,7 +1247,7 @@ void tst_QDBusMarshall::demarshallPrimitives()
sendArg.beginStructure(); sendArg.beginStructure();
sendArg.appendVariant(value); sendArg.appendVariant(value);
sendArg.endStructure(); sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg)); msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg); QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0));
@ -1279,15 +1279,15 @@ void tst_QDBusMarshall::demarshallStrings_data()
typedef QPair<QVariant, char> ValSigPair; typedef QPair<QVariant, char> ValSigPair;
const QList<ValSigPair> nullStringTypes const QList<ValSigPair> nullStringTypes
= QList<ValSigPair>() = QList<ValSigPair>()
<< ValSigPair(qVariantFromValue(QString()), 's') << ValSigPair(QVariant::fromValue(QString()), 's')
<< ValSigPair(qVariantFromValue(QDBusObjectPath()), 'o') << ValSigPair(QVariant::fromValue(QDBusObjectPath()), 'o')
<< ValSigPair(qVariantFromValue(QDBusSignature()), 'g'); << ValSigPair(QVariant::fromValue(QDBusSignature()), 'g');
foreach (ValSigPair valSigPair, nullStringTypes) { foreach (ValSigPair valSigPair, nullStringTypes) {
QTest::newRow("bool(false)") << QVariant(false) << valSigPair.second << valSigPair.first; QTest::newRow("bool(false)") << QVariant(false) << valSigPair.second << valSigPair.first;
QTest::newRow("bool(true)") << QVariant(true) << 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("byte") << QVariant::fromValue(uchar(1)) << valSigPair.second << valSigPair.first;
QTest::newRow("int16") << qVariantFromValue(short(2)) << valSigPair.second << valSigPair.first; QTest::newRow("int16") << QVariant::fromValue(short(2)) << valSigPair.second << valSigPair.first;
QTest::newRow("uint16") << qVariantFromValue(ushort(3)) << 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("int") << QVariant(1) << valSigPair.second << valSigPair.first;
QTest::newRow("uint") << QVariant(2U) << 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; 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 // to check released functionality is maintained even after checks have
// been added to string demarshalling // been added to string demarshalling
QTest::newRow("empty string->invalid objectpath") << QVariant("") QTest::newRow("empty string->invalid objectpath") << QVariant("")
<< 'o' << qVariantFromValue(QDBusObjectPath()); << 'o' << QVariant::fromValue(QDBusObjectPath());
QTest::newRow("null string->invalid objectpath") << QVariant(QString()) QTest::newRow("null string->invalid objectpath") << QVariant(QString())
<< 'o' << qVariantFromValue(QDBusObjectPath()); << 'o' << QVariant::fromValue(QDBusObjectPath());
QTest::newRow("string->invalid objectpath") << QVariant("invalid objectpath") QTest::newRow("string->invalid objectpath") << QVariant("invalid objectpath")
<< 'o' << qVariantFromValue(QDBusObjectPath()); << 'o' << QVariant::fromValue(QDBusObjectPath());
QTest::newRow("string->valid objectpath") << QVariant("/org/kde") 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("") QTest::newRow("empty string->invalid signature") << QVariant("")
<< 'g' << qVariantFromValue(QDBusSignature()); << 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("null string->invalid signature") << QVariant(QString()) QTest::newRow("null string->invalid signature") << QVariant(QString())
<< 'g' << qVariantFromValue(QDBusSignature()); << 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("string->invalid signature") << QVariant("_invalid signature") QTest::newRow("string->invalid signature") << QVariant("_invalid signature")
<< 'g' << qVariantFromValue(QDBusSignature()); << 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("string->valid signature") << QVariant("s") QTest::newRow("string->valid signature") << QVariant("s")
<< 'g' << qVariantFromValue(QDBusSignature("s")); << 'g' << QVariant::fromValue(QDBusSignature("s"));
QTest::newRow("objectpath->string") << qVariantFromValue(QDBusObjectPath("/org/kde")) QTest::newRow("objectpath->string") << QVariant::fromValue(QDBusObjectPath("/org/kde"))
<< 's' << qVariantFromValue(QString("/org/kde")); << 's' << QVariant::fromValue(QString("/org/kde"));
QTest::newRow("objectpath->invalid signature") << qVariantFromValue(QDBusObjectPath("/org/kde")) QTest::newRow("objectpath->invalid signature") << QVariant::fromValue(QDBusObjectPath("/org/kde"))
<< 'g' << qVariantFromValue(QDBusSignature()); << 'g' << QVariant::fromValue(QDBusSignature());
QTest::newRow("signature->string") << qVariantFromValue(QDBusSignature("s")) QTest::newRow("signature->string") << QVariant::fromValue(QDBusSignature("s"))
<< 's' << qVariantFromValue(QString("s")); << 's' << QVariant::fromValue(QString("s"));
QTest::newRow("signature->invalid objectpath") << qVariantFromValue(QDBusSignature("s")) QTest::newRow("signature->invalid objectpath") << QVariant::fromValue(QDBusSignature("s"))
<< 'o' << qVariantFromValue(QDBusObjectPath()); << 'o' << QVariant::fromValue(QDBusObjectPath());
} }
QVariant demarshallAsString(const QDBusArgument& dbusArg, char targetSig) QVariant demarshallAsString(const QDBusArgument& dbusArg, char targetSig)
@ -1338,12 +1338,12 @@ QVariant demarshallAsString(const QDBusArgument& dbusArg, char targetSig)
case 'o': { case 'o': {
QDBusObjectPath op; QDBusObjectPath op;
dbusArg >> op; dbusArg >> op;
return qVariantFromValue(op); return QVariant::fromValue(op);
} }
case 'g' : { case 'g' : {
QDBusSignature sig; QDBusSignature sig;
dbusArg >> sig; dbusArg >> sig;
return qVariantFromValue(sig); return QVariant::fromValue(sig);
} }
default: { default: {
return QVariant(); return QVariant();
@ -1367,7 +1367,7 @@ void tst_QDBusMarshall::demarshallStrings()
sendArg.beginStructure(); sendArg.beginStructure();
sendArg.appendVariant(value); sendArg.appendVariant(value);
sendArg.endStructure(); sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg)); msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg); QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); 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 // Arrays of non-string type should not demarshall to a string list
QList<bool> bools; QList<bool> bools;
QTest::newRow("emptyboollist") << qVariantFromValue(bools); QTest::newRow("emptyboollist") << QVariant::fromValue(bools);
bools << false << true << false; bools << false << true << false;
QTest::newRow("boollist") << qVariantFromValue(bools); QTest::newRow("boollist") << QVariant::fromValue(bools);
// Structures should not demarshall to a QByteArray // Structures should not demarshall to a QByteArray
QTest::newRow("struct of strings") QTest::newRow("struct of strings")
<< qVariantFromValue(QVariantList() << QString("foo") << QString("bar")); << QVariant::fromValue(QVariantList() << QString("foo") << QString("bar"));
QTest::newRow("struct of mixed types") 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() void tst_QDBusMarshall::demarshallInvalidStringList()
@ -1416,7 +1416,7 @@ void tst_QDBusMarshall::demarshallInvalidStringList()
sendArg.beginStructure(); sendArg.beginStructure();
sendArg.appendVariant(value); sendArg.appendVariant(value);
sendArg.endStructure(); sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg)); msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg); QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); 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 // Arrays of other types than byte should not demarshall to a QByteArray
QList<bool> bools; QList<bool> bools;
QTest::newRow("empty array of bool") << qVariantFromValue(bools); QTest::newRow("empty array of bool") << QVariant::fromValue(bools);
bools << true << false << true; 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 // Structures should not demarshall to a QByteArray
QTest::newRow("struct of bytes") QTest::newRow("struct of bytes")
<< qVariantFromValue(QVariantList() << uchar(1) << uchar(2)); << QVariant::fromValue(QVariantList() << uchar(1) << uchar(2));
QTest::newRow("struct of mixed types") 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() void tst_QDBusMarshall::demarshallInvalidByteArray()
@ -1466,7 +1466,7 @@ void tst_QDBusMarshall::demarshallInvalidByteArray()
sendArg.beginStructure(); sendArg.beginStructure();
sendArg.appendVariant(value); sendArg.appendVariant(value);
sendArg.endStructure(); sendArg.endStructure();
msg.setArguments(QVariantList() << qVariantFromValue(sendArg)); msg.setArguments(QVariantList() << QVariant::fromValue(sendArg));
QDBusMessage reply = con.call(msg); QDBusMessage reply = con.call(msg);
const QDBusArgument receiveArg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); 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(selectionChangedSpy.count(), 0);
QCOMPARE(changedSpy.count(), 1); QCOMPARE(changedSpy.count(), 1);
QCOMPARE(changedSpy.at(0).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(); changedSpy.clear();
@ -168,7 +168,7 @@ void tst_QClipboard::testSignals()
QCOMPARE(selectionChangedSpy.count(), 1); QCOMPARE(selectionChangedSpy.count(), 1);
QCOMPARE(changedSpy.count(), 1); QCOMPARE(changedSpy.count(), 1);
QCOMPARE(changedSpy.at(0).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 { } else {
QCOMPARE(selectionChangedSpy.count(), 0); QCOMPARE(selectionChangedSpy.count(), 0);
} }
@ -183,7 +183,7 @@ void tst_QClipboard::testSignals()
QCOMPARE(searchChangedSpy.count(), 1); QCOMPARE(searchChangedSpy.count(), 1);
QCOMPARE(changedSpy.count(), 1); QCOMPARE(changedSpy.count(), 1);
QCOMPARE(changedSpy.at(0).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 { } else {
QCOMPARE(searchChangedSpy.count(), 0); 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); QMatrix4x4 m1(uniqueValues4);
obj.setMatrix(m1); obj.setMatrix(m1);
QMatrix4x4 m2 = qVariantValue<QMatrix4x4>(obj.property("matrix")); QMatrix4x4 m2 = qvariant_cast<QMatrix4x4>(obj.property("matrix"));
QVERIFY(isSame(m2, uniqueValues4)); QVERIFY(isSame(m2, uniqueValues4));
QMatrix4x4 m3(transposedValues4); 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)); 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)); 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.scalar(), (qreal)6.0f);
QCOMPARE(q.x(), (qreal)7.0f); QCOMPARE(q.x(), (qreal)7.0f);
QCOMPARE(q.y(), (qreal)8.0f); QCOMPARE(q.y(), (qreal)8.0f);
QCOMPARE(q.z(), (qreal)9.0f); QCOMPARE(q.z(), (qreal)9.0f);
obj.setProperty("quaternion", 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.scalar(), (qreal)-6.0f);
QCOMPARE(q.x(), (qreal)-7.0f); QCOMPARE(q.x(), (qreal)-7.0f);
QCOMPARE(q.y(), (qreal)-8.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.setVector3D(QVector3D(3.0f, 4.0f, 5.0f));
obj.setVector4D(QVector4D(6.0f, 7.0f, 8.0f, 9.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.x(), (qreal)1.0f);
QCOMPARE(v2.y(), (qreal)2.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.x(), (qreal)3.0f);
QCOMPARE(v3.y(), (qreal)4.0f); QCOMPARE(v3.y(), (qreal)4.0f);
QCOMPARE(v3.z(), (qreal)5.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.x(), (qreal)6.0f);
QCOMPARE(v4.y(), (qreal)7.0f); QCOMPARE(v4.y(), (qreal)7.0f);
QCOMPARE(v4.z(), (qreal)8.0f); QCOMPARE(v4.z(), (qreal)8.0f);
QCOMPARE(v4.w(), (qreal)9.0f); QCOMPARE(v4.w(), (qreal)9.0f);
obj.setProperty("vector2D", obj.setProperty("vector2D",
qVariantFromValue(QVector2D(-1.0f, -2.0f))); QVariant::fromValue(QVector2D(-1.0f, -2.0f)));
obj.setProperty("vector3D", obj.setProperty("vector3D",
qVariantFromValue(QVector3D(-3.0f, -4.0f, -5.0f))); QVariant::fromValue(QVector3D(-3.0f, -4.0f, -5.0f)));
obj.setProperty("vector4D", 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.x(), (qreal)-1.0f);
QCOMPARE(v2.y(), (qreal)-2.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.x(), (qreal)-3.0f);
QCOMPARE(v3.y(), (qreal)-4.0f); QCOMPARE(v3.y(), (qreal)-4.0f);
QCOMPARE(v3.z(), (qreal)-5.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.x(), (qreal)-6.0f);
QCOMPARE(v4.y(), (qreal)-7.0f); QCOMPARE(v4.y(), (qreal)-7.0f);
QCOMPARE(v4.z(), (qreal)-8.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.setName("a");
cookie.setValue("b"); cookie.setValue("b");
QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie" << true << "Cookie"
<< "a=b"; << "a=b";
QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie" << true << "Set-Cookie"
<< "a=b"; << "a=b";
cookie.setPath("/"); cookie.setPath("/");
QTest::newRow("Cookie-2") << QNetworkRequest::CookieHeader QTest::newRow("Cookie-2") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie" << true << "Cookie"
<< "a=b"; << "a=b";
QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie" << true << "Set-Cookie"
<< "a=b; path=/"; << "a=b; path=/";
@ -304,11 +304,11 @@ void tst_QNetworkRequest::setHeader_data()
cookie2.setName("c"); cookie2.setName("c");
cookie2.setValue("d"); cookie2.setValue("d");
QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2) << QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Cookie" << true << "Cookie"
<< "a=b; c=d"; << "a=b; c=d";
QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2) << QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Set-Cookie" << true << "Set-Cookie"
<< "a=b; path=/, c=d"; << "a=b; path=/, c=d";
} }
@ -388,17 +388,17 @@ void tst_QNetworkRequest::rawHeaderParsing_data()
cookie.setName("a"); cookie.setName("a");
cookie.setValue("b"); cookie.setValue("b");
QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie" << true << "Cookie"
<< "a=b"; << "a=b";
QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie" << true << "Set-Cookie"
<< "a=b"; << "a=b";
cookie.setPath("/"); cookie.setPath("/");
QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie) << QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie" << true << "Set-Cookie"
<< "a=b; path=/"; << "a=b; path=/";
@ -407,12 +407,12 @@ void tst_QNetworkRequest::rawHeaderParsing_data()
cookie2.setName("c"); cookie2.setName("c");
cookie2.setValue("d"); cookie2.setValue("d");
QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2) << QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Cookie" << true << "Cookie"
<< "a=b; c=d"; << "a=b; c=d";
cookie.setPath("/"); cookie.setPath("/");
QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
<< qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2) << QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Set-Cookie" << true << "Set-Cookie"
<< "a=b; path=/, c=d"; << "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); QVERIFY(socket->error() != QLocalSocket::UnknownSocketError);
QCOMPARE(socket->state(), QLocalSocket::UnconnectedState); QCOMPARE(socket->state(), QLocalSocket::UnconnectedState);
//QVERIFY(socket->socketDescriptor() == -1); //QVERIFY(socket->socketDescriptor() == -1);
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]), QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QLocalSocket::ServerNotFoundError); QLocalSocket::ServerNotFoundError);
} }
@ -403,19 +403,19 @@ void tst_QLocalSocket::listenAndConnect()
QVERIFY(spyError.count() >= 0); QVERIFY(spyError.count() >= 0);
if (canListen) { if (canListen) {
if (spyError.count() > 0) if (spyError.count() > 0)
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]), QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QLocalSocket::SocketTimeoutError); QLocalSocket::SocketTimeoutError);
} else { } else {
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]), QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
QLocalSocket::ServerNotFoundError); QLocalSocket::ServerNotFoundError);
} }
// Check first and last state // Check first and last state
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.first()[0]), QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketState>(spyStateChanged.first()[0]),
QLocalSocket::ConnectingState); QLocalSocket::ConnectingState);
if (canListen) if (canListen)
QCOMPARE(qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.last()[0]), QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketState>(spyStateChanged.last()[0]),
QLocalSocket::ConnectedState); QLocalSocket::ConnectedState);
QCOMPARE(spyStateChanged.count(), 2); QCOMPARE(spyStateChanged.count(), 2);
QCOMPARE(spyReadyRead.count(), 0); QCOMPARE(spyReadyRead.count(), 0);

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

@ -130,7 +130,7 @@ private slots:
{ {
QTcpSocket *client = nextPendingConnection(); QTcpSocket *client = nextPendingConnection();
connect(client, SIGNAL(readyRead()), SLOT(handleClientCommand())); connect(client, SIGNAL(readyRead()), SLOT(handleClientCommand()));
client->setProperty("pendingResponses", qVariantFromValue(responses)); client->setProperty("pendingResponses", QVariant::fromValue(responses));
} }
void handleClientCommand() void handleClientCommand()
@ -145,7 +145,7 @@ private slots:
client->disconnectFromHost(); client->disconnectFromHost();
else else
client->write(pendingResponses.dequeue()); 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(socket->error(), QAbstractSocket::ConnectionRefusedError);
QCOMPARE(stateSpy.count(), 3); QCOMPARE(stateSpy.count(), 3);
QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState); QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState);
QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(1).at(0)), QAbstractSocket::ConnectingState); QCOMPARE(qvariant_cast<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(2).at(0)), QAbstractSocket::UnconnectedState);
QCOMPARE(errorSpy.count(), 1); QCOMPARE(errorSpy.count(), 1);
delete socket; 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(!socket->waitForEncrypted(10000));
QVERIFY(!peerVerifyErrorSpy.isEmpty()); QVERIFY(!peerVerifyErrorSpy.isEmpty());
QVERIFY(!sslErrorsSpy.isEmpty()); QVERIFY(!sslErrorsSpy.isEmpty());
QCOMPARE(qVariantValue<QSslError>(peerVerifyErrorSpy.last().at(0)).error(), QSslError::HostNameMismatch); QCOMPARE(qvariant_cast<QSslError>(peerVerifyErrorSpy.last().at(0)).error(), QSslError::HostNameMismatch);
QCOMPARE(qVariantValue<QList<QSslError> >(sslErrorsSpy.at(0).at(0)).size(), peerVerifyErrorSpy.size()); QCOMPARE(qvariant_cast<QList<QSslError> >(sslErrorsSpy.at(0).at(0)).size(), peerVerifyErrorSpy.size());
} }
void tst_QSslSocket::disconnectFromHostWhenConnecting() 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 // General Purpose roles that should return a QString
QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole ); QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole );
if ( variant.isValid() ) { if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QString> ( variant ) ); QVERIFY( variant.canConvert<QString>() );
} }
variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole ); variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );
if ( variant.isValid() ) { if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QString> ( variant ) ); QVERIFY( variant.canConvert<QString>() );
} }
variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole ); variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );
if ( variant.isValid() ) { if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QString> ( variant ) ); QVERIFY( variant.canConvert<QString>() );
} }
// General Purpose roles that should return a QSize // General Purpose roles that should return a QSize
variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole ); variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );
if ( variant.isValid() ) { if ( variant.isValid() ) {
QVERIFY( qVariantCanConvert<QSize> ( variant ) ); QVERIFY( variant.canConvert<QSize>() );
} }
// General Purpose roles that should return a QFont // General Purpose roles that should return a QFont
QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole ); QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole );
if ( fontVariant.isValid() ) { if ( fontVariant.isValid() ) {
QVERIFY( qVariantCanConvert<QFont> ( fontVariant ) ); QVERIFY( fontVariant.canConvert<QFont>() );
} }
// Check that the alignment is one we know about // Check that the alignment is one we know about
@ -447,12 +447,12 @@ void ModelTest::data()
// General Purpose roles that should return a QColor // General Purpose roles that should return a QColor
QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole ); QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole );
if ( colorVariant.isValid() ) { if ( colorVariant.isValid() ) {
QVERIFY( qVariantCanConvert<QColor> ( colorVariant ) ); QVERIFY( colorVariant.canConvert<QColor>() );
} }
colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole ); colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );
if ( colorVariant.isValid() ) { if ( colorVariant.isValid() ) {
QVERIFY( qVariantCanConvert<QColor> ( colorVariant ) ); QVERIFY( colorVariant.canConvert<QColor>() );
} }
// Check that the "check state" is one we know about. // 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); QCOMPARE(spy.count(), 1);
QList<QVariant> arguments = spy.takeFirst(); QList<QVariant> arguments = spy.takeFirst();
QCOMPARE(arguments.at(0).toString(), procedureName); 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); QCOMPARE(qvariant_cast<QVariant>(arguments.at(2)).toString(), payload);
QVERIFY_SQL(driver, unsubscribeFromNotification(procedureName)); 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); q.bindValue(":outp", outLst, QSql::Out);
QVERIFY_SQL(q, execBatch(QSqlQuery::ValuesAsColumns) ); 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[0].toString(), QLatin1String("1. Value is 0"));
QCOMPARE(res_outLst[1].toString(), QLatin1String("2. Value is 1")); QCOMPARE(res_outLst[1].toString(), QLatin1String("2. Value is 1"));
QCOMPARE(res_outLst[2].toString(), QLatin1String("3. Value is 2")); 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"); QByteArray ba = QByteArray("points");
QVariant v = tst.property(ba); QVariant v = tst.property(ba);
QVERIFY(v.isValid()); QVERIFY(v.isValid());
myNS::Points p = qVariantValue<myNS::Points>(v); myNS::Points p = qvariant_cast<myNS::Points>(v);
QCOMPARE(p.p1, 0xBEEF); QCOMPARE(p.p1, 0xBEEF);
QCOMPARE(p.p2, 0xBABE); QCOMPARE(p.p2, 0xBABE);
p.p1 = 0xCAFE; p.p1 = 0xCAFE;
p.p2 = 0x1EE7; p.p2 = 0x1EE7;
QVERIFY(tst.setProperty(ba, qVariantFromValue(p))); QVERIFY(tst.setProperty(ba, QVariant::fromValue(p)));
myNS::Points pp = qVariantValue<myNS::Points>(tst.property(ba)); myNS::Points pp = qvariant_cast<myNS::Points>(tst.property(ba));
QCOMPARE(p.p1, pp.p1); QCOMPARE(p.p1, pp.p1);
QCOMPARE(p.p2, pp.p2); QCOMPARE(p.p2, pp.p2);
} }
@ -1181,16 +1181,16 @@ void tst_Moc::qprivateproperties()
PrivatePropertyTest test; PrivatePropertyTest test;
test.setProperty("foo", 1); test.setProperty("foo", 1);
QCOMPARE(test.property("foo"), qVariantFromValue(1)); QCOMPARE(test.property("foo"), QVariant::fromValue(1));
test.setProperty("bar", 2); test.setProperty("bar", 2);
QCOMPARE(test.property("bar"), qVariantFromValue(2)); QCOMPARE(test.property("bar"), QVariant::fromValue(2));
test.setProperty("plop", 3); test.setProperty("plop", 3);
QCOMPARE(test.property("plop"), qVariantFromValue(3)); QCOMPARE(test.property("plop"), QVariant::fromValue(3));
test.setProperty("baz", 4); 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(backButton->isEnabled(), true);
QCOMPARE(forwardButton->isEnabled(), true); QCOMPARE(forwardButton->isEnabled(), true);
QCOMPARE(spy.count(), 3); 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)); QCOMPARE(model->index(currentPath), model->index(temp));
backButton->click(); backButton->click();
currentPath = qVariantValue<QString>(spy.last().first()); currentPath = qvariant_cast<QString>(spy.last().first());
QCOMPARE(currentPath, home); QCOMPARE(currentPath, home);
QCOMPARE(backButton->isEnabled(), false); QCOMPARE(backButton->isEnabled(), false);
QCOMPARE(forwardButton->isEnabled(), true); QCOMPARE(forwardButton->isEnabled(), true);
@ -1101,39 +1101,39 @@ void tst_QFiledialog::historyForward()
backButton->click(); backButton->click();
QCOMPARE(forwardButton->isEnabled(), true); 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(); 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(backButton->isEnabled(), true);
QCOMPARE(forwardButton->isEnabled(), false); QCOMPARE(forwardButton->isEnabled(), false);
QCOMPARE(spy.count(), 4); QCOMPARE(spy.count(), 4);
backButton->click(); 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); QCOMPARE(backButton->isEnabled(), true);
backButton->click(); 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(backButton->isEnabled(), false);
QCOMPARE(forwardButton->isEnabled(), true); QCOMPARE(forwardButton->isEnabled(), true);
QCOMPARE(spy.count(), 6); QCOMPARE(spy.count(), 6);
forwardButton->click(); 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(); 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); QCOMPARE(spy.count(), 8);
forwardButton->click(); 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(); 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(); 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(); 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); fd.setDirectory(desktop);
QCOMPARE(forwardButton->isEnabled(), false); 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(); QApplication::instance()->processEvents();
QCOMPARE(spy.count(), 3); 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.size(), 3);
QCOMPARE(rlist.at(0), rotatedRect); // From item.setMatrix() (clearing rotated rect) QCOMPARE(rlist.at(0), rotatedRect); // From item.setMatrix() (clearing rotated rect)
@ -4450,13 +4450,13 @@ protected:
break; break;
case QGraphicsItem::ItemMatrixChange: { case QGraphicsItem::ItemMatrixChange: {
QVariant variant; QVariant variant;
qVariantSetValue<QMatrix>(variant, matrix()); variant.setValue<QMatrix>(matrix());
oldValues << variant; oldValues << variant;
} }
break; break;
case QGraphicsItem::ItemTransformChange: { case QGraphicsItem::ItemTransformChange: {
QVariant variant; QVariant variant;
qVariantSetValue<QTransform>(variant, transform()); variant.setValue<QTransform>(transform());
oldValues << variant; oldValues << variant;
} }
break; break;
@ -4478,7 +4478,7 @@ protected:
case QGraphicsItem::ItemSelectedHasChanged: case QGraphicsItem::ItemSelectedHasChanged:
break; break;
case QGraphicsItem::ItemParentChange: case QGraphicsItem::ItemParentChange:
oldValues << qVariantFromValue<void *>(parentItem()); oldValues << QVariant::fromValue<void *>(parentItem());
break; break;
case QGraphicsItem::ItemParentHasChanged: case QGraphicsItem::ItemParentHasChanged:
break; break;
@ -4489,11 +4489,11 @@ protected:
oldValues << children().size(); oldValues << children().size();
break; break;
case QGraphicsItem::ItemSceneChange: case QGraphicsItem::ItemSceneChange:
oldValues << qVariantFromValue<QGraphicsScene *>(scene()); oldValues << QVariant::fromValue<QGraphicsScene *>(scene());
if (itemSceneChangeTargetScene if (itemSceneChangeTargetScene
&& qVariantValue<QGraphicsScene *>(value) && qvariant_cast<QGraphicsScene *>(value)
&& itemSceneChangeTargetScene != qVariantValue<QGraphicsScene *>(value)) { && itemSceneChangeTargetScene != qvariant_cast<QGraphicsScene *>(value)) {
return qVariantFromValue<QGraphicsScene *>(itemSceneChangeTargetScene); return QVariant::fromValue<QGraphicsScene *>(itemSceneChangeTargetScene);
} }
return value; return value;
case QGraphicsItem::ItemSceneHasChanged: case QGraphicsItem::ItemSceneHasChanged:
@ -4573,17 +4573,17 @@ void tst_QGraphicsItem::itemChange()
} }
{ {
// ItemMatrixChange / ItemTransformHasChanged // ItemMatrixChange / ItemTransformHasChanged
qVariantSetValue<QMatrix>(tester.itemChangeReturnValue, QMatrix().rotate(90)); tester.itemChangeReturnValue.setValue<QMatrix>(QMatrix().rotate(90));
tester.setMatrix(QMatrix().translate(50, 0), true); tester.setMatrix(QMatrix().translate(50, 0), true);
++changeCount; // notification sent too ++changeCount; // notification sent too
QCOMPARE(tester.changes.size(), ++changeCount); QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(int(tester.changes.at(tester.changes.size() - 2)), int(QGraphicsItem::ItemMatrixChange)); QCOMPARE(int(tester.changes.at(tester.changes.size() - 2)), int(QGraphicsItem::ItemMatrixChange));
QCOMPARE(int(tester.changes.last()), int(QGraphicsItem::ItemTransformHasChanged)); 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)); QMatrix().translate(50, 0));
QCOMPARE(tester.values.last(), QVariant(QTransform(QMatrix().rotate(90)))); QCOMPARE(tester.values.last(), QVariant(QTransform(QMatrix().rotate(90))));
QVariant variant; QVariant variant;
qVariantSetValue<QMatrix>(variant, QMatrix()); variant.setValue<QMatrix>(QMatrix());
QCOMPARE(tester.oldValues.last(), variant); QCOMPARE(tester.oldValues.last(), variant);
QCOMPARE(tester.matrix(), QMatrix().rotate(90)); QCOMPARE(tester.matrix(), QMatrix().rotate(90));
} }
@ -4593,19 +4593,19 @@ void tst_QGraphicsItem::itemChange()
++changeCount; // notification sent too ++changeCount; // notification sent too
// ItemTransformChange / ItemTransformHasChanged // ItemTransformChange / ItemTransformHasChanged
qVariantSetValue<QTransform>(tester.itemChangeReturnValue, QTransform().rotate(90)); tester.itemChangeReturnValue.setValue<QTransform>(QTransform().rotate(90));
tester.translate(50, 0); tester.translate(50, 0);
++changeCount; // notification sent too ++changeCount; // notification sent too
++changeCount; ++changeCount;
QCOMPARE(tester.changes.size(), changeCount); QCOMPARE(tester.changes.size(), changeCount);
QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemTransformChange); QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemTransformChange);
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemTransformHasChanged); 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)); 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)); QTransform().rotate(90));
QVariant variant; QVariant variant;
qVariantSetValue<QTransform>(variant, QTransform()); variant.setValue<QTransform>(QTransform());
QCOMPARE(tester.oldValues.last(), variant); QCOMPARE(tester.oldValues.last(), variant);
QCOMPARE(tester.transform(), QTransform().rotate(90)); QCOMPARE(tester.transform(), QTransform().rotate(90));
} }
@ -4690,9 +4690,9 @@ void tst_QGraphicsItem::itemChange()
QCOMPARE(tester.changes.size(), changeCount); QCOMPARE(tester.changes.size(), changeCount);
QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemFlagsChange); QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemFlagsChange);
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemFlagsHaveChanged); 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() - 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 // ItemSelectedChange
@ -4739,12 +4739,12 @@ void tst_QGraphicsItem::itemChange()
} }
{ {
// ItemParentChange // ItemParentChange
qVariantSetValue<QGraphicsItem *>(tester.itemChangeReturnValue, 0); tester.itemChangeReturnValue.setValue<QGraphicsItem *>(0);
tester.setParentItem(&testerHelper); tester.setParentItem(&testerHelper);
QCOMPARE(tester.changes.size(), ++changeCount); QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(tester.changes.last(), QGraphicsItem::ItemParentChange); QCOMPARE(tester.changes.last(), QGraphicsItem::ItemParentChange);
QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper); QCOMPARE(qvariant_cast<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
QCOMPARE(qVariantValue<QGraphicsItem *>(tester.oldValues.last()), (QGraphicsItem *)0); QCOMPARE(qvariant_cast<QGraphicsItem *>(tester.oldValues.last()), (QGraphicsItem *)0);
QCOMPARE(tester.parentItem(), (QGraphicsItem *)0); QCOMPARE(tester.parentItem(), (QGraphicsItem *)0);
} }
{ {
@ -4771,14 +4771,14 @@ void tst_QGraphicsItem::itemChange()
testerHelper.setParentItem(&tester); testerHelper.setParentItem(&tester);
QCOMPARE(tester.changes.size(), ++changeCount); QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(tester.changes.last(), QGraphicsItem::ItemChildAddedChange); 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 // ItemChildRemovedChange 1
testerHelper.setParentItem(0); testerHelper.setParentItem(0);
QCOMPARE(tester.changes.size(), ++changeCount); QCOMPARE(tester.changes.size(), ++changeCount);
QCOMPARE(tester.changes.last(), QGraphicsItem::ItemChildRemovedChange); 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 // ItemChildRemovedChange 1
ItemChangeTester *test = new ItemChangeTester; ItemChangeTester *test = new ItemChangeTester;
@ -4819,10 +4819,10 @@ void tst_QGraphicsItem::itemChange()
ItemChangeTester *child = new ItemChangeTester; ItemChangeTester *child = new ItemChangeTester;
child->setParentItem(&parent); child->setParentItem(&parent);
QCOMPARE(parent.changes.last(), QGraphicsItem::ItemChildAddedChange); 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; delete child;
QCOMPARE(parent.changes.last(), QGraphicsItem::ItemChildRemovedChange); 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 // !!! 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); QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
// Item's old value was 0 // Item's old value was 0
// Item's current value is scene // Item's current value is scene
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene);
scene2.addItem(&tester); scene2.addItem(&tester);
++changeCount; // ItemSceneChange (0) was: (scene) ++changeCount; // ItemSceneChange (0) was: (scene)
++changeCount; // ItemSceneHasChanged (0) ++changeCount; // ItemSceneHasChanged (0)
@ -4858,16 +4858,16 @@ void tst_QGraphicsItem::itemChange()
// Item's last old value was scene // Item's last old value was scene
// Item's last current value is 0 // Item's last current value is 0
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 2)), (QGraphicsScene *)&scene); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 2)), (QGraphicsScene *)&scene);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 1)), (QGraphicsScene *)0); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 1)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 4)), (QGraphicsScene *)0); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 4)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)0); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene2); QCOMPARE(qvariant_cast<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.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene2);
// Item's last old value was 0 // Item's last old value was 0
// Item's last current value is scene2 // Item's last current value is scene2
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene2); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene2);
scene2.removeItem(&tester); scene2.removeItem(&tester);
++changeCount; // ItemSceneChange (0) was: (scene2) ++changeCount; // ItemSceneChange (0) was: (scene2)
@ -4879,9 +4879,9 @@ void tst_QGraphicsItem::itemChange()
QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged); QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
// Item's last old value was scene2 // Item's last old value was scene2
// Item's last current value is 0 // Item's last current value is 0
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)&scene2); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)&scene2);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)0); QCOMPARE(qvariant_cast<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.values.at(tester.values.size() - 1)), (QGraphicsScene *)0);
tester.itemSceneChangeTargetScene = &scene; tester.itemSceneChangeTargetScene = &scene;
scene2.addItem(&tester); scene2.addItem(&tester);
@ -4890,9 +4890,9 @@ void tst_QGraphicsItem::itemChange()
++changeCount; // ItemSceneHasChanged (scene) ++changeCount; // ItemSceneHasChanged (scene)
QCOMPARE(tester.values.size(), changeCount); QCOMPARE(tester.values.size(), changeCount);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)&scene2); QCOMPARE(qvariant_cast<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)&scene2);
QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene); QCOMPARE(qvariant_cast<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() - 1)), (QGraphicsScene *)&scene);
QCOMPARE(tester.scene(), &scene); QCOMPARE(tester.scene(), &scene);
tester.itemSceneChangeTargetScene = 0; 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 // Check that the update region is correct
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QRectF region; 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; region |= rectF;
QCOMPARE(region, QRectF(-100, -100, 200, 200)); 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; break;
} }
case QEvent::ParentAboutToChange: { case QEvent::ParentAboutToChange: {
valueDuringEvents.insert(QEvent::ParentAboutToChange, qVariantFromValue(parentItem())); valueDuringEvents.insert(QEvent::ParentAboutToChange, QVariant::fromValue(parentItem()));
break; break;
} }
case QEvent::ParentChange: { case QEvent::ParentChange: {
valueDuringEvents.insert(QEvent::ParentChange, qVariantFromValue(parentItem())); valueDuringEvents.insert(QEvent::ParentChange, QVariant::fromValue(parentItem()));
break; break;
} }
case QEvent::CursorChange: { case QEvent::CursorChange: {
@ -3252,10 +3252,10 @@ void tst_QGraphicsWidget::itemChangeEvents()
TestGraphicsWidget *item = new TestGraphicsWidget; TestGraphicsWidget *item = new TestGraphicsWidget;
item->setParentItem(parent); item->setParentItem(parent);
// ParentAboutToChange should be triggered before the parent has changed // 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)); static_cast<QGraphicsItem *>(0));
// ParentChange should be triggered after the parent has changed // 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)); static_cast<QGraphicsItem *>(parent));
// ShowEvent should be triggered before the item is shown // 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) QApplication::setActiveWindow(&parent1); // needs this on twm (focus follows mouse)
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).count(), 2); QCOMPARE(spy.at(0).count(), 2);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le1); QVERIFY(now == &le1);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == 0); QVERIFY(old == 0);
@ -1476,8 +1476,8 @@ void tst_QApplication::focusChanged()
pb1.setFocus(); pb1.setFocus();
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb1); QVERIFY(now == &pb1);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le1); QVERIFY(old == &le1);
@ -1485,8 +1485,8 @@ void tst_QApplication::focusChanged()
lb1.setFocus(); lb1.setFocus();
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &lb1); QVERIFY(now == &lb1);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb1); QVERIFY(old == &pb1);
@ -1494,8 +1494,8 @@ void tst_QApplication::focusChanged()
lb1.clearFocus(); lb1.clearFocus();
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == 0); QVERIFY(now == 0);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &lb1); QVERIFY(old == &lb1);
@ -1513,8 +1513,8 @@ void tst_QApplication::focusChanged()
parent2.show(); parent2.show();
QApplication::setActiveWindow(&parent2); // needs this on twm (focus follows mouse) QApplication::setActiveWindow(&parent2); // needs this on twm (focus follows mouse)
QVERIFY(spy.count() > 0); // one for deactivation, one for activation on Windows QVERIFY(spy.count() > 0); // one for deactivation, one for activation on Windows
old = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(0)); old = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(0));
now = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(1)); now = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(1));
QVERIFY(now == &le2); QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == 0); QVERIFY(old == 0);
@ -1547,8 +1547,8 @@ void tst_QApplication::focusChanged()
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
} else { } else {
QVERIFY(spy.count() > 0); QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb2); QVERIFY(now == &pb2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2); QVERIFY(old == &le2);
@ -1561,8 +1561,8 @@ void tst_QApplication::focusChanged()
} else { } else {
tab.simulate(now); tab.simulate(now);
QVERIFY(spy.count() > 0); QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le2); QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb2); QVERIFY(old == &pb2);
@ -1575,8 +1575,8 @@ void tst_QApplication::focusChanged()
} else { } else {
backtab.simulate(now); backtab.simulate(now);
QVERIFY(spy.count() > 0); QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb2); QVERIFY(now == &pb2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2); QVERIFY(old == &le2);
@ -1591,8 +1591,8 @@ void tst_QApplication::focusChanged()
} else { } else {
backtab.simulate(now); backtab.simulate(now);
QVERIFY(spy.count() > 0); QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le2); QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb2); QVERIFY(old == &pb2);
@ -1605,8 +1605,8 @@ void tst_QApplication::focusChanged()
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
} else { } else {
QVERIFY(spy.count() > 0); QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &pb2); QVERIFY(now == &pb2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2); QVERIFY(old == &le2);
@ -1614,8 +1614,8 @@ void tst_QApplication::focusChanged()
click.simulate(old); click.simulate(old);
QVERIFY(spy.count() > 0); QVERIFY(spy.count() > 0);
old = qVariantValue<QWidget*>(spy.at(0).at(0)); old = qvariant_cast<QWidget*>(spy.at(0).at(0));
now = qVariantValue<QWidget*>(spy.at(0).at(1)); now = qvariant_cast<QWidget*>(spy.at(0).at(1));
QVERIFY(now == &le2); QVERIFY(now == &le2);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &pb2); QVERIFY(old == &pb2);
@ -1629,10 +1629,10 @@ void tst_QApplication::focusChanged()
//on windows, the change of focus is made in 2 steps //on windows, the change of focus is made in 2 steps
//(the focusChanged SIGNAL is emitted twice) //(the focusChanged SIGNAL is emitted twice)
if (spy.count()==1) 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 else
old = qVariantValue<QWidget*>(spy.at(spy.count()-2).at(0)); old = qvariant_cast<QWidget*>(spy.at(spy.count()-2).at(0));
now = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(1)); now = qvariant_cast<QWidget*>(spy.at(spy.count()-1).at(1));
QVERIFY(now == &le1); QVERIFY(now == &le1);
QVERIFY(now == QApplication::focusWidget()); QVERIFY(now == QApplication::focusWidget());
QVERIFY(old == &le2); 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) { if (timesEmitted > 0) {
QList<QVariant> list = dateSpy.takeFirst(); QList<QVariant> list = dateSpy.takeFirst();
QDate d; QDate d;
d = qVariantValue<QDate>(list.at(0)); d = qvariant_cast<QDate>(list.at(0));
QCOMPARE(d, newDate); QCOMPARE(d, newDate);
} }
QCOMPARE(dateTimeSpy.count(), timesEmitted); QCOMPARE(dateTimeSpy.count(), timesEmitted);
@ -2085,7 +2085,7 @@ void tst_QDateTimeEdit::timeSignalChecking()
if (timesEmitted > 0) { if (timesEmitted > 0) {
QList<QVariant> list = timeSpy.takeFirst(); QList<QVariant> list = timeSpy.takeFirst();
QTime t; QTime t;
t = qVariantValue<QTime>(list.at(0)); t = qvariant_cast<QTime>(list.at(0));
QCOMPARE(t, newTime); QCOMPARE(t, newTime);
} }
QCOMPARE(dateTimeSpy.count(), timesEmitted); QCOMPARE(dateTimeSpy.count(), timesEmitted);
@ -2135,21 +2135,21 @@ void tst_QDateTimeEdit::dateTimeSignalChecking()
QCOMPARE(timesDateEmitted, 1); QCOMPARE(timesDateEmitted, 1);
QList<QVariant> list = dateSpy.takeFirst(); QList<QVariant> list = dateSpy.takeFirst();
QDate d; QDate d;
d = qVariantValue<QDate>(list.at(0)); d = qvariant_cast<QDate>(list.at(0));
QCOMPARE(d, newDateTime.date()); QCOMPARE(d, newDateTime.date());
} }
QCOMPARE(timeSpy.count(), timesTimeEmitted); QCOMPARE(timeSpy.count(), timesTimeEmitted);
if (timesTimeEmitted > 0) { if (timesTimeEmitted > 0) {
QList<QVariant> list = timeSpy.takeFirst(); QList<QVariant> list = timeSpy.takeFirst();
QTime t; QTime t;
t = qVariantValue<QTime>(list.at(0)); t = qvariant_cast<QTime>(list.at(0));
QCOMPARE(t, newDateTime.time()); QCOMPARE(t, newDateTime.time());
} }
QCOMPARE(dateTimeSpy.count(), timesDateTimeEmitted); QCOMPARE(dateTimeSpy.count(), timesDateTimeEmitted);
if (timesDateTimeEmitted > 0) { if (timesDateTimeEmitted > 0) {
QList<QVariant> list = dateTimeSpy.takeFirst(); QList<QVariant> list = dateTimeSpy.takeFirst();
QDateTime dt; QDateTime dt;
dt = qVariantValue<QDateTime>(list.at(0)); dt = qvariant_cast<QDateTime>(list.at(0));
QCOMPARE(dt, newDateTime); 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; QVariant v;
QBENCHMARK { QBENCHMARK {
for(int i = 0; i < ITERATION_COUNT; ++i) { 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'); QByteArray ba(256, 'a');
while (ba.size() < 8193) { 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; ba += ba;
} }
QString s(256, QLatin1Char('a')); QString s(256, QLatin1Char('a'));
while (s.size() < 8193) { 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; s += s;
} }
} }
@ -197,7 +197,7 @@ void tst_QDBusPerformance::oneWayVariant()
QFETCH(QVariant, data); QFETCH(QVariant, data);
QFETCH(int, size); QFETCH(int, size);
QVERIFY(executeTest("size", size, qVariantFromValue(QDBusVariant(data)))); QVERIFY(executeTest("size", size, QVariant::fromValue(QDBusVariant(data))));
} }
void tst_QDBusPerformance::roundTrip_data() void tst_QDBusPerformance::roundTrip_data()
@ -223,7 +223,7 @@ void tst_QDBusPerformance::roundTripVariant()
QFETCH(QVariant, data); QFETCH(QVariant, data);
QFETCH(int, size); QFETCH(int, size);
QVERIFY(executeTest("echo", size, qVariantFromValue(QDBusVariant(data)))); QVERIFY(executeTest("echo", size, QVariant::fromValue(QDBusVariant(data))));
} }
QTEST_MAIN(tst_QDBusPerformance) QTEST_MAIN(tst_QDBusPerformance)

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

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