1 files changed, 573 insertions, 0 deletions

diff --git a/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp b/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
index e8ce1f9..6f93d8a 100644
--- a/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
+++ b/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
@@ -49,6 +49,10 @@
 #include "interface.h"
 #include "pinger.h"
 
+static const char serviceName[] = "com.trolltech.autotests.qpinger";
+static const char objectPath[] = "/com/trolltech/qpinger";
+static const char *interfaceName = serviceName;
+
 typedef QSharedPointer<com::trolltech::QtDBus::Pinger> Pinger;
 
 class tst_QDBusAbstractInterface: public QObject
@@ -66,22 +70,47 @@ class tst_QDBusAbstractInterface: public QObject
         return Pinger(new com::trolltech::QtDBus::Pinger(service, path, con));
     }
 
+    Pinger getPingerPeer(const QString &path = "/")
+    {
+        QDBusConnection con = QDBusConnection("peer");
+        if (!con.isConnected())
+            return Pinger();
+        return Pinger(new com::trolltech::QtDBus::Pinger("", path, con));
+    }
+
+    void resetServer()
+    {
+        QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "reset");
+        QDBusConnection::sessionBus().send(req);
+    }
+
 public:
     tst_QDBusAbstractInterface();
 
 private slots:
     void initTestCase();
+    void cleanupTestCase();
 
     void makeVoidCall();
     void makeStringCall();
     void makeComplexCall();
     void makeMultiOutCall();
 
+    void makeVoidCallPeer();
+    void makeStringCallPeer();
+    void makeComplexCallPeer();
+    void makeMultiOutCallPeer();
+
     void makeAsyncVoidCall();
     void makeAsyncStringCall();
     void makeAsyncComplexCall();
     void makeAsyncMultiOutCall();
 
+    void makeAsyncVoidCallPeer();
+    void makeAsyncStringCallPeer();
+    void makeAsyncComplexCallPeer();
+    void makeAsyncMultiOutCallPeer();
+
     void stringPropRead();
     void stringPropWrite();
     void variantPropRead();
@@ -89,6 +118,13 @@ private slots:
     void complexPropRead();
     void complexPropWrite();
 
+    void stringPropReadPeer();
+    void stringPropWritePeer();
+    void variantPropReadPeer();
+    void variantPropWritePeer();
+    void complexPropReadPeer();
+    void complexPropWritePeer();
+
     void stringPropDirectRead();
     void stringPropDirectWrite();
     void variantPropDirectRead();
@@ -96,6 +132,13 @@ private slots:
     void complexPropDirectRead();
     void complexPropDirectWrite();
 
+    void stringPropDirectReadPeer();
+    void stringPropDirectWritePeer();
+    void variantPropDirectReadPeer();
+    void variantPropDirectWritePeer();
+    void complexPropDirectReadPeer();
+    void complexPropDirectWritePeer();
+
     void getVoidSignal_data();
     void getVoidSignal();
     void getStringSignal_data();
@@ -103,16 +146,31 @@ private slots:
     void getComplexSignal_data();
     void getComplexSignal();
 
+    void getVoidSignalPeer_data();
+    void getVoidSignalPeer();
+    void getStringSignalPeer_data();
+    void getStringSignalPeer();
+    void getComplexSignalPeer_data();
+    void getComplexSignalPeer();
+
     void followSignal();
 
     void createErrors_data();
     void createErrors();
 
+    void createErrorsPeer_data();
+    void createErrorsPeer();
+
     void callErrors_data();
     void callErrors();
     void asyncCallErrors_data();
     void asyncCallErrors();
 
+    void callErrorsPeer_data();
+    void callErrorsPeer();
+    void asyncCallErrorsPeer_data();
+    void asyncCallErrorsPeer();
+
     void propertyReadErrors_data();
     void propertyReadErrors();
     void propertyWriteErrors_data();
@@ -121,8 +179,53 @@ private slots:
     void directPropertyReadErrors();
     void directPropertyWriteErrors_data();
     void directPropertyWriteErrors();
