Removed limitation on Managed Services2.1.3

It now is possible to register more than one manager interface for a
given D-Bus object path. Also did some random fixes and improvements
wherever I saw them.

Change-Id: I6616ef0bf9e46de99e1fb326f9038545af8af324

41 files changed, 701 insertions, 407 deletions

diff --git a/Makefile.am b/Makefile.am
index f93ac21..5d11387 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -187,6 +187,7 @@ DYNAMIC_LOADING_TEST_SET = \
 
 check_PROGRAMS = \
         DBusManagedTest \
+        DBusObjectManagerStubTest \
         DBusRuntimeTest \
         ${DYNAMIC_LOADING_TEST_SET} \
         DBusMainLoopIntegrationTest \
@@ -205,7 +206,6 @@ check_PROGRAMS = \
         DBusMultipleConnectionTest \
         DBusServicePublisherTest \
         DBusClientIdTest \
-        DBusObjectManagerStubTest \
         DBusSelectiveBroadcastTest
 
 noinst_PROGRAMS = ${check_PROGRAMS}
@@ -221,6 +221,11 @@ DBusManagedTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} ${GLIB_CFLAGS}
 DBusManagedTest_CXXFLAGS = ${GTEST_CXXFLAGS} ${GLIB_CFLAGS}
 DBusManagedTest_LDADD = ${LDADD_FOR_GTEST} ${GLIB_LIBS}
 
+DBusObjectManagerStubTest_SOURCES = src/test/DBusObjectManagerStubTest.cpp
+DBusObjectManagerStubTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
+DBusObjectManagerStubTest_CXXFLAGS = ${GTEST_CXXFLAGS}
+DBusObjectManagerStubTest_LDADD = ${LDADD_FOR_GTEST}
+
 DBusMainLoopIntegrationTest_SOURCES = \
         src/test/DBusMainLoopIntegrationTest.cpp \
         ${TestInterfaceDBusSources}
@@ -362,11 +367,6 @@ DBusClientIdTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
 DBusClientIdTest_CXXFLAGS = ${GTEST_CXXFLAGS}
 DBusClientIdTest_LDADD = ${LDADD_FOR_GTEST}
 
-DBusObjectManagerStubTest_SOURCES = src/test/DBusObjectManagerStubTest.cpp
-DBusObjectManagerStubTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
-DBusObjectManagerStubTest_CXXFLAGS = ${GTEST_CXXFLAGS}
-DBusObjectManagerStubTest_LDADD = ${LDADD_FOR_GTEST}
-
 DBusSelectiveBroadcastTest_SOURCES =  \
         ${TestInterfaceDBusSources} \
         src/test/DBusSelectiveBroadcastTest.cpp
