Merge branch 'test-base-protocol'

Reviewed-by: Andre Moreira Magalhaes (andrunko) <andre.magalhaes@collabora.co.uk>

10 files changed, 778 insertions, 78 deletions

diff --git a/TelepathyQt/base-connection-manager.cpp b/TelepathyQt/base-connection-manager.cpp
index ac293381..fac2a7f5 100644
--- a/TelepathyQt/base-connection-manager.cpp
+++ b/TelepathyQt/base-connection-manager.cpp
@@ -217,7 +217,8 @@ QString BaseConnectionManager::name() const
 QVariantMap BaseConnectionManager::immutableProperties() const
 {
     QVariantMap ret;
-    ret.insert(TP_QT_IFACE_CONNECTION_MANAGER + QLatin1String(".Protocols"), qVariantFromValue(mPriv->adaptee->protocols()));
+    ret.insert(TP_QT_IFACE_CONNECTION_MANAGER + QLatin1String(".Protocols"),
+            QVariant::fromValue(mPriv->adaptee->protocols()));
     return ret;
 }
 
diff --git a/TelepathyQt/base-connection-manager.h b/TelepathyQt/base-connection-manager.h
index ca337a91..e7b1efb3 100644
--- a/TelepathyQt/base-connection-manager.h
+++ b/TelepathyQt/base-connection-manager.h
@@ -50,9 +50,9 @@ public:
                     QDBusConnection::sessionBus(), name));
     }
     template<typename BaseConnectionManagerSubclass>
-    static BaseConnectionManagerPtr create(const QString &name)
+    static SharedPtr<BaseConnectionManagerSubclass> create(const QString &name)
     {
-        return BaseConnectionManagerPtr(new BaseConnectionManagerSubclass(
+        return SharedPtr<BaseConnectionManagerSubclass>(new BaseConnectionManagerSubclass(
                     QDBusConnection::sessionBus(), name));
     }
     static BaseConnectionManagerPtr create(const QDBusConnection &dbusConnection,
@@ -61,10 +61,11 @@ public:
         return BaseConnectionManagerPtr(new BaseConnectionManager(dbusConnection, name));
     }
     template<typename BaseConnectionManagerSubclass>
-    static BaseConnectionManagerPtr create(const QDBusConnection &dbusConnection,
+    static SharedPtr<BaseConnectionManagerSubclass> create(const QDBusConnection &dbusConnection,
             const QString &name)
     {
-        return BaseConnectionManagerPtr(new BaseConnectionManagerSubclass(dbusConnection, name));
+        return SharedPtr<BaseConnectionManagerSubclass>(new BaseConnectionManagerSubclass(
+                    dbusConnection, name));
     }
 
     virtual ~BaseConnectionManager();
diff --git a/TelepathyQt/base-connection.h b/TelepathyQt/base-connection.h
index 732105b0..8f4235e5 100644
--- a/TelepathyQt/base-connection.h
+++ b/TelepathyQt/base-connection.h
@@ -51,10 +51,10 @@ public:
                     QDBusConnection::sessionBus(), cmName, protocolName, parameters));
     }
     template<typename BaseConnectionSubclass>
-    static BaseConnectionPtr create(const QString &cmName, const QString &protocolName,
-            const QVariantMap &parameters)
+    static SharedPtr<BaseConnectionSubclass> create(const QString &cmName,
+            const QString &protocolName, const QVariantMap &parameters)
     {
-        return BaseConnectionPtr(new BaseConnectionSubclass(
+        return SharedPtr<BaseConnectionSubclass>(new BaseConnectionSubclass(
                     QDBusConnection::sessionBus(), cmName, protocolName, parameters));
     }
     static BaseConnectionPtr create(const QDBusConnection &dbusConnection,
@@ -65,11 +65,11 @@ public:
                     dbusConnection, cmName, protocolName, parameters));
     }
     template<typename BaseConnectionSubclass>