+
+    void propertyReadErrorsPeer_data();
+    void propertyReadErrorsPeer();
+    void propertyWriteErrorsPeer_data();
+    void propertyWriteErrorsPeer();
+    void directPropertyReadErrorsPeer_data();
+    void directPropertyReadErrorsPeer();
+    void directPropertyWriteErrorsPeer_data();
+    void directPropertyWriteErrorsPeer();
+private:
+    QProcess proc;
+};
+
+class WaitForQPinger: public QObject
+{
+    Q_OBJECT
+public:
+    WaitForQPinger();
+    bool ok();
+public Q_SLOTS:
+    void ownerChange(const QString &name)
+    {
+        if (name == serviceName)
+            loop.quit();
+    }
+
+private:
+    QEventLoop loop;
 };
 
+WaitForQPinger::WaitForQPinger()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    if (!ok()) {
+        connect(con.interface(), SIGNAL(serviceOwnerChanged(QString,QString,QString)),
+                SLOT(ownerChange(QString)));
+        QTimer::singleShot(2000, &loop, SLOT(quit()));
+        loop.exec();
+    }
+}
+
+bool WaitForQPinger::ok()
+{
+    return QDBusConnection::sessionBus().isConnected() &&
+        QDBusConnection::sessionBus().interface()->isServiceRegistered(serviceName);
+}
+
 tst_QDBusAbstractInterface::tst_QDBusAbstractInterface()
 {
     // register the meta types
@@ -139,6 +242,39 @@ void tst_QDBusAbstractInterface::initTestCase()
     QDBusConnection con = QDBusConnection::sessionBus();
     QVERIFY(con.isConnected());
     con.registerObject("/", &targetObj, QDBusConnection::ExportScriptableContents);
+
+    // start peer server
+    #ifdef Q_OS_WIN
+    proc.start("qpinger");
+    #else
+    proc.start("./qpinger/qpinger");
+    #endif
+    QVERIFY(proc.waitForStarted());
+
+    WaitForQPinger w;
+    QVERIFY(w.ok());
+    //QTest::qWait(2000);
+
+    // get peer server address
+    QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "address");
+    QDBusMessage rpl = con.call(req);
+    QVERIFY(rpl.type() == QDBusMessage::ReplyMessage);
+    QString address = rpl.arguments().at(0).toString();
+
+    // connect to peer server
+    QDBusConnection peercon = QDBusConnection::connectToPeer(address, "peer");
+    QVERIFY(peercon.isConnected());
+
+    QDBusMessage req2 = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "isConnected");
+    QDBusMessage rpl2 = con.call(req2);
+    QVERIFY(rpl2.type() == QDBusMessage::ReplyMessage);
+    QVERIFY(rpl2.arguments().at(0).toBool());
+}
+
+void tst_QDBusAbstractInterface::cleanupTestCase()
+{
+    proc.close();
+    proc.kill();
 }
 
 void tst_QDBusAbstractInterface::makeVoidCall()
@@ -184,6 +320,49 @@ void tst_QDBusAbstractInterface::makeMultiOutCall()
     QCOMPARE(value, expectedValue);
 }
 
+void tst_QDBusAbstractInterface::makeVoidCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusReply<void> r = p->voidMethod();
+    QVERIFY(r.isValid());
+}
+
+void tst_QDBusAbstractInterface::makeStringCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusReply<QString> r = p->stringMethod();
+    QVERIFY(r.isValid());
+    QCOMPARE(r.value(), targetObj.stringMethod());
+}
+
+void tst_QDBusAbstractInterface::makeComplexCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusReply<RegisteredType> r = p->complexMethod();
+    QVERIFY(r.isValid());
+    QCOMPARE(r.value(), targetObj.complexMethod());
+}
+
+void tst_QDBusAbstractInterface::makeMultiOutCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    int value;
+    QDBusReply<QString> r = p->multiOutMethod(value);
+    QVERIFY(r.isValid());
+
+    int expectedValue;
+    QCOMPARE(r.value(), targetObj.multiOutMethod(expectedValue));
+    QCOMPARE(value, expectedValue);
+}
+
 void tst_QDBusAbstractInterface::makeAsyncVoidCall()
 {
     Pinger p = getPinger();
@@ -230,6 +409,55 @@ void tst_QDBusAbstractInterface::makeAsyncMultiOutCall()
     QCOMPARE(r.argumentAt<1>(), expectedValue);
 }
 