diff --git a/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h b/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h
index d9bb975..456ed8d 100644
--- a/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h
+++ b/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h
@@ -32,7 +32,7 @@ class DBusInstanceAvailabilityStatusChangedEvent:
                 public ProxyManager::InstanceAvailabilityStatusChangedEvent,
                 public DBusProxyConnection::DBusSignalHandler {
  public:
-    DBusInstanceAvailabilityStatusChangedEvent(DBusProxy& dbusProxy, const char* interfaceName) :
+    DBusInstanceAvailabilityStatusChangedEvent(DBusProxy& dbusProxy, const std::string& interfaceName) :
                     dbusProxy_(dbusProxy),
                     observedInterfaceName_(interfaceName) {
     }
diff --git a/src/CommonAPI/DBus/DBusObjectManager.cpp b/src/CommonAPI/DBus/DBusObjectManager.cpp
index 69a4f2a..3525585 100644
--- a/src/CommonAPI/DBus/DBusObjectManager.cpp
+++ b/src/CommonAPI/DBus/DBusObjectManager.cpp
@@ -24,7 +24,7 @@ namespace DBus {
 
 DBusObjectManager::DBusObjectManager(const std::shared_ptr<DBusProxyConnection>& dbusConnection):
         dbusConnection_(dbusConnection),
-        rootDBusObjectManagerStub_("/", dbusConnection) {
+        rootDBusObjectManagerStub_(new DBusObjectManagerStub("/", dbusConnection)) {
 
     if (!dbusConnection->isObjectPathMessageHandlerSet()) {
         dbusConnection->setObjectPathMessageHandler(
@@ -34,7 +34,7 @@ DBusObjectManager::DBusObjectManager(const std::shared_ptr<DBusProxyConnection>&
 
     dbusRegisteredObjectsTable_.insert({
                     DBusInterfaceHandlerPath("/", DBusObjectManagerStub::getInterfaceName()),
-                    &rootDBusObjectManagerStub_ });
+                    rootDBusObjectManagerStub_ });
 }
 
 DBusObjectManager::~DBusObjectManager() {
@@ -45,7 +45,7 @@ DBusObjectManager::~DBusObjectManager() {
     }
 }
 
-bool DBusObjectManager::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) {
+bool DBusObjectManager::registerDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
     const auto& dbusStubAdapterObjectPath = dbusStubAdapter->getObjectPath();
     const auto& dbusStubAdapterInterfaceName = dbusStubAdapter->getInterfaceName();
     DBusInterfaceHandlerPath dbusStubAdapterHandlerPath(dbusStubAdapterObjectPath, dbusStubAdapterInterfaceName);
@@ -54,8 +54,21 @@ bool DBusObjectManager::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter
     objectPathLock_.lock();
     isRegistrationSuccessful = addDBusInterfaceHandler(dbusStubAdapterHandlerPath, dbusStubAdapter);
 
-    if (isRegistrationSuccessful && dbusStubAdapter->hasDBusObjectManagerStub()) {
-        auto dbusObjectManagerStub = dbusStubAdapter->getDBusObjectManagerStub();
+    if (isRegistrationSuccessful && dbusStubAdapter->isManagingInterface()) {
+        auto managerStubIterator = managerStubs_.find(dbusStubAdapterObjectPath);
+        const bool managerStubExists = managerStubIterator != managerStubs_.end();
+
+        if (!managerStubExists) {
+            const std::shared_ptr<DBusObjectManagerStub> newManagerStub = std::make_shared<DBusObjectManagerStub>(dbusStubAdapterObjectPath, dbusStubAdapter->getDBusConnection());
+            auto insertResult = managerStubs_.insert( {dbusStubAdapterObjectPath, {newManagerStub, 1} });
+            assert(insertResult.second);
+            managerStubIterator = insertResult.first;
+        } else {
+            uint32_t& countReferencesToManagerStub = std::get<1>(managerStubIterator->second);
+            ++countReferencesToManagerStub;
+        }
+
+        std::shared_ptr<DBusObjectManagerStub> dbusObjectManagerStub = std::get<0>(managerStubIterator->second);
         assert(dbusObjectManagerStub);
 
         isRegistrationSuccessful = addDBusInterfaceHandler(
@@ -78,7 +91,8 @@ bool DBusObjectManager::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter
     return isRegistrationSuccessful;
 }
 
-bool DBusObjectManager::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) {
+
+bool DBusObjectManager::unregisterDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
     const auto& dbusStubAdapterObjectPath = dbusStubAdapter->getObjectPath();
     const auto& dbusStubAdapterInterfaceName = dbusStubAdapter->getInterfaceName();
     DBusInterfaceHandlerPath dbusStubAdapterHandlerPath(dbusStubAdapterObjectPath, dbusStubAdapterInterfaceName);
@@ -87,16 +101,22 @@ bool DBusObjectManager::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapt
     objectPathLock_.lock();
     isDeregistrationSuccessful = removeDBusInterfaceHandler(dbusStubAdapterHandlerPath, dbusStubAdapter);
 
-    if (isDeregistrationSuccessful && dbusStubAdapter->hasDBusObjectManagerStub()) {
-        auto dbusObjectManagerStub = dbusStubAdapter->getDBusObjectManagerStub();
+    if (isDeregistrationSuccessful && dbusStubAdapter->isManagingInterface()) {
+        auto managerStubIterator = managerStubs_.find(dbusStubAdapterObjectPath);
+        assert(managerStubIterator != managerStubs_.end());
+
+        std::shared_ptr<DBusObjectManagerStub> dbusObjectManagerStub = std::get<0>(managerStubIterator->second);
         assert(dbusObjectManagerStub);
 
-        isDeregistrationSuccessful = removeDBusInterfaceHandler(
-                        { dbusStubAdapterObjectPath, dbusObjectManagerStub->getInterfaceName() }, dbusObjectManagerStub);
+        uint32_t& countReferencesToManagerStub = std::get<1>(managerStubIterator->second);
+        assert(countReferencesToManagerStub > 0);
+        --countReferencesToManagerStub;
 
-        if (!isDeregistrationSuccessful) {
-            const bool isDBusStubAdapterAdded = addDBusInterfaceHandler(dbusStubAdapterHandlerPath, dbusStubAdapter);
-            assert(isDBusStubAdapterAdded);
+        if (countReferencesToManagerStub == 0) {
+            isDeregistrationSuccessful = removeDBusInterfaceHandler(
+                            { dbusStubAdapterObjectPath, dbusObjectManagerStub->getInterfaceName() }, dbusObjectManagerStub);
+            managerStubs_.erase(managerStubIterator);
+            assert(isDeregistrationSuccessful);
         }
     }
 
@@ -112,6 +132,33 @@ bool DBusObjectManager::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapt
     return isDeregistrationSuccessful;
 }
 
+
+bool DBusObjectManager::exportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
+    auto foundManagerStubIterator = managerStubs_.find(parentObjectPath);
+
+    assert(foundManagerStubIterator != managerStubs_.end());
+
+    if (std::get<0>(foundManagerStubIterator->second)->exportManagedDBusStubAdapter(dbusStubAdapter)) {
+        //XXX Other handling necessary?
+        return true;
+    }
+    return false;
+}
+
+
+bool DBusObjectManager::unexportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
+    auto foundManagerStubIterator = managerStubs_.find(parentObjectPath);
+
+    assert(foundManagerStubIterator != managerStubs_.end());
+
+    if (std::get<0>(foundManagerStubIterator->second)->unexportManagedDBusStubAdapter(dbusStubAdapter)) {
+        //XXX Other handling necessary?
+        return true;
+    }
+    return false;
+}
+
+
 bool DBusObjectManager::handleMessage(const DBusMessage& dbusMessage) {
     const char* objectPath = dbusMessage.getObjectPath();
     const char* interfaceName = dbusMessage.getInterfaceName();
@@ -127,7 +174,7 @@ bool DBusObjectManager::handleMessage(const DBusMessage& dbusMessage) {
     bool dbusMessageHandled = false;
 
     if (foundDBusInterfaceHandler) {
-        DBusInterfaceHandler* dbusStubAdapterBase = handlerIterator->second;
+        std::shared_ptr<DBusInterfaceHandler> dbusStubAdapterBase = handlerIterator->second;
         dbusMessageHandled = dbusStubAdapterBase->onInterfaceDBusMessage(dbusMessage);
     } else if (dbusMessage.hasInterfaceName("org.freedesktop.DBus.Introspectable")) {
         dbusMessageHandled = onIntrospectableInterfaceDBusMessage(dbusMessage);
@@ -138,11 +185,15 @@ bool DBusObjectManager::handleMessage(const DBusMessage& dbusMessage) {
 }
 
 bool DBusObjectManager::addDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath,
-                                                DBusInterfaceHandler* dbusInterfaceHandler) {
+                                                std::shared_ptr<DBusInterfaceHandler> dbusInterfaceHandler) {
     const auto& dbusRegisteredObjectsTableIter = dbusRegisteredObjectsTable_.find(dbusInterfaceHandlerPath);
     const bool isDBusInterfaceHandlerAlreadyAdded = (dbusRegisteredObjectsTableIter != dbusRegisteredObjectsTable_.end());
 
     if (isDBusInterfaceHandlerAlreadyAdded) {
+        //If another ObjectManager is to be registered, you can go on and just use the first one.
+        if (dbusInterfaceHandlerPath.second == "org.freedesktop.DBus.ObjectManager") {
+            return true;
+        }
         return false;
     }
 
@@ -153,7 +204,7 @@ bool DBusObjectManager::addDBusInterfaceHandler(const DBusInterfaceHandlerPath&
 }
 
 bool DBusObjectManager::removeDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath,
-                                                   DBusInterfaceHandler* dbusInterfaceHandler) {
+                                                   std::shared_ptr<DBusInterfaceHandler> dbusInterfaceHandler) {
     const auto& dbusRegisteredObjectsTableIter = dbusRegisteredObjectsTable_.find(dbusInterfaceHandlerPath);
     const bool isDBusInterfaceHandlerAdded = (dbusRegisteredObjectsTableIter != dbusRegisteredObjectsTable_.end());
 
@@ -191,7 +242,7 @@ bool DBusObjectManager::onIntrospectableInterfaceDBusMessage(const DBusMessage&
         const DBusInterfaceHandlerPath& handlerPath = registeredObjectsIterator.first;
         const std::string& dbusObjectPath = handlerPath.first;
         const std::string& dbusInterfaceName = handlerPath.second;
-        DBusInterfaceHandler* dbusStubAdapterBase = registeredObjectsIterator.second;
+        std::shared_ptr<DBusInterfaceHandler> dbusStubAdapterBase = registeredObjectsIterator.second;
         std::vector<std::string> elems = CommonAPI::split(dbusObjectPath, '/');
 
         if (dbusMessage.hasObjectPath(dbusObjectPath)) {
diff --git a/src/CommonAPI/DBus/DBusObjectManager.h b/src/CommonAPI/DBus/DBusObjectManager.h
index 130ac0c..c81fea6 100644
--- a/src/CommonAPI/DBus/DBusObjectManager.h
+++ b/src/CommonAPI/DBus/DBusObjectManager.h
@@ -28,36 +28,44 @@ class DBusObjectManager {
     DBusObjectManager(const std::shared_ptr<DBusProxyConnection>&);
     ~DBusObjectManager();
 
-    bool registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter);
-    bool unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter);
+    bool registerDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
+    bool unregisterDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
+
+    //Zusammenfassbar mit "registerDBusStubAdapter"?
+    bool exportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
+    bool unexportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
 
     bool handleMessage(const DBusMessage&);
 
-    inline DBusObjectManagerStub& getRootDBusObjectManagerStub();
+    inline std::shared_ptr<DBusObjectManagerStub> getRootDBusObjectManagerStub();
 
  private:
     // objectPath, interfaceName
     typedef std::pair<std::string, std::string> DBusInterfaceHandlerPath;
 
     bool addDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath,
-                                 DBusInterfaceHandler* dbusInterfaceHandler);
+                                 std::shared_ptr<DBusInterfaceHandler> dbusInterfaceHandler);
 
     bool removeDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath,
-                                    DBusInterfaceHandler* dbusInterfaceHandler);
+                                    std::shared_ptr<DBusInterfaceHandler> dbusInterfaceHandler);
 
     bool onIntrospectableInterfaceDBusMessage(const DBusMessage& callMessage);
 
-    typedef std::unordered_map<DBusInterfaceHandlerPath, DBusInterfaceHandler*> DBusRegisteredObjectsTable;
+    typedef std::unordered_map<DBusInterfaceHandlerPath, std::shared_ptr<DBusInterfaceHandler>> DBusRegisteredObjectsTable;
     DBusRegisteredObjectsTable dbusRegisteredObjectsTable_;
 
-    DBusObjectManagerStub rootDBusObjectManagerStub_;
+    std::shared_ptr<DBusObjectManagerStub> rootDBusObjectManagerStub_;
+
+    typedef std::pair<std::shared_ptr<DBusObjectManagerStub>, uint32_t> ReferenceCountedDBusObjectManagerStub;
+    typedef std::unordered_map<std::string, ReferenceCountedDBusObjectManagerStub> RegisteredObjectManagersTable;
+    RegisteredObjectManagersTable managerStubs_;
 
     std::weak_ptr<DBusProxyConnection> dbusConnection_;
     std::recursive_mutex objectPathLock_;
 };
 
 
-DBusObjectManagerStub& DBusObjectManager::getRootDBusObjectManagerStub() {
+std::shared_ptr<DBusObjectManagerStub> DBusObjectManager::getRootDBusObjectManagerStub() {
     return rootDBusObjectManagerStub_;
 }
 
diff --git a/src/CommonAPI/DBus/DBusObjectManagerStub.cpp b/src/CommonAPI/DBus/DBusObjectManagerStub.cpp
index c574998..5d0f721 100644
--- a/src/CommonAPI/DBus/DBusObjectManagerStub.cpp
+++ b/src/CommonAPI/DBus/DBusObjectManagerStub.cpp
@@ -17,7 +17,7 @@ namespace DBus {
 
 DBusObjectManagerStub::DBusObjectManagerStub(const std::string& dbusObjectPath,
                                              const std::shared_ptr<DBusProxyConnection>& dbusConnection) :
-                dbusConnectionWeakPtr_(dbusConnection),
+                dbusConnection_(dbusConnection),
                 dbusObjectPath_(dbusObjectPath) {
     assert(!dbusObjectPath.empty());
     assert(dbusObjectPath[0] == '/');
@@ -39,22 +39,22 @@ DBusObjectManagerStub::~DBusObjectManagerStub() {
     }
 }
 
-bool DBusObjectManagerStub::exportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) {
-    assert(dbusStubAdapter);
+bool DBusObjectManagerStub::exportManagedDBusStubAdapter(std::shared_ptr<DBusStubAdapter> managedDBusStubAdapter) {
+    assert(managedDBusStubAdapter);
 
     std::lock_guard<std::mutex> dbusObjectManagerStubLock(dbusObjectManagerStubLock_);
 
-    const bool isRegistrationSuccessful = registerDBusStubAdapter(dbusStubAdapter);
+    const bool isRegistrationSuccessful = registerDBusStubAdapter(managedDBusStubAdapter);
     if (!isRegistrationSuccessful) {
         return false;
     }
 
-    auto dbusConnection = dbusConnectionWeakPtr_.lock();
+    auto dbusConnection = dbusConnection_.lock();
     if (dbusConnection && dbusConnection->isConnected()) {
-        const bool isDBusSignalEmitted = emitInterfacesAddedSignal(dbusStubAdapter, dbusConnection);
+        const bool isDBusSignalEmitted = emitInterfacesAddedSignal(managedDBusStubAdapter, dbusConnection);
 
         if (!isDBusSignalEmitted) {
-            unregisterDBusStubAdapter(dbusStubAdapter);
+            unregisterDBusStubAdapter(managedDBusStubAdapter);
             return false;
         }
     }
@@ -62,22 +62,22 @@ bool DBusObjectManagerStub::exportDBusStubAdapter(DBusStubAdapter* dbusStubAdapt
     return true;
 }
 
-bool DBusObjectManagerStub::unexportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) {
-    assert(dbusStubAdapter);
+bool DBusObjectManagerStub::unexportManagedDBusStubAdapter(std::shared_ptr<DBusStubAdapter> managedDBusStubAdapter) {
+    assert(managedDBusStubAdapter);
 
     std::lock_guard<std::mutex> dbusObjectManagerStubLock(dbusObjectManagerStubLock_);
 
-    const bool isRegistrationSuccessful = unregisterDBusStubAdapter(dbusStubAdapter);
+    const bool isRegistrationSuccessful = unregisterDBusStubAdapter(managedDBusStubAdapter);
     if (!isRegistrationSuccessful) {
         return false;
     }
 
-    auto dbusConnection = dbusConnectionWeakPtr_.lock();
+    auto dbusConnection = dbusConnection_.lock();
     if (dbusConnection && dbusConnection->isConnected()) {
-        const bool isDBusSignalEmitted = emitInterfacesRemovedSignal(dbusStubAdapter, dbusConnection);
+        const bool isDBusSignalEmitted = emitInterfacesRemovedSignal(managedDBusStubAdapter, dbusConnection);
 
         if (!isDBusSignalEmitted) {
-            registerDBusStubAdapter(dbusStubAdapter);
+            registerDBusStubAdapter(managedDBusStubAdapter);
             return false;
         }
     }
@@ -85,7 +85,7 @@ bool DBusObjectManagerStub::unexportDBusStubAdapter(DBusStubAdapter* dbusStubAda
     return true;
 }
 
-bool DBusObjectManagerStub::isDBusStubAdapterExported(DBusStubAdapter* dbusStubAdapter) {
+bool DBusObjectManagerStub::isDBusStubAdapterExported(std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
     assert(dbusStubAdapter);
 
     const auto& dbusObjectPath = dbusStubAdapter->getObjectPath();
@@ -112,7 +112,7 @@ bool DBusObjectManagerStub::isDBusStubAdapterExported(DBusStubAdapter* dbusStubA
     return isRegisteredDBusInterfaceName;
 }
 
-bool DBusObjectManagerStub::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) {
+bool DBusObjectManagerStub::registerDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
     const auto& dbusObjectPath = dbusStubAdapter->getObjectPath();
     const auto& dbusInterfaceName = dbusStubAdapter->getInterfaceName();
     const auto& registeredDBusObjectPathIterator = registeredDBusObjectPathsMap_.find(dbusObjectPath);
@@ -138,7 +138,7 @@ bool DBusObjectManagerStub::registerDBusStubAdapter(DBusStubAdapter* dbusStubAda
     return isRegisterationSuccessful;
 }
 
-bool DBusObjectManagerStub::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) {
+bool DBusObjectManagerStub::unregisterDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter) {
     const auto& dbusObjectPath = dbusStubAdapter->getObjectPath();
     const auto& dbusInterfaceName = dbusStubAdapter->getInterfaceName();
     const auto& registeredDBusObjectPathIterator = registeredDBusObjectPathsMap_.find(dbusObjectPath);
@@ -169,7 +169,7 @@ bool DBusObjectManagerStub::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubA
 }
 
 
-bool DBusObjectManagerStub::emitInterfacesAddedSignal(DBusStubAdapter* dbusStubAdapter,
+bool DBusObjectManagerStub::emitInterfacesAddedSignal(std::shared_ptr<DBusStubAdapter> dbusStubAdapter,
                                                       const std::shared_ptr<DBusProxyConnection>& dbusConnection) const {
     assert(dbusConnection);
     assert(dbusConnection->isConnected());
@@ -182,7 +182,7 @@ bool DBusObjectManagerStub::emitInterfacesAddedSignal(DBusStubAdapter* dbusStubA
         { dbusStubInterfaceName, DBusPropertiesChangedDict() }
     });
 
-    if (dbusStubAdapter->hasDBusObjectManagerStub()) {
+    if (dbusStubAdapter->isManagingInterface()) {
         dbusInterfacesAndPropertiesDict.insert({ getInterfaceName(), DBusPropertiesChangedDict() });
     }
 
@@ -194,7 +194,7 @@ bool DBusObjectManagerStub::emitInterfacesAddedSignal(DBusStubAdapter* dbusStubA
     return dbusSignalEmitted;
 }
 
-bool DBusObjectManagerStub::emitInterfacesRemovedSignal(DBusStubAdapter* dbusStubAdapter,
+bool DBusObjectManagerStub::emitInterfacesRemovedSignal(std::shared_ptr<DBusStubAdapter> dbusStubAdapter,
                                                         const std::shared_ptr<DBusProxyConnection>& dbusConnection) const {
     assert(dbusConnection);
     assert(dbusConnection->isConnected());
@@ -205,7 +205,7 @@ bool DBusObjectManagerStub::emitInterfacesRemovedSignal(DBusStubAdapter* dbusStu
     DBusOutputStream dbusOutputStream(dbusSignal);
     std::vector<std::string> removedInterfaces({ { dbusStubInterfaceName } });
 
-    if (dbusStubAdapter->hasDBusObjectManagerStub()) {
+    if (dbusStubAdapter->isManagingInterface()) {
         removedInterfaces.push_back(getInterfaceName());
     }
 
@@ -232,7 +232,7 @@ const char* DBusObjectManagerStub::getMethodsDBusIntrospectionXmlData() const {
 }
 
 bool DBusObjectManagerStub::onInterfaceDBusMessage(const DBusMessage& dbusMessage) {
-    auto dbusConnection = dbusConnectionWeakPtr_.lock();
+    auto dbusConnection = dbusConnection_.lock();
 
     if (!dbusConnection || !dbusConnection->isConnected()) {
         return false;
@@ -261,7 +261,7 @@ bool DBusObjectManagerStub::onInterfaceDBusMessage(const DBusMessage& dbusMessag
 
             dbusInterfacesAndPropertiesDict.insert({ registeredDBusInterfaceName, DBusPropertiesChangedDict() });
 
-            if (registeredDBusStubAdapter->hasDBusObjectManagerStub()) {
+            if (registeredDBusStubAdapter->isManagingInterface()) {
                 dbusInterfacesAndPropertiesDict.insert({ getInterfaceName(), DBusPropertiesChangedDict() });
             }
         }
diff --git a/src/CommonAPI/DBus/DBusObjectManagerStub.h b/src/CommonAPI/DBus/DBusObjectManagerStub.h
index 42db8e3..7335602 100644
--- a/src/CommonAPI/DBus/DBusObjectManagerStub.h
+++ b/src/CommonAPI/DBus/DBusObjectManagerStub.h
@@ -7,20 +7,6 @@
 #ifndef COMMONAPI_DBUS_DBUS_FREEDESKTOP_OBJECT_MANAGER_STUB_H_
 #define COMMONAPI_DBUS_DBUS_FREEDESKTOP_OBJECT_MANAGER_STUB_H_
 
-// TODO rename DBusObjectManager to DBusStubManager
-
-// TODO proxy/client logic simply instantiates DBusObjectManagerProxy
-//      with the object path of the currently instantiated proxy. That
-//      way asking about available instances is a matter of calling
-//      getManagedObjects(). Maybe we'll also have to cache within the
-//      proxy like the service registry is doing.
-
-// TODO Service Discovery
-//      - first detect all objects of a service via the Introspectible interface (like d-feet does).
-//      - Introspectible is less efficient than a global ObjectManager but a global ObjectManager
-//        conflicts with local ones, so we can't intentionally have one. The tradeoff is efficiency for correctness
-//      - Register for all InterfaceAdded and InterfaceRemoved signals on the bus.
-//      - Handle double InterfaceAdded and InterfaceRemoved signals properly (ignore them!).
 
 #include "DBusInterfaceHandler.h"
 
@@ -57,7 +43,7 @@ class DBusStubAdapter;
  */
 class DBusObjectManagerStub: public DBusInterfaceHandler {
  public:
-    // XXX serialization trick: use bool instead of variant since we never serialize it
+    // serialization trick: use bool instead of variant since we never serialize it
     typedef std::unordered_map<std::string, bool> DBusPropertiesChangedDict;
     typedef std::unordered_map<std::string, DBusPropertiesChangedDict> DBusInterfacesAndPropertiesDict;
     typedef std::unordered_map<std::string, DBusInterfacesAndPropertiesDict> DBusObjectPathAndInterfacesDict;
@@ -88,7 +74,7 @@ class DBusObjectManagerStub: public DBusInterfaceHandler {
      * @see CommonAPI::ServicePublisher
      * @see DBusObjectManager
      */
-    bool exportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter);
+    bool exportManagedDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
 
     /**
      * Unexport DBusStubAdapter instance from this DBusObjectManagerStub instance.
@@ -104,9 +90,9 @@ class DBusObjectManagerStub: public DBusInterfaceHandler {
      *
      * @see exportDBusStubAdapter()
      */
-    bool unexportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter);
+    bool unexportManagedDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
 
-    bool isDBusStubAdapterExported(DBusStubAdapter* dbusStubAdapter);
+    bool isDBusStubAdapterExported(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
 
     inline const std::string& getDBusObjectPath() const;
     inline static const char* getInterfaceName();
@@ -115,19 +101,19 @@ class DBusObjectManagerStub: public DBusInterfaceHandler {
     virtual bool onInterfaceDBusMessage(const DBusMessage& dbusMessage);
 
  private:
-    bool registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter);
-    bool unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter);
+    bool registerDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
+    bool unregisterDBusStubAdapter(std::shared_ptr<DBusStubAdapter> dbusStubAdapter);
 
-    bool emitInterfacesAddedSignal(DBusStubAdapter* dbusStubAdapter,
+    bool emitInterfacesAddedSignal(std::shared_ptr<DBusStubAdapter> dbusStubAdapter,
                                    const std::shared_ptr<DBusProxyConnection>& dbusConnection) const;
 
-    bool emitInterfacesRemovedSignal(DBusStubAdapter* dbusStubAdapter,
+    bool emitInterfacesRemovedSignal(std::shared_ptr<DBusStubAdapter> dbusStubAdapter,
                                      const std::shared_ptr<DBusProxyConnection>& dbusConnection) const;
 
     std::string dbusObjectPath_;
-    std::weak_ptr<DBusProxyConnection> dbusConnectionWeakPtr_;
+    std::weak_ptr<DBusProxyConnection> dbusConnection_;
 
-    typedef std::unordered_map<std::string, DBusStubAdapter*> DBusInterfacesMap;
+    typedef std::unordered_map<std::string, std::shared_ptr<DBusStubAdapter>> DBusInterfacesMap;
     typedef std::unordered_map<std::string, DBusInterfacesMap> DBusObjectPathsMap;
     DBusObjectPathsMap registeredDBusObjectPathsMap_;
 
diff --git a/src/CommonAPI/DBus/DBusProxyManager.cpp b/src/CommonAPI/DBus/DBusProxyManager.cpp
index 7765532..b8ba87e 100644
--- a/src/CommonAPI/DBus/DBusProxyManager.cpp
+++ b/src/CommonAPI/DBus/DBusProxyManager.cpp
@@ -13,12 +13,12 @@ namespace DBus {
 
 
 DBusProxyManager::DBusProxyManager(DBusProxy& dbusProxy,
-                                   const char* interfaceName,
-                                   const std::shared_ptr<DBusFactory>& factory) :
+                                   const std::string& interfaceId,
+                                   const std::shared_ptr<DBusFactory> factory) :
                 dbusProxy_(dbusProxy),
-                dbusInstanceAvailabilityStatusEvent_(dbusProxy, interfaceName),
+                dbusInstanceAvailabilityStatusEvent_(dbusProxy, interfaceId),
                 factory_(factory),
-                interfaceName_(interfaceName) ,
+                interfaceId_(interfaceId),
                 registry_(dbusProxy.getDBusConnection()->getDBusServiceRegistry())
 
 { }
@@ -41,12 +41,10 @@ void DBusProxyManager::getAvailableInstances(CommonAPI::CallStatus& callStatus,
                                     dbusProxy_,
                                     DBusObjectManagerStub::getInterfaceName(),
                                     "GetManagedObjects",
-                                    "a{oa{sa{sv}}}",
+                                    "",
                                     callStatus,
                                     dbusObjectPathAndInterfacesDict);
 
-
-
     if (callStatus == CallStatus::SUCCESS) {
         translateCommonApiAddresses(dbusObjectPathAndInterfacesDict, availableInstances);
     }
@@ -75,7 +73,7 @@ void DBusProxyManager::getInstanceAvailabilityStatus(const std::string& instance
                                                      AvailabilityStatus& availabilityStatus) {
 
     std::stringstream ss;
-    ss << "local:" << interfaceName_ << ":" << instanceAddress;
+    ss << "local:" << interfaceId_ << ":" << instanceAddress;
 
     std::string interfaceName;
     std::string connectionName;
@@ -101,7 +99,7 @@ SubscriptionStatus DBusProxyManager::instanceAliveAsyncCallback(const Availabili
 std::future<CallStatus> DBusProxyManager::getInstanceAvailabilityStatusAsync(const std::string& instanceAddress,
                                                                              GetInstanceAvailabilityStatusCallback callback) {
     std::stringstream ss;
-    ss << "local:" << interfaceName_ << ":" << instanceAddress;
+    ss << "local:" << interfaceId_ << ":" << instanceAddress;
 
 
     std::shared_ptr<std::promise<CallStatus> > promise = std::make_shared<std::promise<CallStatus>>();
@@ -122,28 +120,31 @@ DBusProxyManager::InstanceAvailabilityStatusChangedEvent& DBusProxyManager::getI
 }
 
 void DBusProxyManager::translateCommonApiAddresses(const DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict,
-                                                   std::vector<std::string>& commonApiAddresses) {
+                                                   std::vector<std::string>& instanceIds) {
     for (const auto& dbusObjectPathIter : dbusObjectPathAndInterfacesDict) {
         const std::string& dbusObjectPath = dbusObjectPathIter.first;
         const auto& dbusInterfacesDict = dbusObjectPathIter.second;
 
         for (const auto& dbusInterfaceIter : dbusInterfacesDict) {
             const std::string dbusInterfaceName = dbusInterfaceIter.first;
-            std::string commonApiAddress;
+            std::string instanceId;
 
             DBusAddressTranslator::getInstance().searchForCommonAddress(
                             dbusInterfaceName,
                             dbusProxy_.getDBusBusName(),
                             dbusObjectPath,
-                            commonApiAddress);
+                            instanceId);
+
+            auto pos = instanceId.find_last_of(':');
+            instanceId = instanceId.substr(pos + 1, instanceId.size());
 
-            commonApiAddresses.push_back(commonApiAddress);
+            instanceIds.push_back(instanceId);
         }
     }
 }
 
-std::shared_ptr<Proxy> DBusProxyManager::createProxy(const std::string& instanceName) {
-    return factory_->createProxy(interfaceName_, instanceName, interfaceName_, "local");
+std::shared_ptr<Proxy> DBusProxyManager::createProxy(const std::string& instanceId) {
+    return factory_->createProxy(interfaceId_.c_str(), instanceId, interfaceId_, "local");
 }
 
 
diff --git a/src/CommonAPI/DBus/DBusProxyManager.h b/src/CommonAPI/DBus/DBusProxyManager.h
index bbef57f..73f612f 100644
--- a/src/CommonAPI/DBus/DBusProxyManager.h
+++ b/src/CommonAPI/DBus/DBusProxyManager.h
@@ -30,7 +30,9 @@ namespace DBus {
 
 class DBusProxyManager: public ProxyManager {
  public:
-    DBusProxyManager(DBusProxy& dbusProxy, const char* interfaceName, const std::shared_ptr<DBusFactory>& factory);
+    DBusProxyManager(DBusProxy& dbusProxy,
+                     const std::string& interfaceName,
+                     const std::shared_ptr<DBusFactory> factory);
 
     virtual void getAvailableInstances(CommonAPI::CallStatus&, std::vector<std::string>& availableInstances);
 	virtual std::future<CallStatus> getAvailableInstancesAsync(GetAvailableInstancesCallback callback);
@@ -44,7 +46,7 @@ class DBusProxyManager: public ProxyManager {
 
     virtual InstanceAvailabilityStatusChangedEvent& getInstanceAvailabilityStatusChangedEvent();
  protected:
-    virtual std::shared_ptr<Proxy> createProxy(const std::string& instanceName);
+    virtual std::shared_ptr<Proxy> createProxy(const std::string& instanceId);
  private:
 
     void instancesAsyncCallback(const CommonAPI::CallStatus& status,
@@ -56,13 +58,14 @@ class DBusProxyManager: public ProxyManager {
                                     std::shared_ptr<std::promise<CallStatus> >& callStatus);
 
     void translateCommonApiAddresses(const DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict,
-                                     std::vector<std::string>& commonApiAddresses);
+                                     std::vector<std::string>& instanceIds);
 
     DBusProxy& dbusProxy_;
     DBusInstanceAvailabilityStatusChangedEvent dbusInstanceAvailabilityStatusEvent_;
     const std::shared_ptr<DBusFactory> factory_;
     const std::shared_ptr<DBusServiceRegistry> registry_;
-    const char* interfaceName_;
+
+    const std::string interfaceId_;
 };
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusServicePublisher.cpp b/src/CommonAPI/DBus/DBusServicePublisher.cpp
index 77c9647..6f6a4c7 100644
--- a/src/CommonAPI/DBus/DBusServicePublisher.cpp
+++ b/src/CommonAPI/DBus/DBusServicePublisher.cpp
@@ -26,14 +26,14 @@ std::shared_ptr<DBusServicePublisher> DBusServicePublisher::getInstance() {
 bool DBusServicePublisher::registerService(const std::shared_ptr<DBusStubAdapter>& dbusStubAdapter) {
     auto serviceAddress = dbusStubAdapter->getAddress();
     const auto& dbusConnection = dbusStubAdapter->getDBusConnection();
-    DBusObjectManagerStub& rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
-    const bool isManagedRegistrationSuccessfull = registerManagedService(dbusStubAdapter);
+    std::shared_ptr<DBusObjectManagerStub> rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
+    const bool isRegistrationAtManagerSuccessfull = registerManagedService(dbusStubAdapter);
 
-    if (!isManagedRegistrationSuccessfull) {
+    if (!isRegistrationAtManagerSuccessfull) {
         return false;
     }
 
-    const bool isServiceExportSuccessful = rootDBusObjectManagerStub.exportDBusStubAdapter(dbusStubAdapter.get());
+    const bool isServiceExportSuccessful = rootDBusObjectManagerStub->exportManagedDBusStubAdapter(dbusStubAdapter);
     if (!isServiceExportSuccessful) {
         const bool isManagedDeregistrationSuccessfull = unregisterManagedService(serviceAddress);
         assert(isManagedDeregistrationSuccessfull);
@@ -70,6 +70,7 @@ bool DBusServicePublisher::registerService(const std::shared_ptr<StubBase>& stub
     return isRegistrationSuccessful;
 }
 
+
 bool DBusServicePublisher::unregisterService(const std::string& serviceAddress) {
     auto registeredServiceIterator = registeredServices_.find(serviceAddress);
     const bool isServiceAddressRegistered = (registeredServiceIterator != registeredServices_.end());
@@ -80,11 +81,11 @@ bool DBusServicePublisher::unregisterService(const std::string& serviceAddress)
 
     const auto& registeredDBusStubAdapter = registeredServiceIterator->second;
     const auto& dbusConnection = registeredDBusStubAdapter->getDBusConnection();
-    auto& rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
-    const bool isRootService = rootDBusObjectManagerStub.isDBusStubAdapterExported(registeredDBusStubAdapter.get());
+    std::shared_ptr<DBusObjectManagerStub> rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
+    const bool isRootService = rootDBusObjectManagerStub->isDBusStubAdapterExported(registeredDBusStubAdapter);
     registeredDBusStubAdapter->deactivateManagedInstances();
     if (isRootService) {
-        const bool isUnexportSuccessfull = rootDBusObjectManagerStub.unexportDBusStubAdapter(registeredDBusStubAdapter.get());
+        const bool isUnexportSuccessfull = rootDBusObjectManagerStub->unexportManagedDBusStubAdapter(registeredDBusStubAdapter);
         assert(isUnexportSuccessfull);
 
         unregisterManagedService(registeredServiceIterator);
@@ -93,6 +94,7 @@ bool DBusServicePublisher::unregisterService(const std::string& serviceAddress)
     return isRootService;
 }
 
+
 bool DBusServicePublisher::registerManagedService(const std::shared_ptr<DBusStubAdapter>& managedDBusStubAdapter) {
     auto serviceAddress = managedDBusStubAdapter->getAddress();
     const auto& insertResult = registeredServices_.insert( {serviceAddress, managedDBusStubAdapter} );
@@ -105,7 +107,7 @@ bool DBusServicePublisher::registerManagedService(const std::shared_ptr<DBusStub
 
     const auto& dbusConnection = managedDBusStubAdapter->getDBusConnection();
     const auto dbusObjectManager = dbusConnection->getDBusObjectManager();
-    const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(managedDBusStubAdapter.get());
+    const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(managedDBusStubAdapter);
     if (!isDBusObjectRegistrationSuccessful) {
         registeredServices_.erase(insertIter);
         return false;
@@ -114,7 +116,7 @@ bool DBusServicePublisher::registerManagedService(const std::shared_ptr<DBusStub
     const auto& dbusServiceName = managedDBusStubAdapter->getDBusName();
     const bool isServiceNameAcquired = dbusConnection->requestServiceNameAndBlock(dbusServiceName);
     if (!isServiceNameAcquired) {
-        const bool isDBusObjectDeregistrationSuccessful = dbusObjectManager->unregisterDBusStubAdapter(managedDBusStubAdapter.get());
+        const bool isDBusObjectDeregistrationSuccessful = dbusObjectManager->unregisterDBusStubAdapter(managedDBusStubAdapter);
         assert(isDBusObjectDeregistrationSuccessful);
 
         registeredServices_.erase(insertIter);
@@ -123,6 +125,7 @@ bool DBusServicePublisher::registerManagedService(const std::shared_ptr<DBusStub
     return isServiceNameAcquired;
 }
 
+
 bool DBusServicePublisher::unregisterManagedService(const std::string& serviceAddress) {
     auto registeredServiceIterator = registeredServices_.find(serviceAddress);
     const bool isServiceAddressRegistered = (registeredServiceIterator != registeredServices_.end());
@@ -140,7 +143,7 @@ void DBusServicePublisher::unregisterManagedService(DBusServicesMap::iterator& m
     const auto dbusObjectManager = dbusConnection->getDBusObjectManager();
     const auto& dbusServiceName = registeredDbusStubAdapter->getDBusName();
 
-    const bool isDBusStubAdapterUnregistered = dbusObjectManager->unregisterDBusStubAdapter(registeredDbusStubAdapter.get());
+    const bool isDBusStubAdapterUnregistered = dbusObjectManager->unregisterDBusStubAdapter(registeredDbusStubAdapter);
     assert(isDBusStubAdapterUnregistered);
 
     dbusConnection->releaseServiceName(dbusServiceName);
diff --git a/src/CommonAPI/DBus/DBusStubAdapter.cpp b/src/CommonAPI/DBus/DBusStubAdapter.cpp
index d0367b3..eb187ef 100644
--- a/src/CommonAPI/DBus/DBusStubAdapter.cpp
+++ b/src/CommonAPI/DBus/DBusStubAdapter.cpp
@@ -24,7 +24,7 @@ DBusStubAdapter::DBusStubAdapter(const std::shared_ptr<DBusFactory>& factory,
                                  const std::string& dbusBusName,
                                  const std::string& dbusObjectPath,
                                  const std::shared_ptr<DBusProxyConnection>& dbusConnection,
-                                 DBusObjectManagerStub* managerStub) :
+                                 const bool isManagingInterface) :
                 factory_(factory),
                 commonApiDomain_(split(commonApiAddress, ':')[0]),
                 commonApiServiceId_(split(commonApiAddress, ':')[1]),
@@ -33,7 +33,7 @@ DBusStubAdapter::DBusStubAdapter(const std::shared_ptr<DBusFactory>& factory,
                 dbusBusName_(dbusBusName),
                 dbusObjectPath_(dbusObjectPath),
                 dbusConnection_(dbusConnection),
-                managerStub(managerStub) {
+                isManagingInterface_(isManagingInterface) {
 
     assert(!dbusBusName_.empty());
     assert(!dbusInterfaceName_.empty());
diff --git a/src/CommonAPI/DBus/DBusStubAdapter.h b/src/CommonAPI/DBus/DBusStubAdapter.h
index 7c365af..ec73067 100644
--- a/src/CommonAPI/DBus/DBusStubAdapter.h
+++ b/src/CommonAPI/DBus/DBusStubAdapter.h
@@ -35,7 +35,7 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter, public DBusInterfa
                     const std::string& dbusBusName,
                     const std::string& dbusObjectPath,
                     const std::shared_ptr<DBusProxyConnection>& dbusConnection,
-                    DBusObjectManagerStub* managerStub = NULL);
+                    const bool isManagingInterface);
 
     virtual ~DBusStubAdapter();
 
@@ -53,8 +53,7 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter, public DBusInterfa
 
     inline const std::shared_ptr<DBusProxyConnection>& getDBusConnection() const;
 
-    inline virtual DBusObjectManagerStub* getDBusObjectManagerStub();
-    inline const bool hasDBusObjectManagerStub();
+    inline const bool isManagingInterface();
 
     virtual const char* getMethodsDBusIntrospectionXmlData() const = 0;
     virtual bool onInterfaceDBusMessage(const DBusMessage& dbusMessage) = 0;
@@ -72,20 +71,16 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter, public DBusInterfa
     const std::string dbusInterfaceName_;
     const std::shared_ptr<DBusProxyConnection> dbusConnection_;
 
-    DBusObjectManagerStub* managerStub;
-
     static const std::string domain_;
 
     const std::shared_ptr<DBusFactory> factory_;
-};
 
+    const bool isManagingInterface_;
+};
 
-DBusObjectManagerStub* DBusStubAdapter::getDBusObjectManagerStub() {
-    return managerStub;
-}
 
-const bool DBusStubAdapter::hasDBusObjectManagerStub() {
-    return (getDBusObjectManagerStub() != NULL);
+const bool DBusStubAdapter::isManagingInterface() {
+    return isManagingInterface_;
 }
 
 const std::string& DBusStubAdapter::getDBusName() const {
diff --git a/src/CommonAPI/DBus/DBusStubAdapterHelper.h b/src/CommonAPI/DBus/DBusStubAdapterHelper.h
index 9507214..54f246a 100644
--- a/src/CommonAPI/DBus/DBusStubAdapterHelper.h
+++ b/src/CommonAPI/DBus/DBusStubAdapterHelper.h
@@ -47,8 +47,8 @@ class DBusStubAdapterHelper: public DBusStubAdapter, public std::enable_shared_f
                           const std::string& dbusObjectPath,
                           const std::shared_ptr<DBusProxyConnection>& dbusConnection,
                           const std::shared_ptr<_StubClass>& stub,
-                          DBusObjectManagerStub* managerStub = NULL):
-                    DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, managerStub),
+                          const bool isManagingInterface):
+                    DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, isManagingInterface),
                     stub_(stub) {
     }
 
diff --git a/src/test/DBusCommunicationTest.cpp b/src/test/DBusCommunicationTest.cpp
index 2ecb697..4f4bb06 100644
--- a/src/test/DBusCommunicationTest.cpp
+++ b/src/test/DBusCommunicationTest.cpp
@@ -336,12 +336,12 @@ class DBusLowLevelCommunicationTest: public ::testing::Test {
         dbusStubAdapter = std::make_shared<commonapi::tests::TestInterfaceDBusStubAdapter>(dummy, commonApiAddress, interfaceName, connectionName, objectPath, dbusConnection, stub);
         dbusStubAdapter->init();
 
-        CommonAPI::DBus::DBusObjectManagerStub& rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
+        std::shared_ptr<CommonAPI::DBus::DBusObjectManagerStub> rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
 
         const auto dbusObjectManager = dbusConnection->getDBusObjectManager();
-        const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(dbusStubAdapter.get());
+        const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(dbusStubAdapter);
 
-        const bool isServiceExportSuccessful = rootDBusObjectManagerStub.exportDBusStubAdapter(dbusStubAdapter.get());
+        const bool isServiceExportSuccessful = rootDBusObjectManagerStub->exportManagedDBusStubAdapter(dbusStubAdapter);
 
         return dbusStubAdapter;
     }
diff --git a/src/test/DBusManagedTest.cpp b/src/test/DBusManagedTest.cpp
index bbbcef2..16e74a7 100644
--- a/src/test/DBusManagedTest.cpp
+++ b/src/test/DBusManagedTest.cpp
@@ -24,31 +24,53 @@
 #include "commonapi/tests/managed/RootInterfaceStubDefault.h"
 #include "commonapi/tests/managed/LeafInterfaceStubDefault.h"
 
+#include "commonapi/tests/managed/RootInterfaceProxy.h"
 #include "commonapi/tests/managed/RootInterfaceDBusProxy.h"
 #include "commonapi/tests/managed/LeafInterfaceProxy.h"
 
-
 #include <gtest/gtest.h>
 #include <algorithm>
 #include <array>
 #include <memory>
 
-static const std::string rootAddress = "local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterface";
+static const std::string rootAddress =
+                "local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterface";
 static const std::string leafInstance = "commonapi.tests.managed.RootInterface.LeafInterface";
 static const std::string leafAddress = "local:commonapi.tests.managed.LeafInterface:" + leafInstance;
 
 static const std::string dbusServiceName = "CommonAPI.DBus.DBusObjectManagerStubTest";
-static const std::string& dbusObjectManagerStubPath = "/commonapi/dbus/test/DBusObjectManagerStub";
-static const std::string& managedDBusObjectPathPrefix = "/commonapi/dbus/test/DBusObjectManagerStub/ManagedObject";
+
+static const std::string rootInterfaceName = "/commonapi/tests/managed/RootInterface";
+static const std::string rootObjectPath = "/commonapi/tests/managed/RootInterface";
+
+
+const CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict getManagedObjects(const std::string& dbusObjectPath,
+                                                                                                std::shared_ptr<CommonAPI::DBus::DBusConnection> connection) {
+    auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall(
+                    dbusServiceName,
+                    dbusObjectPath,
+                    CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName(),
+                    "GetManagedObjects");
+
+    CommonAPI::DBus::DBusError dbusError;
+    auto dbusMessageReply = connection->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError);
+
+    CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply);
+
+    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
+    dbusInputStream >> dbusObjectPathAndInterfacesDict;
+
+    return dbusObjectPathAndInterfacesDict;
+}
 
 
 class DBusManagedTest: public ::testing::Test {
- protected:
+protected:
     virtual void SetUp() {
-        leafStatus = CommonAPI::AvailabilityStatus::UNKNOWN;
-        runtime = std::dynamic_pointer_cast<CommonAPI::DBus::DBusRuntime>(CommonAPI::Runtime::load());
-        serviceFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(runtime->createFactory());
-        clientFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(runtime->createFactory());
+        leafStatus_ = CommonAPI::AvailabilityStatus::UNKNOWN;
+        runtime_ = std::dynamic_pointer_cast<CommonAPI::DBus::DBusRuntime>(CommonAPI::Runtime::load());
+        serviceFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(runtime_->createFactory());
+        clientFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(runtime_->createFactory());
 
         proxyDBusConnection_ = CommonAPI::DBus::DBusConnection::getSessionBus();
         ASSERT_TRUE(proxyDBusConnection_->connect());
@@ -60,7 +82,7 @@ class DBusManagedTest: public ::testing::Test {
     }
 
     virtual void TearDown() {
-        runtime->getServicePublisher()->unregisterService(rootAddress);
+        runtime_->getServicePublisher()->unregisterService(rootAddress);
 
         stubDBusConnection_->disconnect();
         stubDBusConnection_.reset();
@@ -69,105 +91,57 @@ class DBusManagedTest: public ::testing::Test {
         proxyDBusConnection_.reset();
     }
 
-    std::shared_ptr<CommonAPI::DBus::DBusRuntime> runtime;
+    std::shared_ptr<CommonAPI::DBus::DBusRuntime> runtime_;
     std::shared_ptr<CommonAPI::DBus::DBusFactory> serviceFactory;
     std::shared_ptr<CommonAPI::DBus::DBusFactory> clientFactory;
 
-    CommonAPI::AvailabilityStatus leafStatus;
-
-    void getManagedObjects(const std::string& dbusObjectPath,
-                           CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict) {
-        auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall(
-                        dbusServiceName,
-                        dbusObjectPath,
-                        CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName(),
-                        "GetManagedObjects");
-
-        CommonAPI::DBus::DBusError dbusError;
-        auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError);
-
-        ASSERT_FALSE(dbusError) << dbusError.getMessage();
-        ASSERT_TRUE(dbusMessageReply.isMethodReturnType());
-        ASSERT_TRUE(dbusMessageReply.hasSignature("a{oa{sa{sv}}}"));
-
-        CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply);
-
-        dbusInputStream >> dbusObjectPathAndInterfacesDict;
-        ASSERT_FALSE(dbusInputStream.hasError());
-    }
-
-    void getIntrospectionData(const std::string& dbusObjectPath, std::string& introspectionDataXml) {
-        auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall(
-                        dbusServiceName,
-                        dbusObjectPath,
-                        "org.freedesktop.DBus.Introspectable",
-                        "Introspect");
-        CommonAPI::DBus::DBusError dbusError;
-        auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError);
-
-        ASSERT_FALSE(dbusError) << dbusError.getMessage();
-        ASSERT_TRUE(dbusMessageReply.isMethodReturnType());
-        ASSERT_TRUE(dbusMessageReply.hasSignature("s"));
-
-        CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply);
-
-        dbusInputStream >> introspectionDataXml;
-        ASSERT_FALSE(dbusInputStream.hasError());
-    }
-
     std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyDBusConnection_;
     std::shared_ptr<CommonAPI::DBus::DBusConnection> stubDBusConnection_;
- public:
-    //Callback on singnal...
-    void managedObjectSignalled(std::string address, CommonAPI::AvailabilityStatus status) {
-        //ASSERT_EQ(address, leafAddress);
-        leafStatus = status;
-    }
 
+    CommonAPI::AvailabilityStatus leafStatus_;
 
+public:
+    void managedObjectSignalled(std::string address, CommonAPI::AvailabilityStatus status) {
+        leafStatus_ = status;
+    }
 };
 
 TEST_F(DBusManagedTest, RegisterRoot) {
     auto rootStub = std::make_shared<commonapi::tests::managed::RootInterfaceStubDefault>();
-    runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
+    runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
 
-    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
 
     EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
 
-    runtime->getServicePublisher()->unregisterService(rootAddress);
+    runtime_->getServicePublisher()->unregisterService(rootAddress);
 }
 
-
 TEST_F(DBusManagedTest, RegisterLeafUnmanaged) {
     auto leafStub = std::make_shared<commonapi::tests::managed::LeafInterfaceStubDefault>();
-    runtime->getServicePublisher()->registerService(leafStub, leafAddress, serviceFactory);
+    runtime_->getServicePublisher()->registerService(leafStub, leafAddress, serviceFactory);
 
-    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
 
     EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
 
-    runtime->getServicePublisher()->unregisterService(leafAddress);
+    runtime_->getServicePublisher()->unregisterService(leafAddress);
 }
 
 TEST_F(DBusManagedTest, RegisterLeafManaged) {
-    const char* rootInterfaceName = "/commonapi/tests/managed/RootInterface";
-    const char* rootObjectPath = "/commonapi/tests/managed/RootInterface";
-
     auto rootStub = std::make_shared<commonapi::tests::managed::RootInterfaceStubDefault>();
-    runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
+    runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
 
     std::shared_ptr<commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
                     commonapi::tests::managed::RootInterfaceDBusProxy>(
-                                    clientFactory,
-                                    rootAddress,
-                                    rootInterfaceName,
-                                    dbusServiceName,
-                                    rootObjectPath,
-                                    proxyDBusConnection_
+                    clientFactory,
+                    rootAddress,
+                    rootInterfaceName,
+                    dbusServiceName,
+                    rootObjectPath,
+                    proxyDBusConnection_
                     );
+
     rootProxy->init();
 
     for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
@@ -178,61 +152,55 @@ TEST_F(DBusManagedTest, RegisterLeafManaged) {
     CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface();
     proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(
                     std::bind(&DBusManagedTest::managedObjectSignalled,
-                              this,
-                              std::placeholders::_1,
-                              std::placeholders::_2));
+                                    this,
+                                    std::placeholders::_1,
+                                    std::placeholders::_2));
 
     auto leafStub = std::make_shared<commonapi::tests::managed::LeafInterfaceStubDefault>();
 
     bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
     ASSERT_TRUE(reg);
 
-    for (uint32_t i = 0; leafStatus != CommonAPI::AvailabilityStatus::AVAILABLE && i < 50; ++i) {
-        usleep(1000);
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::AVAILABLE && i < 50; ++i) {
+        usleep(10 * 1000);
     }
-    ASSERT_TRUE(leafStatus == CommonAPI::AvailabilityStatus::AVAILABLE);
-
-    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
+    ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::AVAILABLE);
 
-    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
     ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
     dbusObjectPathAndInterfacesDict.clear();
-    getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict);
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_);
     ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
 
     bool deregistered = rootStub->deregisterManagedStubLeafInterface(leafInstance);
-    ASSERT_TRUE(deregistered);
+    EXPECT_TRUE(deregistered);
 
-    for (uint32_t i = 0; leafStatus != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) {
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) {
         usleep(10 * 1000);
     }
-    ASSERT_TRUE(leafStatus == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+    EXPECT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
 
-    dbusObjectPathAndInterfacesDict.clear();
-    getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict);
-    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_);
+    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
-    runtime->getServicePublisher()->unregisterService(rootAddress);
-    dbusObjectPathAndInterfacesDict.clear();
-    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
-    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    runtime_->getServicePublisher()->unregisterService(rootAddress);
+    dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
+    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
 TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) {
-    const char* rootInterfaceName = "/commonapi/tests/managed/RootInterface";
-    const char* rootObjectPath = "/commonapi/tests/managed/RootInterface";
-
     auto rootStub = std::make_shared<commonapi::tests::managed::RootInterfaceStubDefault>();
-    runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
+    bool success = runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
+    ASSERT_TRUE(success);
 
     std::shared_ptr<commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
                     commonapi::tests::managed::RootInterfaceDBusProxy>(
-                                    clientFactory,
-                                    rootAddress,
-                                    rootInterfaceName,
-                                    dbusServiceName,
-                                    rootObjectPath,
-                                    proxyDBusConnection_
+                    clientFactory,
+                    rootAddress,
+                    rootInterfaceName,
+                    dbusServiceName,
+                    rootObjectPath,
+                    proxyDBusConnection_
                     );
     rootProxy->init();
 
@@ -242,11 +210,16 @@ TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) {
     ASSERT_TRUE(rootProxy->isAvailable());
 
     CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface();
-    proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(std::bind(&DBusManagedTest::managedObjectSignalled, this, std::placeholders::_1, std::placeholders::_2));
+    proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(
+                    std::bind(
+                                    &DBusManagedTest::managedObjectSignalled,
+                                    this,
+                                    std::placeholders::_1,
+                                    std::placeholders::_2));
 
     auto leafStub = std::make_shared<commonapi::tests::managed::LeafInterfaceStubDefault>();
-    bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
-    ASSERT_TRUE(reg);
+    success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
+    ASSERT_TRUE(success);
 
     sleep(2);
 
@@ -263,37 +236,35 @@ TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) {
     std::string outString;
     leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString);
 
-    ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
+    EXPECT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
 
-    bool dereg = rootStub->deregisterManagedStubLeafInterface(leafInstance);
+    success = rootStub->deregisterManagedStubLeafInterface(leafInstance);
+    EXPECT_TRUE(success);
 
-    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    dbusObjectPathAndInterfacesDict.clear();
-    getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict);
-    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_);
+    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
-    runtime->getServicePublisher()->unregisterService(rootAddress);
-    dbusObjectPathAndInterfacesDict.clear();
-    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
-    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    success = runtime_->getServicePublisher()->unregisterService(rootAddress);
+    EXPECT_TRUE(success);
+
+    dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
+    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
 TEST_F(DBusManagedTest, PropagateTeardown) {
-    const char* rootInterfaceName = "/commonapi/tests/managed/RootInterface";
-    const char* rootObjectPath = "/commonapi/tests/managed/RootInterface";
-
     auto rootStub = std::make_shared<commonapi::tests::managed::RootInterfaceStubDefault>();
-    runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
+    bool success = runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory);
 
+    ASSERT_TRUE(success);
 
     std::shared_ptr<commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
                     commonapi::tests::managed::RootInterfaceDBusProxy>(
-                                    clientFactory,
-                                    rootAddress,
-                                    rootInterfaceName,
-                                    dbusServiceName,
-                                    rootObjectPath,
-                                    proxyDBusConnection_
+                    clientFactory,
+                    rootAddress,
+                    rootInterfaceName,
+                    dbusServiceName,
+                    rootObjectPath,
+                    proxyDBusConnection_
                     );
     rootProxy->init();
 
@@ -303,7 +274,12 @@ TEST_F(DBusManagedTest, PropagateTeardown) {
     ASSERT_TRUE(rootProxy->isAvailable());
 
     CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface();
-    proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(std::bind(&DBusManagedTest::managedObjectSignalled, this, std::placeholders::_1, std::placeholders::_2));
+    proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(
+                    std::bind(
+                                    &DBusManagedTest::managedObjectSignalled,
+                                    this,
+                                    std::placeholders::_1,
+                                    std::placeholders::_2));
 
     auto leafStub = std::make_shared<commonapi::tests::managed::LeafInterfaceStubDefault>();
     bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
@@ -327,23 +303,269 @@ TEST_F(DBusManagedTest, PropagateTeardown) {
 
     ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
 
-    bool dereg = runtime->getServicePublisher()->unregisterService(rootAddress);
+    bool dereg = runtime_->getServicePublisher()->unregisterService(rootAddress);
     ASSERT_TRUE(dereg);
 
-    for (uint32_t i = 0; leafStatus != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 100; ++i) {
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 100; ++i) {
         usleep(10 * 1000);
     }
-    ASSERT_TRUE(leafStatus == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+    ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
 
-    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    dbusObjectPathAndInterfacesDict.clear();
-    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
     ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
+class DBusManagedTestExtended: public ::testing::Test {
+protected:
+    virtual void SetUp() {
+        runtime_ = std::dynamic_pointer_cast<CommonAPI::DBus::DBusRuntime>(CommonAPI::Runtime::load());
+        serviceFactory_ = runtime_->createFactory();
+        clientFactory_ = runtime_->createFactory();
+
+        manualTestDBusConnection_ = CommonAPI::DBus::DBusConnection::getSessionBus();
+        ASSERT_TRUE(manualTestDBusConnection_->connect());
+
+        auto dbusServiceFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(serviceFactory_);
+        auto stubDBusConnection = dbusServiceFactory->getDbusConnection();
+        ASSERT_TRUE(stubDBusConnection->connect());
+        ASSERT_TRUE(stubDBusConnection->requestServiceNameAndBlock(dbusServiceName));
+    }
+
+    virtual void TearDown() {
+        for (auto it: rootStubs_) {
+            runtime_->getServicePublisher()->unregisterService(it.first);
+        }
+
+        rootStubs_.clear();
+        rootProxies_.clear();
+
+        auto dbusServiceFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(serviceFactory_);
+        auto stubDBusConnection = dbusServiceFactory->getDbusConnection();
+        ASSERT_TRUE(stubDBusConnection->releaseServiceName(dbusServiceName));
+
+        usleep(50000);
+    }
+
+    inline const std::string getSuffixedRootAddress(const std::string& suffix) {
+        return "local:commonapi.tests.managed.RootInterface" + suffix + ":commonapi.tests.managed.RootInterface";
+    }
+
+    inline const bool registerRootStubForSuffix(const std::string& suffix) {
+        std::shared_ptr<commonapi::tests::managed::RootInterfaceStubDefault> rootStub = std::make_shared<
+                        commonapi::tests::managed::RootInterfaceStubDefault>();
+        const std::string rootAddress = getSuffixedRootAddress(suffix);
+        rootStubs_.insert( {rootAddress, rootStub} );
+        return runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory_);
+    }
+
+    inline void createRootProxyForSuffix(const std::string& suffix) {
+        rootProxies_.push_back(clientFactory_->buildProxy<commonapi::tests::managed::RootInterfaceProxy>(getSuffixedRootAddress(suffix)));
+    }
+
+    template<typename _ProxyType>
+    bool waitForAllProxiesToBeAvailable(const std::vector<_ProxyType>& dbusProxies) {
+        bool allAreAvailable = false;
+        for (size_t i = 0; i < 200 && !allAreAvailable; i++) {
+            allAreAvailable = std::all_of(
+                    dbusProxies.begin(),
+                    dbusProxies.end(),
+                    [](const _ProxyType& proxy) {
+                        return proxy->isAvailable();
+                    });
+            usleep(10 * 1000);
+        }
+        return allAreAvailable;
+    }
+
+    bool registerXLeafStubsForAllRoots(uint32_t x, bool doSubscriptionsForLeafNotifications) {
+        bool success = true;
+        bool expectedValueForRegistration = true;
+        for (auto rootStubIterator: rootStubs_) {
+            if (doSubscriptionsForLeafNotifications) {
+                // CommonAPI::ProxyManager& proxyManagerForLeafInterface = rootManagerProxyArray[i]->getProxyManagerLeafInterface();
+                // auto subscription = subscribeWithAvailabilityFlag(proxyManagerForLeafInterface, stati[i]);
+                // subscriptions.push_back(subscription);
+            }
+            for (uint32_t i = 0; i < x; i++) {
+                std::shared_ptr<commonapi::tests::managed::LeafInterfaceStubDefault> leafStub = std::make_shared<
+                                commonapi::tests::managed::LeafInterfaceStubDefault>();
+                success &= (rootStubIterator.second->registerManagedStubLeafInterfaceAutoInstance(leafStub) == expectedValueForRegistration);
+            }
+            //As all root interfaces are registered on the same object path, the leaf interfaces also will be registered with
+            //this same object path as base. The first set of leaf interfaces therefore will be registered successfully.
+            //The second and third set of leaf interfaces use a different object manager that does not know about the already
+            //registered leaf interfaces, and therefore tries to register the same names on the same object paths again.
+            //As of now, this will fail.
+            expectedValueForRegistration = false;
+        }
+        return success;
+    }
+
+    void createXLeafProxiesForAllExistingLeafs() {
+        for (auto rootProxyIterator: rootProxies_) {
+            std::vector<std::shared_ptr<commonapi::tests::managed::LeafInterfaceProxy<>>> leafProxiesForRootX;
+
+            CommonAPI::ProxyManager& leafProxyManager = rootProxyIterator->getProxyManagerLeafInterface();
+            std::vector<std::string> availableInstances;
+            CommonAPI::CallStatus status;
+            leafProxyManager.getAvailableInstances(status, availableInstances);
+
+            for (const std::string& availableInstance: availableInstances) {
+                auto newLeafProxy = leafProxyManager.buildProxy<commonapi::tests::managed::LeafInterfaceProxy>(availableInstance);
+                leafProxiesForRootX.push_back(newLeafProxy);
+            }
+            leafProxies_.push_back(std::move(leafProxiesForRootX));
+        }
+    }
+
+    std::shared_ptr<CommonAPI::DBus::DBusRuntime> runtime_;
+    std::shared_ptr<CommonAPI::Factory> serviceFactory_;
+    std::shared_ptr<CommonAPI::Factory> clientFactory_;
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> manualTestDBusConnection_;
+
+    std::unordered_map<std::string, std::shared_ptr<commonapi::tests::managed::RootInterfaceStubDefault>> rootStubs_;
+    std::vector<std::shared_ptr<commonapi::tests::managed::RootInterfaceProxy<>>> rootProxies_;
+    std::vector<std::vector<std::shared_ptr<commonapi::tests::managed::LeafInterfaceProxy<>>>> leafProxies_;
+};
+
+
+TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPath) {
+    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    ASSERT_TRUE(registerRootStubForSuffix("Two"));
+    ASSERT_TRUE(registerRootStubForSuffix("Three"));
+
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
+    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+}
+
+
+TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPathAndCommunicate) {
+    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    ASSERT_TRUE(registerRootStubForSuffix("Two"));
+    ASSERT_TRUE(registerRootStubForSuffix("Three"));
+
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
+    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+
+    createRootProxyForSuffix("One");
+    createRootProxyForSuffix("Two");
+    createRootProxyForSuffix("Three");
+
+    bool allRootProxiesAreAvailable = waitForAllProxiesToBeAvailable(rootProxies_);
+    ASSERT_TRUE(allRootProxiesAreAvailable);
+
+    CommonAPI::CallStatus callStatus;
+    commonapi::tests::managed::RootInterface::testRootMethodError applicationError;
+    int32_t outInt;
+    std::string outString;
+
+    for (size_t i = 0; i < rootProxies_.size(); ++i) {
+        rootProxies_[i]->testRootMethod(
+                            -5,
+                            std::string("More Cars"),
+                            callStatus,
+                            applicationError,
+                            outInt,
+                            outString);
+        EXPECT_EQ(CommonAPI::CallStatus::SUCCESS, callStatus);
+    }
+}
+
+TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPath) {
+    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    ASSERT_TRUE(registerRootStubForSuffix("Two"));
+    ASSERT_TRUE(registerRootStubForSuffix("Three"));
+
+    bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5, false);
+    ASSERT_TRUE(allLeafStubsWereRegistered);
+
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
+    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+}
+
+TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPathAndCommunicate) {
+    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    ASSERT_TRUE(registerRootStubForSuffix("Two"));
+    ASSERT_TRUE(registerRootStubForSuffix("Three"));
+
+    bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5, false);
+    ASSERT_TRUE(allLeafStubsWereRegistered);
+
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
+    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+
+    createRootProxyForSuffix("One");
+    createRootProxyForSuffix("Two");
+    createRootProxyForSuffix("Three");
+
+    //Check on existence of leaf-stubs
+
+    bool allRootProxiesAreAvailable = waitForAllProxiesToBeAvailable(rootProxies_);
+    ASSERT_TRUE(allRootProxiesAreAvailable);
+
+    usleep(500 * 1000);
+
+    createXLeafProxiesForAllExistingLeafs();
+
+    usleep(500 * 1000);
+
+    ASSERT_EQ(3, leafProxies_.size());
+
+    uint32_t runNr = 1;
+    for (const auto& leafProxiesForCurrentRoot: leafProxies_) {
+        ASSERT_EQ(5, leafProxiesForCurrentRoot.size()) << "in run #" << runNr++;
+
+        bool allLeafProxiesForCurrentRootAreAvailable = waitForAllProxiesToBeAvailable(leafProxiesForCurrentRoot);
+        EXPECT_TRUE(allLeafProxiesForCurrentRootAreAvailable);
+
+        ++runNr;
+    }
+
+//    CommonAPI::AvailabilityStatus stati[3];
+//    std::vector<CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent::Subscription> subscriptions;
+
+    //    auto leafStub = std::make_shared<commonapi::tests::managed::LeafInterfaceStubDefault>();
+    //    bool success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
+    //    ASSERT_TRUE(success);
+    //
+    //    sleep(2);
+    //
+    //    auto leafProxy = proxyManagerLeafInterface.buildProxy<commonapi::tests::managed::LeafInterfaceProxy>(leafInstance);
+    //    for (uint32_t i = 0; !leafProxy->isAvailable() && i < 500; ++i) {
+    //        usleep(10 * 1000);
+    //    }
+    //
+    //    ASSERT_TRUE(leafProxy->isAvailable());
+    //
+    //    CommonAPI::CallStatus callStatus;
+    //    commonapi::tests::managed::LeafInterface::testLeafMethodError error;
+    //    int outInt;
+    //    std::string outString;
+    //    leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString);
+    //
+    //    EXPECT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
+    //
+    //    success = rootStub->deregisterManagedStubLeafInterface(leafInstance);
+    //    EXPECT_TRUE(success);
+    //
+    //    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
+    //    dbusObjectPathAndInterfacesDict.clear();
+    //    getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict);
+    //    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    //
+    //    success = runtime->getServicePublisher()->unregisterService(rootAddress);
+    //    EXPECT_TRUE(success);
+    //
+    //    dbusObjectPathAndInterfacesDict.clear();
+    //    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
+    //    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+}
+
 //XXX: Needs tests for invalid instances for the children.
 //XXX: Also later on need auto generated instance ID test and
-//XXX: Also check transitive teardown
+//XXX: If stub cannot manage, ensure the objectManager interface does not appear on dbus
+//XXX: Tests if configuration file is present
 
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
diff --git a/src/test/DBusObjectManagerStubTest.cpp b/src/test/DBusObjectManagerStubTest.cpp
index 1df20bf..cd14d74 100644
--- a/src/test/DBusObjectManagerStubTest.cpp
+++ b/src/test/DBusObjectManagerStubTest.cpp
@@ -24,22 +24,24 @@
 #include <array>
 #include <memory>
 
-
 static const std::string dbusServiceName = "CommonAPI.DBus.DBusObjectManagerStubTest";
 static const std::string& dbusObjectManagerStubPath = "/commonapi/dbus/test/DBusObjectManagerStub";
 static const std::string& managedDBusObjectPathPrefix = "/commonapi/dbus/test/DBusObjectManagerStub/ManagedObject";
 
-
 class TestDBusStubAdapter: public CommonAPI::DBus::DBusStubAdapter {
- public:
+public:
     TestDBusStubAdapter(const std::shared_ptr<CommonAPI::DBus::DBusFactory> factory,
                         const std::string& dbusObjectPath,
-                        const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection) :
-                    DBusStubAdapter(factory, "local:" + dbusServiceName + ":commonapi.dbus.tests.TestDBusStubAdapter-" + dbusObjectPath,
+                        const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
+                        const bool isManagingInterface) :
+                    DBusStubAdapter(
+                                    factory,
+                                    "local:" + dbusServiceName + ":commonapi.dbus.tests.TestDBusStubAdapter-" + dbusObjectPath,
                                     "commonapi.dbus.tests.TestDBusStubAdapter",
                                     dbusServiceName,
                                     dbusObjectPath,
-                                    dbusConnection) {
+                                    dbusConnection,
+                                    isManagingInterface) {
     }
 
     void deactivateManagedInstances() {
@@ -54,41 +56,38 @@ class TestDBusStubAdapter: public CommonAPI::DBus::DBusStubAdapter {
         return false;
     }
 
-
-
- protected:
+protected:
     TestDBusStubAdapter(const std::shared_ptr<CommonAPI::DBus::DBusFactory> factory,
-                    const std::string& dbusObjectPath,
+                        const std::string& dbusObjectPath,
                         const std::string& dbusInterfaceName,
-                        const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection) :
-                    DBusStubAdapter(factory, "local:" + dbusServiceName + ":" + dbusInterfaceName + "-" + dbusObjectPath,
+                        const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
+                        const bool isManagingInterface) :
+                    DBusStubAdapter(
+                                    factory,
+                                    "local:" + dbusServiceName + ":" + dbusInterfaceName + "-" + dbusObjectPath,
                                     dbusInterfaceName,
                                     dbusServiceName,
                                     dbusObjectPath,
-                                    dbusConnection) {
+                                    dbusConnection,
+                                    isManagingInterface) {
     }
 
-
 };
 
-
 class ManagerTestDBusStubAdapter: public TestDBusStubAdapter {
- public:
-    ManagerTestDBusStubAdapter(const std::shared_ptr<CommonAPI::DBus::DBusFactory> factory, const std::string& dbusObjectPath,
+public:
+    ManagerTestDBusStubAdapter(const std::shared_ptr<CommonAPI::DBus::DBusFactory> factory,
+                               const std::string& dbusObjectPath,
                                const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection) :
-                    TestDBusStubAdapter(factory, dbusObjectPath, "commonapi.dbus.tests.ManagerTestDBusStubAdapter", dbusConnection),
-                    dbusObjectManagerStub_(dbusObjectPath, dbusConnection) {
-    }
-
-    virtual CommonAPI::DBus::DBusObjectManagerStub* getDBusObjectManagerStub() {
-        return &dbusObjectManagerStub_;
+                    TestDBusStubAdapter(
+                                    factory,
+                                    dbusObjectPath,
+                                    "commonapi.dbus.tests.ManagerTestDBusStubAdapter",
+                                    dbusConnection,
+                                    true) {
     }
-
- private:
-    CommonAPI::DBus::DBusObjectManagerStub dbusObjectManagerStub_;
 };
 
-
 struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnection::DBusSignalHandler {
     size_t totalAddedCount;
     size_t totalRemovedCount;
@@ -99,7 +98,6 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio
     std::condition_variable signalReceived;
     std::mutex lock;
 
-
     ~TestDBusObjectManagerSignalHandler() {
         dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerAddedToken_);
         dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerRemovedToken_);
@@ -131,14 +129,15 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio
     }
 
     static inline std::shared_ptr<TestDBusObjectManagerSignalHandler> create(
-                    const std::string& dbusObjectPath,
-                    const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection) {
+                                                                             const std::string& dbusObjectPath,
+                                                                             const std::shared_ptr<
+                                                                                             CommonAPI::DBus::DBusProxyConnection>& dbusConnection) {
         auto dbusSignalHandler = new TestDBusObjectManagerSignalHandler(dbusObjectPath, dbusConnection);
         dbusSignalHandler->init();
         return std::shared_ptr<TestDBusObjectManagerSignalHandler>(dbusSignalHandler);
     }
 
- private:
+private:
     TestDBusObjectManagerSignalHandler(const std::string& dbusObjectPath,
                                        const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection) :
                     dbusObjectPath_(dbusObjectPath),
@@ -169,9 +168,8 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio
     CommonAPI::DBus::DBusProxyConnection::DBusSignalHandlerToken dbusSignalHandlerRemovedToken_;
 };
 
-
 class DBusObjectManagerStubTest: public ::testing::Test {
- protected:
+protected:
     virtual void SetUp() {
         auto runtime = std::dynamic_pointer_cast<CommonAPI::DBus::DBusRuntime>(CommonAPI::Runtime::load());
         serviceFactory = std::dynamic_pointer_cast<CommonAPI::DBus::DBusFactory>(runtime->createFactory());
@@ -185,15 +183,15 @@ class DBusObjectManagerStubTest: public ::testing::Test {
         ASSERT_TRUE(stubDBusConnection_->requestServiceNameAndBlock(dbusServiceName));
     }
 
-	virtual void TearDown() {
-	    stubDBusConnection_->disconnect();
-	    stubDBusConnection_.reset();
+    virtual void TearDown() {
+        stubDBusConnection_->disconnect();
+        stubDBusConnection_.reset();
 
-	    proxyDBusConnection_->disconnect();
-	    proxyDBusConnection_.reset();
-	}
+        proxyDBusConnection_->disconnect();
+        proxyDBusConnection_.reset();
+    }
 
-	std::shared_ptr<CommonAPI::DBus::DBusFactory> serviceFactory;
+    std::shared_ptr<CommonAPI::DBus::DBusFactory> serviceFactory;
 
     void getManagedObjects(const std::string& dbusObjectPath,
                            CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict) {
@@ -206,7 +204,7 @@ class DBusObjectManagerStubTest: public ::testing::Test {
         CommonAPI::DBus::DBusError dbusError;
         auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError);
 
-        ASSERT_FALSE(dbusError) << dbusError.getMessage();
+        ASSERT_FALSE(dbusError)<< dbusError.getMessage();
         ASSERT_TRUE(dbusMessageReply.isMethodReturnType());
         ASSERT_TRUE(dbusMessageReply.hasSignature("a{oa{sa{sv}}}"));
 
@@ -225,7 +223,7 @@ class DBusObjectManagerStubTest: public ::testing::Test {
         CommonAPI::DBus::DBusError dbusError;
         auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError);
 
-        ASSERT_FALSE(dbusError) << dbusError.getMessage();
+        ASSERT_FALSE(dbusError)<< dbusError.getMessage();
         ASSERT_TRUE(dbusMessageReply.isMethodReturnType());
         ASSERT_TRUE(dbusMessageReply.hasSignature("s"));
 
@@ -244,11 +242,12 @@ class DBusObjectManagerStubTest: public ::testing::Test {
         auto waitResult = dbusSignalHandler->signalReceived.wait_for(
                         lock,
                         std::chrono::milliseconds(interfacesAddedCount * waitMillisecondsPerInterface),
-                        [&]() { return dbusSignalHandler->totalAddedCount == interfacesAddedCount; });
+                        [&]() {return dbusSignalHandler->totalAddedCount == interfacesAddedCount;});
         ASSERT_TRUE(waitResult);
         ASSERT_EQ(dbusSignalHandler->totalRemovedCount, interfacesRemovedExpectedCount);
 
-        const std::string lastAddedDBusObjectPath = managedDBusObjectPathPrefix + std::to_string(interfacesAddedCount - 1);
+        const std::string lastAddedDBusObjectPath = managedDBusObjectPathPrefix
+                        + std::to_string(interfacesAddedCount - 1);
         ASSERT_TRUE(dbusSignalHandler->lastAddedDBusObjectPath == lastAddedDBusObjectPath);
     }
 
@@ -261,20 +260,22 @@ class DBusObjectManagerStubTest: public ::testing::Test {
         auto waitResult = dbusSignalHandler->signalReceived.wait_for(
                         lock,
                         std::chrono::milliseconds(interfacesRemovedCount * waitMillisecondsPerInterface),
-                        [&]() { return dbusSignalHandler->totalRemovedCount == interfacesRemovedCount; });
+                        [&]() {return dbusSignalHandler->totalRemovedCount == interfacesRemovedCount;});
         ASSERT_TRUE(waitResult);
         ASSERT_EQ(dbusSignalHandler->totalAddedCount, interfacesAddedExpectedCount);
 
-        const std::string lastRemovedDBusObjectPath = managedDBusObjectPathPrefix + std::to_string(interfacesRemovedCount - 1);
+        const std::string lastRemovedDBusObjectPath = managedDBusObjectPathPrefix
+                        + std::to_string(interfacesRemovedCount - 1);
         ASSERT_TRUE(dbusSignalHandler->lastRemovedDBusObjectPath == lastRemovedDBusObjectPath);
     }
 
-    template <typename _StubType, size_t _ArraySize>
-    void createDBusStubAdapter(std::array<std::shared_ptr<_StubType>, _ArraySize>& dbusStubAdapter) {
+    template<typename _StubType, size_t _ArraySize>
+    void createDBusStubAdapterArray(std::array<std::shared_ptr<_StubType>, _ArraySize>& dbusStubAdapter) {
         for (size_t i = 0; i < _ArraySize; i++) {
             dbusStubAdapter[i] = std::make_shared<_StubType>(serviceFactory,
                             managedDBusObjectPathPrefix + std::to_string(i),
-                            stubDBusConnection_);
+                            stubDBusConnection_,
+                            false);
 
             ASSERT_TRUE(bool(dbusStubAdapter[i]));
 
@@ -310,7 +311,7 @@ TEST_F(DBusObjectManagerStubTest, RootRegisterStubAdapterWorks) {
     auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create("/", proxyDBusConnection_);
     std::array<std::shared_ptr<TestDBusStubAdapter>, 10> dbusStubAdapterArray;
 
-    createDBusStubAdapter(dbusStubAdapterArray);
+    createDBusStubAdapterArray(dbusStubAdapterArray);
 
     const bool isServiceRegistrationSuccessful = std::all_of(
                     dbusStubAdapterArray.begin(),
@@ -341,9 +342,13 @@ TEST_F(DBusObjectManagerStubTest, RootRegisterStubAdapterWorks) {
     ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
+
 TEST_F(DBusObjectManagerStubTest, RegisterManagerStubAdapterWorks) {
     CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    auto managerDBusStubAdapter = std::make_shared<ManagerTestDBusStubAdapter>(serviceFactory, dbusObjectManagerStubPath, stubDBusConnection_);
+    auto managerDBusStubAdapter = std::make_shared<ManagerTestDBusStubAdapter>(
+                    serviceFactory,
+                    dbusObjectManagerStubPath,
+                    stubDBusConnection_);
     managerDBusStubAdapter->init();
 
     ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter));
@@ -355,55 +360,68 @@ TEST_F(DBusObjectManagerStubTest, RegisterManagerStubAdapterWorks) {
     ASSERT_EQ(dbusObjectPathAndInterfacesDict.count(dbusObjectManagerStubPath), 1);
 
     ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].size(), 2);
-    ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count(CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName()), 1);
-    ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count(managerDBusStubAdapter->getInterfaceName()), 1);
+    ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count(
+                                CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName()),
+              1);
+    ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count(
+                                managerDBusStubAdapter->getInterfaceName()),
+              1);
 
-    ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterService(managerDBusStubAdapter->getAddress()));
+    ASSERT_TRUE(
+                    CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterService(
+                                    managerDBusStubAdapter->getAddress()));
 
     dbusObjectPathAndInterfacesDict.clear();
     getManagedObjects("/", dbusObjectPathAndInterfacesDict);
     ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
-
 TEST_F(DBusObjectManagerStubTest, ManagerStubAdapterExportAndUnexportWorks) {
     CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create(dbusObjectManagerStubPath, proxyDBusConnection_);
-    auto managerDBusStubAdapter = std::make_shared<ManagerTestDBusStubAdapter>(serviceFactory, dbusObjectManagerStubPath, stubDBusConnection_);
+    auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create(
+                    dbusObjectManagerStubPath,
+                    proxyDBusConnection_);
+    auto managerDBusStubAdapter = std::make_shared<ManagerTestDBusStubAdapter>(
+                    serviceFactory,
+                    dbusObjectManagerStubPath,
+                    stubDBusConnection_);
     managerDBusStubAdapter->init();
 
     ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter));
 
     std::array<std::shared_ptr<TestDBusStubAdapter>, 10> dbusStubAdapterArray;
-    createDBusStubAdapter(dbusStubAdapterArray);
-
-    const bool isServiceRegistrationSuccessful = std::all_of(
-                    dbusStubAdapterArray.begin(),
-                    dbusStubAdapterArray.end(),
-                    [](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
-                        return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
-                    });
+    createDBusStubAdapterArray(dbusStubAdapterArray);
+
+    const bool isServiceRegistrationSuccessful =
+                    std::all_of(
+                                    dbusStubAdapterArray.begin(),
+                                    dbusStubAdapterArray.end(),
+                                    [](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
+                                        return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
+                                    });
     ASSERT_TRUE(isServiceRegistrationSuccessful);
 
-    const bool isServiceExportSuccessful = std::all_of(
-                    dbusStubAdapterArray.begin(),
-                    dbusStubAdapterArray.end(),
-                    [&](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
-                        return managerDBusStubAdapter->getDBusObjectManagerStub()->exportDBusStubAdapter(dbusStubAdapter.get());
-                    });
+    const bool isServiceExportSuccessful =
+                    std::all_of(
+                                    dbusStubAdapterArray.begin(),
+                                    dbusStubAdapterArray.end(),
+                                    [&](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
+                                        return stubDBusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(managerDBusStubAdapter->getObjectPath(), dbusStubAdapter);
+                                    });
     ASSERT_TRUE(isServiceExportSuccessful);
 
     waitForInterfacesAdded(dbusSignalHandler, dbusStubAdapterArray.size(), 0);
 
     getManagedObjects(dbusObjectManagerStubPath, dbusObjectPathAndInterfacesDict);
-    ASSERT_EQ(dbusObjectPathAndInterfacesDict.size(), dbusStubAdapterArray.size());
-
-    const bool isServiceUnexportSuccessful = std::all_of(
-                    dbusStubAdapterArray.begin(),
-                    dbusStubAdapterArray.end(),
-                    [&](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
-                        return managerDBusStubAdapter->getDBusObjectManagerStub()->unexportDBusStubAdapter(dbusStubAdapter.get());
-                    });
+    EXPECT_EQ(dbusObjectPathAndInterfacesDict.size(), dbusStubAdapterArray.size());
+
+    const bool isServiceUnexportSuccessful =
+                    std::all_of(
+                                    dbusStubAdapterArray.begin(),
+                                    dbusStubAdapterArray.end(),
+                                    [&](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
+                                        return stubDBusConnection_->getDBusObjectManager()->unexportManagedDBusStubAdapter(managerDBusStubAdapter->getObjectPath(), dbusStubAdapter);
+                                    });
     ASSERT_TRUE(isServiceUnexportSuccessful);
 
     const bool isServiceDeregistrationSuccessful = std::all_of(
@@ -419,36 +437,44 @@ TEST_F(DBusObjectManagerStubTest, ManagerStubAdapterExportAndUnexportWorks) {
 
     dbusObjectPathAndInterfacesDict.clear();
     getManagedObjects(dbusObjectManagerStubPath, dbusObjectPathAndInterfacesDict);
-    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
     ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterService(managerDBusStubAdapter->getAddress()));
 }
 
+
 TEST_F(DBusObjectManagerStubTest, DestructorUnpublishingWorks) {
     CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create(dbusObjectManagerStubPath, proxyDBusConnection_);
-    auto managerDBusStubAdapter = std::make_shared<ManagerTestDBusStubAdapter>(serviceFactory, dbusObjectManagerStubPath, stubDBusConnection_);
+    auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create(
+                    dbusObjectManagerStubPath,
+                    proxyDBusConnection_);
+    auto managerDBusStubAdapter = std::make_shared<ManagerTestDBusStubAdapter>(
+                    serviceFactory,
+                    dbusObjectManagerStubPath,
+                    stubDBusConnection_);
     managerDBusStubAdapter->init();
 
-    ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter));
+    EXPECT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter));
 
     std::array<std::shared_ptr<TestDBusStubAdapter>, 10> dbusStubAdapterArray;
-    createDBusStubAdapter(dbusStubAdapterArray);
-
-    const bool isServiceRegistrationSuccessful = std::all_of(
-                    dbusStubAdapterArray.begin(),
-                    dbusStubAdapterArray.end(),
-                    [](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
-                        return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
-                    });
+    createDBusStubAdapterArray(dbusStubAdapterArray);
+
+    const bool isServiceRegistrationSuccessful =
+                    std::all_of(
+                                    dbusStubAdapterArray.begin(),
+                                    dbusStubAdapterArray.end(),
+                                    [](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
+                                        return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
+                                    });
     ASSERT_TRUE(isServiceRegistrationSuccessful);
 
-    const bool isServiceExportSuccessful = std::all_of(
-                    dbusStubAdapterArray.begin(),
-                    dbusStubAdapterArray.end(),
-                    [&](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
-                        return managerDBusStubAdapter->getDBusObjectManagerStub()->exportDBusStubAdapter(dbusStubAdapter.get());
-                    });
+    const bool isServiceExportSuccessful =
+                    std::all_of(
+                                    dbusStubAdapterArray.begin(),
+                                    dbusStubAdapterArray.end(),
+                                    [&](const std::shared_ptr<TestDBusStubAdapter>& dbusStubAdapter) {
+                                        return stubDBusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(managerDBusStubAdapter->getObjectPath(), dbusStubAdapter);
+                                    });
     ASSERT_TRUE(isServiceExportSuccessful);
 
     waitForInterfacesAdded(dbusSignalHandler, dbusStubAdapterArray.size(), 0);
diff --git a/src/test/DBusServiceRegistryTest.cpp b/src/test/DBusServiceRegistryTest.cpp
index 9eb1c65..2f1043e 100644
--- a/src/test/DBusServiceRegistryTest.cpp
+++ b/src/test/DBusServiceRegistryTest.cpp
@@ -146,7 +146,7 @@ class TestDBusStubAdapter: public CommonAPI::DBus::DBusStubAdapter {
                         const std::string& dbusBusName,
                         const std::string& dbusObjectPath,
                         const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection):
-                        DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection),
+                        DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, false),
                         introspectionCount(0) {
     }
 
diff --git a/src/test/commonapi/tests/managed/BranchInterface.h b/src/test/commonapi/tests/managed/BranchInterface.h
index 80b5138..d2a1e28 100644
--- a/src/test/commonapi/tests/managed/BranchInterface.h
+++ b/src/test/commonapi/tests/managed/BranchInterface.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp
index f056c50..8a1e99e 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp
+++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h
index a5eac7b..bac635b 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp
index b9c846b..fd16fca 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp
+++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -40,8 +40,7 @@ BranchInterfaceDBusStubAdapter::BranchInterfaceDBusStubAdapter(
         const std::shared_ptr<CommonAPI::StubBase>& stub):
         BranchInterfaceDBusStubAdapterHelper(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, 
             dbusConnection, std::dynamic_pointer_cast<BranchInterfaceStub>(stub),
-            NULL)
-            {
+            false) {
 }
 
 BranchInterfaceDBusStubAdapter::~BranchInterfaceDBusStubAdapter() {
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h
index df42f7b..3ebce77 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceProxy.h b/src/test/commonapi/tests/managed/BranchInterfaceProxy.h
index 9bbbc77..a0de1b6 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceProxy.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceProxy.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h b/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h
index 5a6a613..acd2931 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceStub.h b/src/test/commonapi/tests/managed/BranchInterfaceStub.h
index 8f90cfa..0e4d397 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceStub.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceStub.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp
index 1fa2a8f..84e7567 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp
+++ b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h
index b2dab45..ae9945d 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/LeafInterface.h b/src/test/commonapi/tests/managed/LeafInterface.h
index 1aaad3d..2d99fe5 100644
--- a/src/test/commonapi/tests/managed/LeafInterface.h
+++ b/src/test/commonapi/tests/managed/LeafInterface.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp
index a87c019..665b655 100644
--- a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp
+++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h
index 8653db4..26ba6f9 100644
--- a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h
+++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp
index 2ff0d48..9abe5d4 100644
--- a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp
+++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -40,8 +40,7 @@ LeafInterfaceDBusStubAdapter::LeafInterfaceDBusStubAdapter(
         const std::shared_ptr<CommonAPI::StubBase>& stub):
         LeafInterfaceDBusStubAdapterHelper(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, 
             dbusConnection, std::dynamic_pointer_cast<LeafInterfaceStub>(stub),
-            NULL)
-            {
+            false) {
 }
 
 LeafInterfaceDBusStubAdapter::~LeafInterfaceDBusStubAdapter() {
diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h
index f67cc26..8775a83 100644
--- a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h
+++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterface.h b/src/test/commonapi/tests/managed/RootInterface.h
index 398e60c..85fff90 100644
--- a/src/test/commonapi/tests/managed/RootInterface.h
+++ b/src/test/commonapi/tests/managed/RootInterface.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp
index 4d74952..b27e0eb 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp
+++ b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h
index 5aaf63f..70e9a28 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
index 1a3a6dc..9872b58 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
+++ b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -40,8 +40,7 @@ RootInterfaceDBusStubAdapter::RootInterfaceDBusStubAdapter(
         const std::shared_ptr<CommonAPI::StubBase>& stub):
         RootInterfaceDBusStubAdapterHelper(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, 
             dbusConnection, std::dynamic_pointer_cast<RootInterfaceStub>(stub),
-            new CommonAPI::DBus::DBusObjectManagerStub(dbusObjectPath, dbusConnection))
-            {
+            true) {
 }
 
 RootInterfaceDBusStubAdapter::~RootInterfaceDBusStubAdapter() {
@@ -109,9 +108,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubLeafInterface(std::shared_
         if (objectPath.compare(0, dbusObjectPath_.length(), dbusObjectPath_) == 0) {
             auto dbusStubAdapter = factory_->createDBusStubAdapter(stub, "commonapi.tests.managed.LeafInterface",
                     instance, "commonapi.tests.managed.LeafInterface", "local");
-            bool ok = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
-            if (ok) {
-                bool isServiceExportSuccessful = managerStub->exportDBusStubAdapter(dbusStubAdapter.get());
+
+            bool success = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
+            if (success) {
+                bool isServiceExportSuccessful = dbusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter);
                 if (isServiceExportSuccessful) {
                     registeredLeafInterfaceInstances.insert(instance);
                     return true;
@@ -129,10 +129,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubLeafInterface(std::shared_
 bool RootInterfaceDBusStubAdapter::deregisterManagedStubLeafInterface(const std::string& instance) {
     std::string commonApiAddress = "local:commonapi.tests.managed.LeafInterface:" + instance;
     if (registeredLeafInterfaceInstances.find(instance) != registeredLeafInterfaceInstances.end()) {
-        std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> adapter =
+        std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> dbusStubAdapter =
                     CommonAPI::DBus::DBusServicePublisher::getInstance()->getRegisteredService(commonApiAddress);
-        if (adapter != nullptr) {
-            managerStub->unexportDBusStubAdapter(adapter.get());
+        if (dbusStubAdapter != nullptr) {
+            dbusConnection_->getDBusObjectManager()->unexportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter);
             CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress);
             registeredLeafInterfaceInstances.erase(instance);
             return true;
@@ -162,9 +162,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubBranchInterface(std::share
         if (objectPath.compare(0, dbusObjectPath_.length(), dbusObjectPath_) == 0) {
             auto dbusStubAdapter = factory_->createDBusStubAdapter(stub, "commonapi.tests.managed.BranchInterface",
                     instance, "commonapi.tests.managed.BranchInterface", "local");
-            bool ok = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
-            if (ok) {
-                bool isServiceExportSuccessful = managerStub->exportDBusStubAdapter(dbusStubAdapter.get());
+
+            bool success = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter);
+            if (success) {
+                bool isServiceExportSuccessful = dbusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter);
                 if (isServiceExportSuccessful) {
                     registeredBranchInterfaceInstances.insert(instance);
                     return true;
@@ -182,10 +183,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubBranchInterface(std::share
 bool RootInterfaceDBusStubAdapter::deregisterManagedStubBranchInterface(const std::string& instance) {
     std::string commonApiAddress = "local:commonapi.tests.managed.BranchInterface:" + instance;
     if (registeredBranchInterfaceInstances.find(instance) != registeredBranchInterfaceInstances.end()) {
-        std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> adapter =
+        std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> dbusStubAdapter =
                     CommonAPI::DBus::DBusServicePublisher::getInstance()->getRegisteredService(commonApiAddress);
-        if (adapter != nullptr) {
-            managerStub->unexportDBusStubAdapter(adapter.get());
+        if (dbusStubAdapter != nullptr) {
+            dbusConnection_->getDBusObjectManager()->unexportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter);
             CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress);
             registeredBranchInterfaceInstances.erase(instance);
             return true;
diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h
index a3fd482..c10288d 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceProxy.h b/src/test/commonapi/tests/managed/RootInterfaceProxy.h
index 17f570a..741aa05 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceProxy.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceProxy.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h b/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h
index ca8a693..65380b7 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceStub.h b/src/test/commonapi/tests/managed/RootInterfaceStub.h
index c0c5da9..2b71e5f 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceStub.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceStub.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp
index f4d39d1..6e84512 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp
+++ b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -37,7 +37,7 @@ void RootInterfaceStubDefault::testRootMethod(int32_t inInt, std::string inStrin
 bool RootInterfaceStubDefault::registerManagedStubLeafInterfaceAutoInstance(std::shared_ptr<LeafInterfaceStub> stub) {
     autoInstanceCounter_++;
     std::stringstream ss;
-    ss << stubAdapter_->getInstanceId() << "." << autoInstanceCounter_;
+    ss << stubAdapter_->getInstanceId() << ".i" << autoInstanceCounter_;
     std::string instance = ss.str();
     return stubAdapter_->registerManagedStubLeafInterface(stub, instance);
 }
@@ -53,7 +53,7 @@ std::set<std::string>& RootInterfaceStubDefault::getLeafInterfaceInstances() {
 bool RootInterfaceStubDefault::registerManagedStubBranchInterfaceAutoInstance(std::shared_ptr<BranchInterfaceStub> stub) {
     autoInstanceCounter_++;
     std::stringstream ss;
-    ss << stubAdapter_->getInstanceId() << "." << autoInstanceCounter_;
+    ss << stubAdapter_->getInstanceId() << ".i" << autoInstanceCounter_;
     std::string instance = ss.str();
     return stubAdapter_->registerManagedStubBranchInterface(stub, instance);
 }
diff --git a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h
index c2e0620..6f3a960 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators. 
-* Used org.genivi.commonapi.core 2.1.0.qualifier.
+* Used org.genivi.commonapi.core 2.1.3.qualifier.
 * Used org.franca.core 0.8.9.201308271211.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.