-    static BaseConnectionPtr create(const QDBusConnection &dbusConnection,
+    static SharedPtr<BaseConnectionSubclass> create(const QDBusConnection &dbusConnection,
             const QString &cmName, const QString &protocolName,
             const QVariantMap &parameters)
     {
-        return BaseConnectionPtr(new BaseConnectionSubclass(
+        return SharedPtr<BaseConnectionSubclass>(new BaseConnectionSubclass(
                     dbusConnection, cmName, protocolName, parameters));
     }
 
diff --git a/TelepathyQt/base-protocol-internal.h b/TelepathyQt/base-protocol-internal.h
index 1f992aa3..fc152fc6 100644
--- a/TelepathyQt/base-protocol-internal.h
+++ b/TelepathyQt/base-protocol-internal.h
@@ -76,8 +76,7 @@ class TP_QT_NO_EXPORT BaseProtocolAddressingInterface::Adaptee : public QObject
     Q_PROPERTY(QStringList addressableURISchemes READ addressableURISchemes)
 
 public:
-    Adaptee(const QDBusConnection &dbusConnection, QObject *dbusObject,
-            BaseProtocolAddressingInterface *interface);
+    Adaptee(BaseProtocolAddressingInterface *interface);
     ~Adaptee();
 
     QStringList addressableVCardFields() const;
@@ -106,8 +105,7 @@ class TP_QT_NO_EXPORT BaseProtocolAvatarsInterface::Adaptee : public QObject
     Q_PROPERTY(uint maximumAvatarBytes READ maximumAvatarBytes)
 
 public:
-    Adaptee(const QDBusConnection &dbusConnection, QObject *dbusObject,
-            BaseProtocolAvatarsInterface *interface);
+    Adaptee(BaseProtocolAvatarsInterface *interface);
     ~Adaptee();
 
     QStringList supportedAvatarMIMETypes() const;
@@ -129,8 +127,7 @@ class TP_QT_NO_EXPORT BaseProtocolPresenceInterface::Adaptee : public QObject
     Q_PROPERTY(Tp::SimpleStatusSpecMap statuses READ statuses)
 
 public:
-    Adaptee(const QDBusConnection &dbusConnection, QObject *dbusObject,
-            BaseProtocolPresenceInterface *interface);
+    Adaptee(BaseProtocolPresenceInterface *interface);
     ~Adaptee();
 
     SimpleStatusSpecMap statuses() const;
diff --git a/TelepathyQt/base-protocol.cpp b/TelepathyQt/base-protocol.cpp
index 0d386267..4764bd42 100644
--- a/TelepathyQt/base-protocol.cpp
+++ b/TelepathyQt/base-protocol.cpp
@@ -222,14 +222,22 @@ QVariantMap BaseProtocol::immutableProperties() const
     foreach (const AbstractProtocolInterfacePtr &iface, mPriv->interfaces) {
         ret.unite(iface->immutableProperties());
     }
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Interfaces"), qVariantFromValue(mPriv->adaptee->interfaces()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Parameters"), qVariantFromValue(mPriv->adaptee->parameters()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".ConnectionInterfaces"), qVariantFromValue(mPriv->adaptee->connectionInterfaces()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".RequestableChannelClasses"), qVariantFromValue(mPriv->adaptee->requestableChannelClasses()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".VCardField"), qVariantFromValue(mPriv->adaptee->vCardField()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".EnglishName"), qVariantFromValue(mPriv->adaptee->englishName()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Icon"), qVariantFromValue(mPriv->adaptee->icon()));
-    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".AuthenticationTypes"), qVariantFromValue(mPriv->adaptee->authenticationTypes()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Interfaces"),
+            QVariant::fromValue(mPriv->adaptee->interfaces()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Parameters"),
+            QVariant::fromValue(mPriv->adaptee->parameters()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".ConnectionInterfaces"),
+            QVariant::fromValue(mPriv->adaptee->connectionInterfaces()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".RequestableChannelClasses"),
+            QVariant::fromValue(mPriv->adaptee->requestableChannelClasses()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".VCardField"),
+            QVariant::fromValue(mPriv->adaptee->vCardField()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".EnglishName"),
+            QVariant::fromValue(mPriv->adaptee->englishName()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Icon"),
+            QVariant::fromValue(mPriv->adaptee->icon()));
+    ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".AuthenticationTypes"),
+            QVariant::fromValue(mPriv->adaptee->authenticationTypes()));
     return ret;
 }
 
@@ -622,7 +630,7 @@ QString BaseProtocol::normalizeContact(const QString &contactId, Tp::DBusError *
  * object has been registered on the bus with registerObject().
  *
  * \return A list containing all the Protocol interface implementation objects.
- * \sa plugInterface()
+ * \sa plugInterface(), interface()
  */
 QList<AbstractProtocolInterfacePtr> BaseProtocol::interfaces() const
 {
@@ -630,6 +638,21 @@ QList<AbstractProtocolInterfacePtr> BaseProtocol::interfaces() const
 }
 
 /**
+ * Return a pointer to the interface with the given name.
+ *
+ * \param interfaceName The D-Bus name of the interface,
+ * ex. TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING.
+ * \return A pointer to the AbstractProtocolInterface object that implements
+ * the D-Bus interface with the given name, or a null pointer if such an interface
+ * has not been plugged into this object.
+ * \sa plugInterface(), interfaces()
+ */
+AbstractProtocolInterfacePtr BaseProtocol::interface(const QString &interfaceName) const
+{
+    return mPriv->interfaces.value(interfaceName);
+}
+
+/**
  * Plug a new interface into this Protocol D-Bus object.
  *
  * This property is immutable and cannot change after this Protocol
@@ -638,7 +661,7 @@ QList<AbstractProtocolInterfacePtr> BaseProtocol::interfaces() const
  * \param interface An AbstractProtocolInterface instance that implements
  * the interface that is to be plugged.
  * \return \c true on success or \c false otherwise
- * \sa interfaces()
+ * \sa interfaces(), interface()
  */
 bool BaseProtocol::plugInterface(const AbstractProtocolInterfacePtr &interface)
 {
@@ -704,12 +727,10 @@ AbstractProtocolInterface::~AbstractProtocolInterface()
 }
 
 // Proto.I.Addressing
-BaseProtocolAddressingInterface::Adaptee::Adaptee(const QDBusConnection &dbusConnection,
-        QObject *dbusObject, BaseProtocolAddressingInterface *interface)
+BaseProtocolAddressingInterface::Adaptee::Adaptee(BaseProtocolAddressingInterface *interface)
     : QObject(interface),
       mInterface(interface)
 {
-    (void) new Service::ProtocolInterfaceAddressingAdaptor(dbusConnection, this, dbusObject);
 }
 
 BaseProtocolAddressingInterface::Adaptee::~Adaptee()
@@ -755,8 +776,8 @@ void BaseProtocolAddressingInterface::Adaptee::normalizeContactURI(const QString
 
 struct TP_QT_NO_EXPORT BaseProtocolAddressingInterface::Private
 {
-    Private()
-        : adaptee(0)
+    Private(BaseProtocolAddressingInterface *parent)
+        : adaptee(new BaseProtocolAddressingInterface::Adaptee(parent))
     {
     }
 
@@ -780,7 +801,7 @@ struct TP_QT_NO_EXPORT BaseProtocolAddressingInterface::Private
  */
 BaseProtocolAddressingInterface::BaseProtocolAddressingInterface()
     : AbstractProtocolInterface(TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING),
-      mPriv(new Private)
+      mPriv(new Private(this))
 {
 }
 
@@ -941,18 +962,15 @@ QString BaseProtocolAddressingInterface::normalizeContactUri(const QString &uri,
 
 void BaseProtocolAddressingInterface::createAdaptor()
 {
-    Q_ASSERT(!mPriv->adaptee);
-    mPriv->adaptee = new BaseProtocolAddressingInterface::Adaptee(
-            dbusObject()->dbusConnection(), dbusObject(), this);
+    (void) new Service::ProtocolInterfaceAddressingAdaptor(dbusObject()->dbusConnection(),
+                mPriv->adaptee, dbusObject());
 }
 
 // Proto.I.Avatars
-BaseProtocolAvatarsInterface::Adaptee::Adaptee(const QDBusConnection &dbusConnection,
-        QObject *dbusObject, BaseProtocolAvatarsInterface *interface)
+BaseProtocolAvatarsInterface::Adaptee::Adaptee(BaseProtocolAvatarsInterface *interface)
     : QObject(interface),
       mInterface(interface)
 {
-    (void) new Service::ProtocolInterfaceAvatarsAdaptor(dbusConnection, this, dbusObject);
 }
 
 BaseProtocolAvatarsInterface::Adaptee::~Adaptee()
@@ -1001,8 +1019,8 @@ uint BaseProtocolAvatarsInterface::Adaptee::maximumAvatarBytes() const
 
 struct TP_QT_NO_EXPORT BaseProtocolAvatarsInterface::Private
 {
-    Private()
-        : adaptee(0)
+    Private(BaseProtocolAvatarsInterface *parent)
+        : adaptee(new BaseProtocolAvatarsInterface::Adaptee(parent))
     {
     }
 
@@ -1023,7 +1041,7 @@ struct TP_QT_NO_EXPORT BaseProtocolAvatarsInterface::Private
  */
 BaseProtocolAvatarsInterface::BaseProtocolAvatarsInterface()
     : AbstractProtocolInterface(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS),
-      mPriv(new Private)
+      mPriv(new Private(this))
 {
 }
 
@@ -1046,14 +1064,22 @@ BaseProtocolAvatarsInterface::~BaseProtocolAvatarsInterface()
 QVariantMap BaseProtocolAvatarsInterface::immutableProperties() const
 {
     QVariantMap ret;
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".SupportedAvatarMIMETypes"), mPriv->adaptee->supportedAvatarMIMETypes());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight"), mPriv->adaptee->minimumAvatarHeight());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarWidth"), mPriv->adaptee->minimumAvatarWidth());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarHeight"), mPriv->adaptee->recommendedAvatarHeight());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarWidth"), mPriv->adaptee->recommendedAvatarWidth());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarHeight"), mPriv->adaptee->maximumAvatarHeight());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarWidth"), mPriv->adaptee->maximumAvatarWidth());
-    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarBytes"), mPriv->adaptee->maximumAvatarBytes());
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".SupportedAvatarMIMETypes"),
+            QVariant::fromValue(mPriv->adaptee->supportedAvatarMIMETypes()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight"),
+            QVariant::fromValue(mPriv->adaptee->minimumAvatarHeight()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarWidth"),
+            QVariant::fromValue(mPriv->adaptee->minimumAvatarWidth()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarHeight"),
+            QVariant::fromValue(mPriv->adaptee->recommendedAvatarHeight()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarWidth"),
+            QVariant::fromValue(mPriv->adaptee->recommendedAvatarWidth()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarHeight"),
+            QVariant::fromValue(mPriv->adaptee->maximumAvatarHeight()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarWidth"),
+            QVariant::fromValue(mPriv->adaptee->maximumAvatarWidth()));
+    ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarBytes"),
+            QVariant::fromValue(mPriv->adaptee->maximumAvatarBytes()));
     return ret;
 }
 
@@ -1097,18 +1123,15 @@ void BaseProtocolAvatarsInterface::setAvatarDetails(const AvatarSpec &details)
 
 void BaseProtocolAvatarsInterface::createAdaptor()
 {
-    Q_ASSERT(!mPriv->adaptee);
-    mPriv->adaptee = new BaseProtocolAvatarsInterface::Adaptee(
-            dbusObject()->dbusConnection(), dbusObject(), this);
+    (void) new Service::ProtocolInterfaceAvatarsAdaptor(dbusObject()->dbusConnection(),
+                mPriv->adaptee, dbusObject());
 }
 
 // Proto.I.Presence
-BaseProtocolPresenceInterface::Adaptee::Adaptee(const QDBusConnection &dbusConnection,
-        QObject *dbusObject, BaseProtocolPresenceInterface *interface)
+BaseProtocolPresenceInterface::Adaptee::Adaptee(BaseProtocolPresenceInterface *interface)
     : QObject(interface),
       mInterface(interface)
 {
-    (void) new Service::ProtocolInterfacePresenceAdaptor(dbusConnection, this, dbusObject);
 }
 
 BaseProtocolPresenceInterface::Adaptee::~Adaptee()
@@ -1122,8 +1145,8 @@ SimpleStatusSpecMap BaseProtocolPresenceInterface::Adaptee::statuses() const
 
 struct TP_QT_NO_EXPORT BaseProtocolPresenceInterface::Private
 {
-    Private()
-        : adaptee(0)
+    Private(BaseProtocolPresenceInterface *parent)
+        : adaptee(new BaseProtocolPresenceInterface::Adaptee(parent))
     {
     }
 
@@ -1144,7 +1167,7 @@ struct TP_QT_NO_EXPORT BaseProtocolPresenceInterface::Private
  */
 BaseProtocolPresenceInterface::BaseProtocolPresenceInterface()
     : AbstractProtocolInterface(TP_QT_IFACE_PROTOCOL_INTERFACE_PRESENCE),
-      mPriv(new Private)
+      mPriv(new Private(this))
 {
 }
 
@@ -1166,8 +1189,10 @@ BaseProtocolPresenceInterface::~BaseProtocolPresenceInterface()
  */
 QVariantMap BaseProtocolPresenceInterface::immutableProperties() const
 {
-    // no immutable property
-    return QVariantMap();
+    QVariantMap map;
+    map.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_PRESENCE + QLatin1String(".Statuses"),
+            QVariant::fromValue(mPriv->adaptee->statuses()));
+    return map;
 }
 
 /**
@@ -1212,9 +1237,8 @@ void BaseProtocolPresenceInterface::setStatuses(const PresenceSpecList &statuses
 
 void BaseProtocolPresenceInterface::createAdaptor()
 {
-    Q_ASSERT(!mPriv->adaptee);
-    mPriv->adaptee = new BaseProtocolPresenceInterface::Adaptee(
-            dbusObject()->dbusConnection(), dbusObject(), this);
+    (void) new Service::ProtocolInterfacePresenceAdaptor(dbusObject()->dbusConnection(),
+                mPriv->adaptee, dbusObject());
 }
 
 }
diff --git a/TelepathyQt/base-protocol.h b/TelepathyQt/base-protocol.h
index e2b7e34c..c1a691ec 100644
--- a/TelepathyQt/base-protocol.h
+++ b/TelepathyQt/base-protocol.h
@@ -55,18 +55,20 @@ public:
         return BaseProtocolPtr(new BaseProtocol(QDBusConnection::sessionBus(), name));
     }
     template<typename BaseProtocolSubclass>
-    static BaseProtocolPtr create(const QString &name)
+    static SharedPtr<BaseProtocolSubclass> create(const QString &name)
     {
-        return BaseProtocolPtr(new BaseProtocolSubclass(QDBusConnection::sessionBus(), name));
+        return SharedPtr<BaseProtocolSubclass>(new BaseProtocolSubclass(
+                QDBusConnection::sessionBus(), name));
     }
     static BaseProtocolPtr create(const QDBusConnection &dbusConnection, const QString &name)
     {
         return BaseProtocolPtr(new BaseProtocol(dbusConnection, name));
     }
     template<typename BaseProtocolSubclass>
-    static BaseProtocolPtr create(const QDBusConnection &dbusConnection, const QString &name)
+    static SharedPtr<BaseProtocolSubclass> create(const QDBusConnection &dbusConnection,
+            const QString &name)
     {
-        return BaseProtocolPtr(new BaseProtocolSubclass(dbusConnection, name));
+        return SharedPtr<BaseProtocolSubclass>(new BaseProtocolSubclass(dbusConnection, name));
     }
 
     virtual ~BaseProtocol();
@@ -110,6 +112,7 @@ public:
     QString normalizeContact(const QString &contactId, DBusError *error);
 
     QList<AbstractProtocolInterfacePtr> interfaces() const;
+    AbstractProtocolInterfacePtr interface(const QString & interfaceName) const;
     bool plugInterface(const AbstractProtocolInterfacePtr &interface);
 
 protected:
@@ -129,6 +132,7 @@ private:
 
 class TP_QT_EXPORT AbstractProtocolInterface : public AbstractDBusServiceInterface
 {
+    Q_OBJECT
     Q_DISABLE_COPY(AbstractProtocolInterface)
 
 public:
@@ -145,6 +149,7 @@ private:
 
 class TP_QT_EXPORT BaseProtocolAddressingInterface : public AbstractProtocolInterface
 {
+    Q_OBJECT
     Q_DISABLE_COPY(BaseProtocolAddressingInterface)
 
 public:
@@ -153,9 +158,10 @@ public:
         return BaseProtocolAddressingInterfacePtr(new BaseProtocolAddressingInterface());
     }
     template<typename BaseProtocolAddressingInterfaceSubclass>
-    static BaseProtocolAddressingInterfacePtr create()
+    static SharedPtr<BaseProtocolAddressingInterfaceSubclass> create()
     {
-        return BaseProtocolAddressingInterfacePtr(new BaseProtocolAddressingInterfaceSubclass());
+        return SharedPtr<BaseProtocolAddressingInterfaceSubclass>(
+                new BaseProtocolAddressingInterfaceSubclass());
     }
 
     virtual ~BaseProtocolAddressingInterface();
@@ -191,6 +197,7 @@ private:
 
 class TP_QT_EXPORT BaseProtocolAvatarsInterface : public AbstractProtocolInterface
 {
+    Q_OBJECT
     Q_DISABLE_COPY(BaseProtocolAvatarsInterface)
 
 public:
@@ -199,9 +206,10 @@ public:
         return BaseProtocolAvatarsInterfacePtr(new BaseProtocolAvatarsInterface());
     }
     template<typename BaseProtocolAvatarsInterfaceSubclass>
-    static BaseProtocolAvatarsInterfacePtr create()
+    static SharedPtr<BaseProtocolAvatarsInterfaceSubclass> create()
     {
-        return BaseProtocolAvatarsInterfacePtr(new BaseProtocolAvatarsInterfaceSubclass());
+        return SharedPtr<BaseProtocolAvatarsInterfaceSubclass>(
+                new BaseProtocolAvatarsInterfaceSubclass());
     }
 
     virtual ~BaseProtocolAvatarsInterface();
@@ -226,6 +234,7 @@ private:
 
 class TP_QT_EXPORT BaseProtocolPresenceInterface : public AbstractProtocolInterface
 {
+    Q_OBJECT
     Q_DISABLE_COPY(BaseProtocolPresenceInterface)
 
 public:
@@ -234,9 +243,10 @@ public:
         return BaseProtocolPresenceInterfacePtr(new BaseProtocolPresenceInterface());
     }
     template<typename BaseProtocolPresenceInterfaceSubclass>
-    static BaseProtocolPresenceInterfacePtr create()
+    static SharedPtr<BaseProtocolPresenceInterfaceSubclass> create()
     {
-        return BaseProtocolPresenceInterfacePtr(new BaseProtocolPresenceInterfaceSubclass());
+        return SharedPtr<BaseProtocolPresenceInterfaceSubclass>(
+                new BaseProtocolPresenceInterfaceSubclass());
     }
 
     virtual ~BaseProtocolPresenceInterface();
diff --git a/TelepathyQt/protocol-parameter.cpp b/TelepathyQt/protocol-parameter.cpp
index bc30f68e..e0960d14 100644
--- a/TelepathyQt/protocol-parameter.cpp
+++ b/TelepathyQt/protocol-parameter.cpp
@@ -39,7 +39,7 @@ struct TP_QT_NO_EXPORT ProtocolParameter::Private : public QSharedData
     }
 
     Private(const QString &name, const QString &dbusSignature,
-            ConnMgrParamFlag flags, const QVariant &defaultValue)
+            ConnMgrParamFlags flags, const QVariant &defaultValue)
         : type(variantTypeFromDBusSignature(dbusSignature))
     {
         spec.name = name;
@@ -95,7 +95,7 @@ ProtocolParameter::ProtocolParameter(const ParamSpec &spec)
 
 ProtocolParameter::ProtocolParameter(const QString &name,
                                      const QDBusSignature &dbusSignature,
-                                     ConnMgrParamFlag flags,
+                                     ConnMgrParamFlags flags,
                                      QVariant defaultValue)
     : mPriv(new Private(name, dbusSignature.signature(), flags, defaultValue))
 {
@@ -103,7 +103,7 @@ ProtocolParameter::ProtocolParameter(const QString &name,
 
 ProtocolParameter::ProtocolParameter(const QString &name,
                                      const QString &dbusSignature,
-                                     ConnMgrParamFlag flags,
+                                     ConnMgrParamFlags flags,
                                      QVariant defaultValue)
     : mPriv(new Private(name, dbusSignature, flags, defaultValue))
 {
diff --git a/TelepathyQt/protocol-parameter.h b/TelepathyQt/protocol-parameter.h
index cdd349a5..0762bb39 100644
--- a/TelepathyQt/protocol-parameter.h
+++ b/TelepathyQt/protocol-parameter.h
@@ -46,11 +46,11 @@ public:
     ProtocolParameter(const ParamSpec &spec);
     ProtocolParameter(const QString &name,
                       const QDBusSignature &dbusSignature,
-                      ConnMgrParamFlag flags,
+                      ConnMgrParamFlags flags,
                       QVariant defaultValue = QVariant());
     ProtocolParameter(const QString &name,
                       const QString &dbusSignature,
-                      ConnMgrParamFlag flags,
+                      ConnMgrParamFlags flags,
                       QVariant defaultValue = QVariant());
     ProtocolParameter(const ProtocolParameter &other);
     ~ProtocolParameter();
diff --git a/tests/dbus/CMakeLists.txt b/tests/dbus/CMakeLists.txt
index 5b87a6c1..4df270ee 100644
--- a/tests/dbus/CMakeLists.txt
+++ b/tests/dbus/CMakeLists.txt
@@ -85,6 +85,7 @@ tpqt_add_dbus_unit_test(Types types)
 
 if(ENABLE_EXPERIMENTAL_SERVICE_SUPPORT)
     tpqt_add_dbus_unit_test(BaseConnectionManager base-cm telepathy-qt${QT_VERSION_MAJOR}-service)
+    tpqt_add_dbus_unit_test(BaseProtocol base-protocol telepathy-qt${QT_VERSION_MAJOR}-service)
 endif(ENABLE_EXPERIMENTAL_SERVICE_SUPPORT)
 
 # Make check target. In case of check, output on failure and put it into a log
diff --git a/tests/dbus/base-protocol.cpp b/tests/dbus/base-protocol.cpp
new file mode 100644
index 00000000..3eaf985e
--- /dev/null
+++ b/tests/dbus/base-protocol.cpp
@@ -0,0 +1,666 @@
+#include <tests/lib/test.h>
+#include <tests/lib/test-thread-helper.h>
+
+#define TP_QT_ENABLE_LOWLEVEL_API
+
+#include <TelepathyQt/BaseConnectionManager>
+#include <TelepathyQt/BaseProtocol>
+#include <TelepathyQt/BaseConnection>
+#include <TelepathyQt/ConnectionManager>
+#include <TelepathyQt/ConnectionManagerLowlevel>
+#include <TelepathyQt/DBusError>
+#include <TelepathyQt/PendingReady>
+#include <TelepathyQt/PendingConnection>
+#include <TelepathyQt/PendingString>
+
+using namespace Tp;
+
+class TestBaseProtocolCM;
+typedef SharedPtr<TestBaseProtocolCM> TestBaseProtocolCMPtr;
+
+class TestBaseProtocolCM : public BaseConnectionManager
+{
+public:
+    TestBaseProtocolCM(const QDBusConnection &conn, const QString & name)
+        : BaseConnectionManager(conn, name)
+    { }
+
+    static void createCM(TestBaseProtocolCMPtr &cm);
+
+private:
+    static BaseConnectionPtr createConnectionCb(const QVariantMap &parameters,
+            Tp::DBusError *error);
+    static QString identifyAccountCb(const QVariantMap &parameters, Tp::DBusError *error);
+    static QString normalizeContactCb(const QString &contactId, Tp::DBusError *error);
+
+    static QString normalizeVCardAddressCb(const QString &vCardField,
+            const QString &vCardAddress, Tp::DBusError *error);
+    static QString normalizeContactUriCb(const QString &uri, Tp::DBusError *error);
+};
+
+class TestBaseProtocol : public Test
+{
+    Q_OBJECT
+public:
+    TestBaseProtocol(QObject *parent = 0)
+        : Test(parent)
+    { }
+
+private:
+    static void protocolObjectSvcSideCb(TestBaseProtocolCMPtr &cm);
+    static void addressingIfaceSvcSideCb(TestBaseProtocolCMPtr &cm);
+    static void avatarsIfaceSvcSideCb(TestBaseProtocolCMPtr &cm);
+    static void presenceIfaceSvcSideCb(TestBaseProtocolCMPtr &cm);
+
+private Q_SLOTS:
+    void initTestCase();
+    void init();
+
+    void protocolObjectSvcSide();
+    void protocolObjectClientSide();
+    void addressingIfaceSvcSide();
+    void addressingIfaceClientSide();
+    void avatarsIfaceSvcSide();
+    void avatarsIfaceClientSide();
+    void presenceIfaceSvcSide();
+    void presenceIfaceClientSide();
+
+    void cleanup();
+    void cleanupTestCase();
+
+private:
+    TestThreadHelper<TestBaseProtocolCMPtr> *mThreadHelper;
+};
+
+void TestBaseProtocolCM::createCM(TestBaseProtocolCMPtr &cm)
+{
+    cm = BaseConnectionManager::create<TestBaseProtocolCM>(QLatin1String("testcm"));
+
+    BaseProtocolPtr protocol = BaseProtocol::create(QLatin1String("example"));
+    protocol->setConnectionInterfaces(QStringList() <<
+            TP_QT_IFACE_CONNECTION_INTERFACE_CONTACT_LIST);
+    protocol->setParameters(ProtocolParameterList() <<
+            ProtocolParameter(QLatin1String("account"), QDBusSignature("s"),
+                    Tp::ConnMgrParamFlagRequired | Tp::ConnMgrParamFlagRegister));
+    protocol->setRequestableChannelClasses(RequestableChannelClassSpec::textChat());
+    protocol->setVCardField(QLatin1String("x-telepathy-example"));
+    protocol->setEnglishName(QLatin1String("Test CM"));
+    protocol->setIconName(QLatin1String("im-icq"));
+    protocol->setAuthenticationTypes(QStringList() <<
+            TP_QT_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION);
+    protocol->setCreateConnectionCallback(ptrFun(&TestBaseProtocolCM::createConnectionCb));
+    protocol->setIdentifyAccountCallback(ptrFun(&TestBaseProtocolCM::identifyAccountCb));
+    protocol->setNormalizeContactCallback(ptrFun(&TestBaseProtocolCM::normalizeContactCb));
+
+    BaseProtocolAddressingInterfacePtr addressingIface =
+                BaseProtocolAddressingInterface::create();
+    addressingIface->setAddressableUriSchemes(QStringList()
+            << QLatin1String("xmpp")
+            << QLatin1String("tel"));
+    addressingIface->setAddressableVCardFields(QStringList()
+            << QLatin1String("x-jabber")
+            << QLatin1String("tel"));
+    addressingIface->setNormalizeVCardAddressCallback(
+            ptrFun(&TestBaseProtocolCM::normalizeVCardAddressCb));
+    addressingIface->setNormalizeContactUriCallback(
+            ptrFun(&TestBaseProtocolCM::normalizeContactUriCb));
+    QVERIFY(protocol->plugInterface(addressingIface));
+
+    BaseProtocolAvatarsInterfacePtr avatarsIface = BaseProtocolAvatarsInterface::create();
+    avatarsIface->setAvatarDetails(
+            AvatarSpec(QStringList()
+                << QLatin1String("image/png")
+                << QLatin1String("image/jpeg")
+                << QLatin1String("image/gif"),
+                32, 96, 64,
+                32, 96, 64,
+                37748736));
+    QVERIFY(protocol->plugInterface(avatarsIface));
+
+    BaseProtocolPresenceInterfacePtr presenceIface = BaseProtocolPresenceInterface::create();
+    //TODO add statuses on presenceIface
+    QVERIFY(protocol->plugInterface(presenceIface));
+
+    QVERIFY(cm->addProtocol(protocol));
+
+    Tp::DBusError err;
+    QVERIFY(cm->registerObject(&err));
+    QVERIFY(!err.isValid());
+    QVERIFY(cm->isRegistered());
+}
+
+BaseConnectionPtr TestBaseProtocolCM::createConnectionCb(const QVariantMap &parameters,
+        Tp::DBusError *error)
+{
+    if (parameters.contains(QLatin1String("account"))) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED,
+                parameters.value(QLatin1String("account")).toString());
+    } else {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED,
+                QLatin1String("This test doesn't create connections"));
+    }
+    return BaseConnectionPtr();
+}
+
+QString TestBaseProtocolCM::identifyAccountCb(const QVariantMap &parameters, Tp::DBusError *error)
+{
+    QString account = parameters.value(QLatin1String("account")).toString();
+    if (account.isEmpty()) {
+        error->set(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("'account' parameter not given"));
+    }
+    return account;
+}
+
+QString TestBaseProtocolCM::normalizeContactCb(const QString &contactId, Tp::DBusError *error)
+{
+    if (contactId.isEmpty()) {
+        error->set(TP_QT_ERROR_INVALID_HANDLE, QLatin1String("ID must not be empty"));
+        return QString();
+    }
+
+    return contactId.toLower();
+}
+
+QString TestBaseProtocolCM::normalizeVCardAddressCb(const QString &vCardField,
+        const QString &vCardAddress, Tp::DBusError *error)
+{
+    if (vCardField == QLatin1String("x-jabber")) {
+        return vCardAddress.toLower() + QLatin1String("@wonderland");
+    } else {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Invalid VCard field"));
+        return QString();
+    }
+}
+
+QString TestBaseProtocolCM::normalizeContactUriCb(const QString &uri, Tp::DBusError *error)
+{
+    if (uri.startsWith(QLatin1String("xmpp:"))) {
+        if (uri.contains(QLatin1Char('/'))) {
+            return uri.left(uri.indexOf(QLatin1Char('/')));
+        } else {
+            return uri;
+        }
+    } else {
+        error->set(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("Invalid URI"));
+        return QString();
+    }
+}
+
+
+void TestBaseProtocol::initTestCase()
+{
+    initTestCaseImpl();
+}
+
+void TestBaseProtocol::init()
+{
+    initImpl();
+    mThreadHelper = new TestThreadHelper<TestBaseProtocolCMPtr>();
+    TEST_THREAD_HELPER_EXECUTE(mThreadHelper, &TestBaseProtocolCM::createCM);
+}
+
+void TestBaseProtocol::protocolObjectSvcSideCb(TestBaseProtocolCMPtr &cm)
+{
+    QCOMPARE(cm->name(), QLatin1String("testcm"));
+    QVERIFY(cm->hasProtocol(QLatin1String("example")));
+    QCOMPARE(cm->protocols().size(), 1);
+
+    BaseProtocolPtr protocol = cm->protocols().at(0);
+    QVERIFY(protocol);
+
+    //basic properties
+    QCOMPARE(protocol->name(), QLatin1String("example"));
+    QCOMPARE(protocol->vCardField(), QLatin1String("x-telepathy-example"));
+    QCOMPARE(protocol->englishName(), QLatin1String("Test CM"));
+    QCOMPARE(protocol->iconName(), QLatin1String("im-icq"));
+    QCOMPARE(protocol->connectionInterfaces(), QStringList() <<
+            TP_QT_IFACE_CONNECTION_INTERFACE_CONTACT_LIST);
+    QCOMPARE(protocol->authenticationTypes(), QStringList() <<
+            TP_QT_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION);
+    QCOMPARE(protocol->requestableChannelClasses().size(), 1);
+    QCOMPARE(protocol->requestableChannelClasses().at(0),
+            RequestableChannelClassSpec::textChat());
+
+    //parameters
+    QCOMPARE(protocol->parameters().size(), 1);
+    QCOMPARE(protocol->parameters().at(0).name(), QLatin1String("account"));
+    QCOMPARE(protocol->parameters().at(0).dbusSignature(), QDBusSignature("s"));
+    QVERIFY(protocol->parameters().at(0).isRequired());
+    QVERIFY(protocol->parameters().at(0).isRequiredForRegistration());
+    QVERIFY(!protocol->parameters().at(0).isSecret());
+
+    //interfaces
+    QCOMPARE(protocol->interfaces().size(), 3);
+
+    //immutable props
+    QVariantMap props = protocol->immutableProperties();
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".Interfaces")));
+
+    QStringList sl = props.value(
+            TP_QT_IFACE_PROTOCOL + QLatin1String(".Interfaces")).toStringList();
+    QVERIFY(sl.contains(TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING));
+    QVERIFY(sl.contains(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS));
+    QVERIFY(sl.contains(TP_QT_IFACE_PROTOCOL_INTERFACE_PRESENCE));
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".Parameters")));
+    ParamSpecList params = qvariant_cast<ParamSpecList>(props.value(
+            TP_QT_IFACE_PROTOCOL + QLatin1String(".Parameters")));
+    QCOMPARE(params.size(), 1);
+    QCOMPARE(params.at(0).name, QLatin1String("account"));
+    QCOMPARE(params.at(0).signature, QLatin1String("s"));
+    QCOMPARE(params.at(0).flags, uint(ConnMgrParamFlagRequired | ConnMgrParamFlagRegister));
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".VCardField")));
+    QCOMPARE(props.value(TP_QT_IFACE_PROTOCOL + QLatin1String(".VCardField")).toString(),
+             QLatin1String("x-telepathy-example"));
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".EnglishName")));
+    QCOMPARE(props.value(TP_QT_IFACE_PROTOCOL + QLatin1String(".EnglishName")).toString(),
+             QLatin1String("Test CM"));
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".Icon")));
+    QCOMPARE(props.value(TP_QT_IFACE_PROTOCOL + QLatin1String(".Icon")).toString(),
+             QLatin1String("im-icq"));
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".RequestableChannelClasses")));
+    RequestableChannelClassList rcc = qvariant_cast<RequestableChannelClassList>(props.value(
+            TP_QT_IFACE_PROTOCOL + QLatin1String(".RequestableChannelClasses")));
+    QCOMPARE(rcc.size(), 1);
+    QCOMPARE(RequestableChannelClassSpec(rcc.at(0)), RequestableChannelClassSpec::textChat());
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".ConnectionInterfaces")));
+    sl = props.value(TP_QT_IFACE_PROTOCOL + QLatin1String(".ConnectionInterfaces")).toStringList();
+    QCOMPARE(sl, QStringList() << TP_QT_IFACE_CONNECTION_INTERFACE_CONTACT_LIST);
+
+    QVERIFY(props.contains(TP_QT_IFACE_PROTOCOL + QLatin1String(".AuthenticationTypes")));
+    sl = props.value(TP_QT_IFACE_PROTOCOL + QLatin1String(".AuthenticationTypes")).toStringList();
+    QCOMPARE(sl, QStringList() << TP_QT_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION);
+
+    //interface immutable properties should also be here
+    //test only one - the rest later
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight")).toInt(),
+        32);
+
+    //methods
+    {
+        Tp::DBusError err;
+        QString normalizedContact = protocol->normalizeContact(QLatin1String("BoB"), &err);
+        QVERIFY(!err.isValid());
+        QCOMPARE(normalizedContact, QLatin1String("bob"));
+    }
+
+    {
+        Tp::DBusError err;
+        QString account = protocol->identifyAccount(QVariantMap(), &err);
+        QVERIFY(err.isValid());
+        QVERIFY(account.isEmpty());
+        QCOMPARE(err.name(), TP_QT_ERROR_INVALID_ARGUMENT);
+        QCOMPARE(err.message(), QLatin1String("'account' parameter not given"));
+    }
+
+    {
+        Tp::DBusError err;
+        BaseConnectionPtr conn = protocol->createConnection(QVariantMap(), &err);
+        QVERIFY(err.isValid());
+        QVERIFY(conn.isNull());
+        QCOMPARE(err.name(), TP_QT_ERROR_NOT_IMPLEMENTED);
+        QCOMPARE(err.message(), QLatin1String("This test doesn't create connections"));
+    }
+}
+
+void TestBaseProtocol::protocolObjectSvcSide()
+{
+    TEST_THREAD_HELPER_EXECUTE(mThreadHelper, &TestBaseProtocol::protocolObjectSvcSideCb);
+}
+
+void TestBaseProtocol::protocolObjectClientSide()
+{
+    ConnectionManagerPtr cliCM = ConnectionManager::create(QLatin1String("testcm"));
+    PendingReady *pr = cliCM->becomeReady(ConnectionManager::FeatureCore);
+    connect(pr, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+
+    QCOMPARE(cliCM->supportedProtocols().size(), 1);
+    QVERIFY(cliCM->hasProtocol(QLatin1String("example")));
+
+    ProtocolInfo protocol = cliCM->protocol(QLatin1String("example"));
+    QVERIFY(protocol.isValid());
+
+    Tp::Client::ProtocolInterface protocolIface(cliCM->busName(),
+            cliCM->objectPath() + QLatin1String("/example"));
+
+    //basic properties
+    QCOMPARE(protocol.vcardField(), QLatin1String("x-telepathy-example"));
+    QCOMPARE(protocol.englishName(), QLatin1String("Test CM"));
+    QCOMPARE(protocol.iconName(), QLatin1String("im-icq"));
+    QCOMPARE(protocol.capabilities().allClassSpecs().size(), 1);
+    QVERIFY(protocol.capabilities().textChats());
+
+    PendingVariant *pv = protocolIface.requestPropertyConnectionInterfaces();
+    connect(pv, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+    QCOMPARE(pv->result().toStringList(), QStringList() <<
+            TP_QT_IFACE_CONNECTION_INTERFACE_CONTACT_LIST);
+
+    pv = protocolIface.requestPropertyAuthenticationTypes();
+    connect(pv, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+    QCOMPARE(pv->result().toStringList(), QStringList() <<
+            TP_QT_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION);
+
+    //parameters
+    QVERIFY(protocol.hasParameter(QLatin1String("account")));
+    ProtocolParameterList params = protocol.parameters();
+    QCOMPARE(params.size(), 1);
+    QCOMPARE(params.at(0).name(), QLatin1String("account"));
+    QCOMPARE(params.at(0).dbusSignature(), QDBusSignature("s"));
+    QVERIFY(params.at(0).isRequired());
+    QVERIFY(params.at(0).isRequiredForRegistration());
+    QVERIFY(!params.at(0).isSecret());
+
+    //methods
+    {
+        QDBusPendingReply<QString> reply = protocolIface.NormalizeContact(QLatin1String("ALiCe"));
+        reply.waitForFinished();
+        QVERIFY(!reply.isError());
+        QCOMPARE(reply.value(), QLatin1String("alice"));
+    }
+
+    QVariantMap map;
+    map.insert(QLatin1String("account"), QLatin1String("example@nowhere.com"));
+
+    {
+        QDBusPendingReply<QString> reply = protocolIface.IdentifyAccount(map);
+        reply.waitForFinished();
+        QVERIFY(!reply.isError());
+        QCOMPARE(reply.value(), QLatin1String("example@nowhere.com"));
+    }
+
+    PendingConnection *pc = cliCM->lowlevel()->requestConnection(QLatin1String("example"), map);
+    connect(pc, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectFailure(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+    QCOMPARE(mLastError, TP_QT_ERROR_NOT_IMPLEMENTED);
+    QCOMPARE(mLastErrorMessage, QLatin1String("example@nowhere.com"));
+}
+
+void TestBaseProtocol::addressingIfaceSvcSideCb(TestBaseProtocolCMPtr &cm)
+{
+    QCOMPARE(cm->name(), QLatin1String("testcm"));
+    QVERIFY(cm->hasProtocol(QLatin1String("example")));
+    QCOMPARE(cm->protocols().size(), 1);
+
+    Tp::BaseProtocolPtr protocol = cm->protocols().at(0);
+    QVERIFY(protocol);
+
+    Tp::BaseProtocolAddressingInterfacePtr iface =
+            Tp::BaseProtocolAddressingInterfacePtr::qObjectCast(
+                    protocol->interface(TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING));
+    QVERIFY(iface);
+
+    //properties
+    QStringList uriSchemes = iface->addressableUriSchemes();
+    QCOMPARE(uriSchemes.size(), 2);
+    QVERIFY(uriSchemes.contains(QLatin1String("xmpp")));
+    QVERIFY(uriSchemes.contains(QLatin1String("tel")));
+
+    QStringList vCardFields = iface->addressableVCardFields();
+    QCOMPARE(vCardFields.size(), 2);
+    QVERIFY(vCardFields.contains(QLatin1String("x-jabber")));
+    QVERIFY(vCardFields.contains(QLatin1String("tel")));
+
+    //no immutable properties
+    QVERIFY(iface->immutableProperties().isEmpty());
+
+    //methods
+    {
+        Tp::DBusError err;
+        QString result = iface->normalizeVCardAddress(QLatin1String("x-msn"),
+                QLatin1String("Alice"), &err);
+        QVERIFY(err.isValid());
+        QVERIFY(result.isEmpty());
+        QCOMPARE(err.name(), TP_QT_ERROR_NOT_IMPLEMENTED);
+        QCOMPARE(err.message(), QLatin1String("Invalid VCard field"));
+    }
+
+    {
+        Tp::DBusError err;
+        QString result = iface->normalizeContactUri(
+                QLatin1String("xmpp:alice@wonderland/Mobile"), &err);
+        QVERIFY(!err.isValid());
+        QCOMPARE(result, QLatin1String("xmpp:alice@wonderland"));
+    }
+}
+
+void TestBaseProtocol::addressingIfaceSvcSide()
+{
+    TEST_THREAD_HELPER_EXECUTE(mThreadHelper, &TestBaseProtocol::addressingIfaceSvcSideCb);
+}
+
+void TestBaseProtocol::addressingIfaceClientSide()
+{
+    ConnectionManagerPtr cliCM = ConnectionManager::create(QLatin1String("testcm"));
+    PendingReady *pr = cliCM->becomeReady(ConnectionManager::FeatureCore);
+    connect(pr, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+
+    QCOMPARE(cliCM->supportedProtocols().size(), 1);
+    QVERIFY(cliCM->hasProtocol(QLatin1String("example")));
+
+    ProtocolInfo protocol = cliCM->protocol(QLatin1String("example"));
+    QVERIFY(protocol.isValid());
+
+    //properties
+    QStringList uriSchemes = protocol.addressableUriSchemes();
+    QCOMPARE(uriSchemes.size(), 2);
+    QVERIFY(uriSchemes.contains(QLatin1String("xmpp")));
+    QVERIFY(uriSchemes.contains(QLatin1String("tel")));
+
+    QStringList vCardFields = protocol.addressableVCardFields();
+    QCOMPARE(vCardFields.size(), 2);
+    QVERIFY(vCardFields.contains(QLatin1String("x-jabber")));
+    QVERIFY(vCardFields.contains(QLatin1String("tel")));
+
+    //methods
+    PendingString *str = protocol.normalizeVCardAddress(QLatin1String("x-jabber"),
+                QLatin1String("Alice"));
+    connect(str, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+    QCOMPARE(str->result(), QLatin1String("alice@wonderland"));
+
+    str = protocol.normalizeContactUri(QLatin1String("invalid"));
+    connect(str, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectFailure(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+    QCOMPARE(mLastError, TP_QT_ERROR_INVALID_ARGUMENT);
+    QCOMPARE(mLastErrorMessage, QLatin1String("Invalid URI"));
+}
+
+void TestBaseProtocol::avatarsIfaceSvcSideCb(TestBaseProtocolCMPtr &cm)
+{
+    QCOMPARE(cm->name(), QLatin1String("testcm"));
+    QVERIFY(cm->hasProtocol(QLatin1String("example")));
+    QCOMPARE(cm->protocols().size(), 1);
+
+    Tp::BaseProtocolPtr protocol = cm->protocols().at(0);
+    QVERIFY(protocol);
+
+    Tp::BaseProtocolAvatarsInterfacePtr iface =
+            Tp::BaseProtocolAvatarsInterfacePtr::qObjectCast(
+                    protocol->interface(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS));
+    QVERIFY(iface);
+
+    //avatar details property
+    AvatarSpec avatarSpec = iface->avatarDetails();
+    QVERIFY(avatarSpec.isValid());
+
+    QStringList mimeTypes = avatarSpec.supportedMimeTypes();
+    QCOMPARE(mimeTypes.size(), 3);
+    QVERIFY(mimeTypes.contains(QLatin1String("image/png")));
+    QVERIFY(mimeTypes.contains(QLatin1String("image/jpeg")));
+    QVERIFY(mimeTypes.contains(QLatin1String("image/gif")));
+
+    QCOMPARE(avatarSpec.minimumWidth(), 32U);
+    QCOMPARE(avatarSpec.maximumWidth(), 96U);
+    QCOMPARE(avatarSpec.recommendedWidth(), 64U);
+    QCOMPARE(avatarSpec.minimumHeight(), 32U);
+    QCOMPARE(avatarSpec.maximumHeight(), 96U);
+    QCOMPARE(avatarSpec.recommendedHeight(), 64U);
+    QCOMPARE(avatarSpec.maximumBytes(), 37748736U);
+
+    //immutable properties
+    QVariantMap props = protocol->immutableProperties();
+
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".SupportedAvatarMIMETypes")));
+    mimeTypes = props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".SupportedAvatarMIMETypes"))
+            .toStringList();
+    QCOMPARE(mimeTypes.size(), 3);
+    QVERIFY(mimeTypes.contains(QLatin1String("image/png")));
+    QVERIFY(mimeTypes.contains(QLatin1String("image/jpeg")));
+    QVERIFY(mimeTypes.contains(QLatin1String("image/gif")));
+
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight")).toInt(),
+        32);
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarWidth")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarWidth")).toInt(),
+        32);
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarHeight")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarHeight")).toInt(),
+        64);
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarWidth")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarWidth")).toInt(),
+        64);
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarHeight")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarHeight")).toInt(),
+        96);
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarWidth")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarWidth")).toInt(),
+        96);
+    QVERIFY(props.contains(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarBytes")));
+    QCOMPARE(props.value(
+        TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarBytes")).toInt(),
+        37748736);
+}
+
+void TestBaseProtocol::avatarsIfaceSvcSide()
+{
+    TEST_THREAD_HELPER_EXECUTE(mThreadHelper, &TestBaseProtocol::avatarsIfaceSvcSideCb);
+}
+
+void TestBaseProtocol::avatarsIfaceClientSide()
+{
+    ConnectionManagerPtr cliCM = ConnectionManager::create(QLatin1String("testcm"));
+    PendingReady *pr = cliCM->becomeReady(ConnectionManager::FeatureCore);
+    connect(pr, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+
+    QCOMPARE(cliCM->supportedProtocols().size(), 1);
+    QVERIFY(cliCM->hasProtocol(QLatin1String("example")));
+
+    ProtocolInfo protocol = cliCM->protocol(QLatin1String("example"));
+    QVERIFY(protocol.isValid());
+
+    //avatar iface
+    AvatarSpec avatarSpec = protocol.avatarRequirements();
+    QVERIFY(avatarSpec.isValid());
+
+    QStringList mimeTypes = avatarSpec.supportedMimeTypes();
+    QCOMPARE(mimeTypes.size(), 3);
+    QVERIFY(mimeTypes.contains(QLatin1String("image/png")));
+    QVERIFY(mimeTypes.contains(QLatin1String("image/jpeg")));
+    QVERIFY(mimeTypes.contains(QLatin1String("image/gif")));
+
+    QCOMPARE(avatarSpec.minimumWidth(), 32U);
+    QCOMPARE(avatarSpec.maximumWidth(), 96U);
+    QCOMPARE(avatarSpec.recommendedWidth(), 64U);
+    QCOMPARE(avatarSpec.minimumHeight(), 32U);
+    QCOMPARE(avatarSpec.maximumHeight(), 96U);
+    QCOMPARE(avatarSpec.recommendedHeight(), 64U);
+    QCOMPARE(avatarSpec.maximumBytes(), 37748736U);
+}
+
+void TestBaseProtocol::presenceIfaceSvcSideCb(TestBaseProtocolCMPtr &cm)
+{
+    QCOMPARE(cm->name(), QLatin1String("testcm"));
+    QVERIFY(cm->hasProtocol(QLatin1String("example")));
+    QCOMPARE(cm->protocols().size(), 1);
+
+    Tp::BaseProtocolPtr protocol = cm->protocols().at(0);
+    QVERIFY(protocol);
+
+    Tp::BaseProtocolPresenceInterfacePtr iface =
+            Tp::BaseProtocolPresenceInterfacePtr::qObjectCast(
+                    protocol->interface(TP_QT_IFACE_PROTOCOL_INTERFACE_PRESENCE));
+    QVERIFY(iface);
+
+    //presence interface
+    PresenceSpecList statuses = iface->statuses();
+    QVERIFY(statuses.isEmpty());
+
+    //TODO properly test statuses
+}
+
+void TestBaseProtocol::presenceIfaceSvcSide()
+{
+    TEST_THREAD_HELPER_EXECUTE(mThreadHelper, &TestBaseProtocol::presenceIfaceSvcSideCb);
+}
+
+void TestBaseProtocol::presenceIfaceClientSide()
+{
+    ConnectionManagerPtr cliCM = ConnectionManager::create(QLatin1String("testcm"));
+    PendingReady *pr = cliCM->becomeReady(ConnectionManager::FeatureCore);
+    connect(pr, SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(expectSuccessfulCall(Tp::PendingOperation*)));
+    QCOMPARE(mLoop->exec(), 0);
+
+    QCOMPARE(cliCM->supportedProtocols().size(), 1);
+    QVERIFY(cliCM->hasProtocol(QLatin1String("example")));
+
+    ProtocolInfo protocol = cliCM->protocol(QLatin1String("example"));
+    QVERIFY(protocol.isValid());
+
+    //presence interface
+    PresenceSpecList statuses = protocol.allowedPresenceStatuses();
+    QVERIFY(statuses.isEmpty());
+
+    //TODO properly test statuses
+}
+
+void TestBaseProtocol::cleanup()
+{
+    delete mThreadHelper;
+    cleanupImpl();
+}
+
+void TestBaseProtocol::cleanupTestCase()
+{
+    cleanupTestCaseImpl();
+}
+
+QTEST_MAIN(TestBaseProtocol)
+#include "_gen/base-protocol.cpp.moc.hpp"