+void tst_QDBusAbstractInterface::makeAsyncVoidCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusPendingReply<void> r = p->voidMethod();
+    r.waitForFinished();
+    QVERIFY(r.isValid());
+}
+void tst_QDBusAbstractInterface::makeAsyncStringCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusMessage reply = p->call(QDBus::BlockWithGui, QLatin1String("voidMethod"));
+    QVERIFY(reply.type() == QDBusMessage::ReplyMessage);
+
+    QDBusPendingReply<QString> r = p->stringMethod();
+    r.waitForFinished();
+    QVERIFY(r.isValid());
+    QCOMPARE(r.value(), targetObj.stringMethod());
+}
+
+void tst_QDBusAbstractInterface::makeAsyncComplexCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusPendingReply<RegisteredType> r = p->complexMethod();
+    r.waitForFinished();
+    QVERIFY(r.isValid());
+    QCOMPARE(r.value(), targetObj.complexMethod());
+}
+
+void tst_QDBusAbstractInterface::makeAsyncMultiOutCallPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusPendingReply<QString, int> r = p->multiOutMethod();
+    r.waitForFinished();
+    QVERIFY(r.isValid());
+
+    int expectedValue;
+    QCOMPARE(r.value(), targetObj.multiOutMethod(expectedValue));
+    QCOMPARE(r.argumentAt<1>(), expectedValue);
+    QCoreApplication::instance()->processEvents();
+}
+
 void tst_QDBusAbstractInterface::stringPropRead()
 {
     Pinger p = getPinger();
@@ -295,6 +523,77 @@ void tst_QDBusAbstractInterface::complexPropWrite()
     QCOMPARE(targetObj.m_complexProp, expectedValue);
 }
 
+void tst_QDBusAbstractInterface::stringPropReadPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QString expectedValue = "This is a test";
+    QVariant v = p->property("stringProp");
+    QVERIFY(v.isValid());
+    QCOMPARE(v.toString(), expectedValue);
+}
+
+void tst_QDBusAbstractInterface::stringPropWritePeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QString expectedValue = "This is a value";
+    QVERIFY(p->setProperty("stringProp", expectedValue));
+    QCOMPARE(targetObj.m_stringProp, expectedValue);
+}
+
+void tst_QDBusAbstractInterface::variantPropReadPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QDBusVariant expectedValue = QDBusVariant(QVariant(42));
+    QVariant v = p->property("variantProp");
+    QVERIFY(v.isValid());
+    QDBusVariant value = v.value<QDBusVariant>();
+    QCOMPARE(value.variant().userType(), expectedValue.variant().userType());
+    QCOMPARE(value.variant(), expectedValue.variant());
+}
+
+void tst_QDBusAbstractInterface::variantPropWritePeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QDBusVariant expectedValue = QDBusVariant(Q_INT64_C(-47));
+    QVERIFY(p->setProperty("variantProp", qVariantFromValue(expectedValue)));
+    QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant());
+}
+
+void tst_QDBusAbstractInterface::complexPropReadPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    RegisteredType expectedValue = RegisteredType("This is a test");
+    QVariant v = p->property("complexProp");
+    QVERIFY(v.userType() == qMetaTypeId<RegisteredType>());
+    QCOMPARE(v.value<RegisteredType>(), expectedValue);
+}
+
+void tst_QDBusAbstractInterface::complexPropWritePeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    RegisteredType expectedValue = RegisteredType("This is a value");
+    QVERIFY(p->setProperty("complexProp", qVariantFromValue(expectedValue)));
+    QCOMPARE(targetObj.m_complexProp, expectedValue);
+}
+
 void tst_QDBusAbstractInterface::stringPropDirectRead()
 {
     Pinger p = getPinger();
@@ -353,6 +652,70 @@ void tst_QDBusAbstractInterface::complexPropDirectWrite()
     QCOMPARE(targetObj.m_complexProp, expectedValue);
 }
 
+void tst_QDBusAbstractInterface::stringPropDirectReadPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QString expectedValue = "This is a test";
+    QCOMPARE(p->stringProp(), expectedValue);
+}
+
+void tst_QDBusAbstractInterface::stringPropDirectWritePeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QString expectedValue = "This is a value";
+    p->setStringProp(expectedValue);
+    QCOMPARE(targetObj.m_stringProp, expectedValue);
+}
+
+void tst_QDBusAbstractInterface::variantPropDirectReadPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QDBusVariant expectedValue = QDBusVariant(42);
+    QCOMPARE(p->variantProp().variant(), expectedValue.variant());
+}
+
+void tst_QDBusAbstractInterface::variantPropDirectWritePeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    QDBusVariant expectedValue = QDBusVariant(Q_INT64_C(-47));
+    p->setVariantProp(expectedValue);
+    QCOMPARE(targetObj.m_variantProp.variant().userType(), expectedValue.variant().userType());
+    QCOMPARE(targetObj.m_variantProp.variant(), expectedValue.variant());
+}
+
+void tst_QDBusAbstractInterface::complexPropDirectReadPeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    RegisteredType expectedValue = RegisteredType("This is a test");
+    QCOMPARE(p->complexProp(), expectedValue);
+}
+
+void tst_QDBusAbstractInterface::complexPropDirectWritePeer()
+{
+    Pinger p = getPingerPeer();
+    QVERIFY2(p, "Not connected to D-Bus");
+    resetServer();
+
+    RegisteredType expectedValue = RegisteredType("This is a value");
+    p->setComplexProp(expectedValue);
+    QCOMPARE(targetObj.m_complexProp, expectedValue);
+}
+
 void tst_QDBusAbstractInterface::getVoidSignal_data()
 {
     QTest::addColumn<QString>("service");
@@ -437,6 +800,89 @@ void tst_QDBusAbstractInterface::getComplexSignal()
     QCOMPARE(s[0][0].value<RegisteredType>(), expectedValue);
 }
 
+void tst_QDBusAbstractInterface::getVoidSignalPeer_data()
+{
+    QTest::addColumn<QString>("path");
+
+    QTest::newRow("specific") << "/";
+    QTest::newRow("wildcard") << QString();
+}
+
+void tst_QDBusAbstractInterface::getVoidSignalPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we need to connect the signal somewhere in order for D-Bus to enable the rules
+    QTestEventLoop::instance().connect(p.data(), SIGNAL(voidSignal()), SLOT(exitLoop()));
+    QSignalSpy s(p.data(), SIGNAL(voidSignal()));
+
+    QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "voidSignal");
+    QVERIFY(QDBusConnection::sessionBus().send(req));
+    QTestEventLoop::instance().enterLoop(2);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QVERIFY(s.size() == 1);
+    QVERIFY(s.at(0).size() == 0);
+}
+
+void tst_QDBusAbstractInterface::getStringSignalPeer_data()
+{
+    getVoidSignalPeer_data();
+}
+
+void tst_QDBusAbstractInterface::getStringSignalPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we need to connect the signal somewhere in order for D-Bus to enable the rules
+    QTestEventLoop::instance().connect(p.data(), SIGNAL(stringSignal(QString)), SLOT(exitLoop()));
+    QSignalSpy s(p.data(), SIGNAL(stringSignal(QString)));
+
+    QString expectedValue = "Good morning";
+    QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "stringSignal");
+    req << expectedValue;
+    QVERIFY(QDBusConnection::sessionBus().send(req));
+    QTestEventLoop::instance().enterLoop(2);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QVERIFY(s.size() == 1);
+    QVERIFY(s[0].size() == 1);
+    QCOMPARE(s[0][0].userType(), int(QVariant::String));
+    QCOMPARE(s[0][0].toString(), expectedValue);
+}
+
+void tst_QDBusAbstractInterface::getComplexSignalPeer_data()
+{
+    getVoidSignalPeer_data();
+}
+
+void tst_QDBusAbstractInterface::getComplexSignalPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we need to connect the signal somewhere in order for D-Bus to enable the rules
+    QTestEventLoop::instance().connect(p.data(), SIGNAL(complexSignal(RegisteredType)), SLOT(exitLoop()));
+    QSignalSpy s(p.data(), SIGNAL(complexSignal(RegisteredType)));
+
+    RegisteredType expectedValue("Good evening");
+    QDBusMessage req = QDBusMessage::createMethodCall(serviceName, objectPath, interfaceName, "complexSignal");
+    req << "Good evening";
+    QVERIFY(QDBusConnection::sessionBus().send(req));
+    QTestEventLoop::instance().enterLoop(2);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QVERIFY(s.size() == 1);
+    QVERIFY(s[0].size() == 1);
+    QCOMPARE(s[0][0].userType(), qMetaTypeId<RegisteredType>());
+    QCOMPARE(s[0][0].value<RegisteredType>(), expectedValue);
+}
+
 void tst_QDBusAbstractInterface::followSignal()
 {
     const QString serviceToFollow = "com.trolltech.tst_qdbusabstractinterface.FollowMe";
@@ -514,6 +960,24 @@ void tst_QDBusAbstractInterface::createErrors()
     QTEST(p->lastError().name(), "errorName");
 }
 
+void tst_QDBusAbstractInterface::createErrorsPeer_data()
+{
+    QTest::addColumn<QString>("path");
+    QTest::addColumn<QString>("errorName");
+
+    QTest::newRow("invalid-path") << "this isn't valid" << "com.trolltech.QtDBus.Error.InvalidObjectPath";
+}
+
+void tst_QDBusAbstractInterface::createErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QVERIFY(!p->isValid());
+    QTEST(p->lastError().name(), "errorName");
+}
+
 void tst_QDBusAbstractInterface::callErrors_data()
 {
     createErrors_data();
@@ -556,6 +1020,43 @@ void tst_QDBusAbstractInterface::asyncCallErrors()
     QCOMPARE(p->lastError().name(), r.error().name());
 }
 
+void tst_QDBusAbstractInterface::callErrorsPeer_data()
+{
+    createErrorsPeer_data();
+    QTest::newRow("path-wildcard") << QString() << "com.trolltech.QtDBus.Error.InvalidObjectPath";
+}
+
+void tst_QDBusAbstractInterface::callErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we shouldn't be able to make this call:
+    QDBusReply<QString> r = p->stringMethod();
+    QVERIFY(!r.isValid());
+    QTEST(r.error().name(), "errorName");
+    QCOMPARE(p->lastError().name(), r.error().name());
+}
+
+void tst_QDBusAbstractInterface::asyncCallErrorsPeer_data()
+{
+    callErrorsPeer_data();
+}
+
+void tst_QDBusAbstractInterface::asyncCallErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we shouldn't be able to make this call:
+    QDBusPendingReply<QString> r = p->stringMethod();
+    QVERIFY(r.isError());
+    QTEST(r.error().name(), "errorName");
+    QCOMPARE(p->lastError().name(), r.error().name());
+}
+
 void tst_QDBusAbstractInterface::propertyReadErrors_data()
 {
     callErrors_data();
@@ -632,5 +1133,77 @@ void tst_QDBusAbstractInterface::directPropertyWriteErrors()
     QTEST(p->lastError().name(), "errorName");
 }
 
+void tst_QDBusAbstractInterface::propertyReadErrorsPeer_data()
+{
+    callErrorsPeer_data();
+}
+
+void tst_QDBusAbstractInterface::propertyReadErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we shouldn't be able to get this value:
+    QVariant v = p->property("stringProp");
+    QVERIFY(v.isNull());
+    QVERIFY(!v.isValid());
+    QTEST(p->lastError().name(), "errorName");
+}
+
+void tst_QDBusAbstractInterface::propertyWriteErrorsPeer_data()
+{
+    callErrorsPeer_data();
+}
+
+void tst_QDBusAbstractInterface::propertyWriteErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we shouldn't be able to get this value:
+    if (p->isValid())
+        QCOMPARE(int(p->lastError().type()), int(QDBusError::NoError));
+    QVERIFY(!p->setProperty("stringProp", ""));
+    QTEST(p->lastError().name(), "errorName");
+}
+
+void tst_QDBusAbstractInterface::directPropertyReadErrorsPeer_data()
+{
+    callErrorsPeer_data();
+}
+
+void tst_QDBusAbstractInterface::directPropertyReadErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we shouldn't be able to get this value:
+    QString v = p->stringProp();
+    QVERIFY(v.isNull());
+    QTEST(p->lastError().name(), "errorName");
+}
+
+void tst_QDBusAbstractInterface::directPropertyWriteErrorsPeer_data()
+{
+    callErrorsPeer_data();
+}
+
+void tst_QDBusAbstractInterface::directPropertyWriteErrorsPeer()
+{
+    QFETCH(QString, path);
+    Pinger p = getPingerPeer(path);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    // we shouldn't be able to get this value:
+    // but there's no direct way of verifying that the setting failed
+    if (p->isValid())
+        QCOMPARE(int(p->lastError().type()), int(QDBusError::NoError));
+    p->setStringProp("");
+    QTEST(p->lastError().name(), "errorName");
+}
+
 QTEST_MAIN(tst_QDBusAbstractInterface)
 #include "tst_qdbusabstractinterface.moc"