1 files changed, 265 insertions, 182 deletions

diff --git a/src/test/DBusBroadcastTest.cpp b/src/test/DBusBroadcastTest.cpp
index c74c296..36f8121 100644
--- a/src/test/DBusBroadcastTest.cpp
+++ b/src/test/DBusBroadcastTest.cpp
@@ -27,11 +27,16 @@
 
 #include "commonapi/tests/PredefinedTypeCollection.hpp"
 #include "commonapi/tests/DerivedTypeCollection.hpp"
-#include "v1_0/commonapi/tests/TestInterfaceProxy.hpp"
-#include "v1_0/commonapi/tests/TestInterfaceStubDefault.hpp"
-#include "v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.hpp"
 
-#include "v1_0/commonapi/tests/TestInterfaceDBusProxy.hpp"
+#include "v1/commonapi/tests/TestInterfaceManagerProxy.hpp"
+#include "v1/commonapi/tests/TestInterfaceManagerStubDefault.hpp"
+#include "v1/commonapi/tests/TestInterfaceManagerDBusProxy.hpp"
+#include "v1/commonapi/tests/TestInterfaceManagerDBusStubAdapter.hpp"
+
+#include "v1/commonapi/tests/TestInterfaceProxy.hpp"
+#include "v1/commonapi/tests/TestInterfaceStubDefault.hpp"
+#include "v1/commonapi/tests/TestInterfaceDBusStubAdapter.hpp"
+#include "v1/commonapi/tests/TestInterfaceDBusProxy.hpp"
 
 #define VERSION v1_0
 
@@ -42,11 +47,11 @@ public:
         acceptSubs(true),
         sentBroadcasts(0) {
 
-	}
+    }
 
-	virtual ~SelectiveBroadcastSender() {
+    virtual ~SelectiveBroadcastSender() {
 
-	}
+    }
 
     void startSending() {
         sentBroadcasts = 0;
@@ -69,6 +74,7 @@ public:
 
     bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(
                     const std::shared_ptr<CommonAPI::ClientId> clientId) {
+        (void)clientId;
         return acceptSubs;
     }
 
@@ -83,7 +89,7 @@ public:
 
 
     int getNumberOfSubscribedClients() {
-        return getSubscribersForTestSelectiveBroadcastSelective()->size();
+        return static_cast<int>(getSubscribersForTestSelectiveBroadcastSelective()->size());
 
     }
 
@@ -96,7 +102,18 @@ private:
     std::shared_ptr<CommonAPI::ClientId> lastSubscribedClient;
 };
 
+class Environment: public ::testing::Environment {
+public:
+    virtual ~Environment() {
+    }
 
+    virtual void SetUp() {
+        CommonAPI::Runtime::setProperty("LibraryBase", "fakeGlueCode");
+    }
+
+    virtual void TearDown() {
+    }
+};
 
 class DBusBroadcastTest: public ::testing::Test {
 protected:
@@ -104,59 +121,65 @@ protected:
        runtime_ = CommonAPI::Runtime::get();
        ASSERT_TRUE((bool)runtime_);
 
-	   serviceAddressObject_ = CommonAPI::Address(serviceAddress_);
+       serviceAddressObject_ = CommonAPI::Address(serviceAddress_);
 
-       selectiveBroadcastArrivedAtProxyFromSameFactory1 = 0;
-       selectiveBroadcastArrivedAtProxyFromSameFactory2 = 0;
-       selectiveBroadcastArrivedAtProxyFromOtherFactory = 0;
+       selectiveBroadcastArrivedAtProxyFromSameConnection1 = 0;
+       selectiveBroadcastArrivedAtProxyFromSameConnection2 = 0;
+       selectiveBroadcastArrivedAtProxyFromOtherConnection = 0;
    }
 
    virtual void TearDown() {
-	   runtime_->unregisterService(serviceAddressObject_.getDomain(), serviceAddressInterface_, serviceAddressObject_.getInstance());
+       runtime_->unregisterService(serviceAddressObject_.getDomain(), serviceAddressInterface_, serviceAddressObject_.getInstance());
    }
 
    std::shared_ptr<CommonAPI::Runtime> runtime_;
 
    static const std::string serviceAddress_;
+   static const std::string managerServiceAddress_;
    CommonAPI::Address serviceAddressObject_;
    std::string serviceAddressInterface_;
-   static const CommonAPI::ConnectionId_t connectionId_;
+   static const CommonAPI::ConnectionId_t connectionIdService_;
+   static const CommonAPI::ConnectionId_t connectionIdClient1_;
+   static const CommonAPI::ConnectionId_t connectionIdClient2_;
 
-   int selectiveBroadcastArrivedAtProxyFromSameFactory1;
-   int selectiveBroadcastArrivedAtProxyFromSameFactory2;
-   int selectiveBroadcastArrivedAtProxyFromOtherFactory;
+   int selectiveBroadcastArrivedAtProxyFromSameConnection1;
+   int selectiveBroadcastArrivedAtProxyFromSameConnection2;
+   int selectiveBroadcastArrivedAtProxyFromOtherConnection;
 
 public:
-   void selectiveBroadcastCallbackForProxyFromSameFactory1() {
-       selectiveBroadcastArrivedAtProxyFromSameFactory1++;
+   void selectiveBroadcastCallbackForProxyFromSameConnection1() {
+       selectiveBroadcastArrivedAtProxyFromSameConnection1++;
    }
 
-   void selectiveBroadcastCallbackForProxyFromSameFactory2() {
-       selectiveBroadcastArrivedAtProxyFromSameFactory2++;
+   void selectiveBroadcastCallbackForProxyFromSameConnection2() {
+       selectiveBroadcastArrivedAtProxyFromSameConnection2++;
    }
 
-   void selectiveBroadcastCallbackForProxyFromOtherFactory() {
-       selectiveBroadcastArrivedAtProxyFromOtherFactory++;
+   void selectiveBroadcastCallbackForProxyFromOtherConnection() {
+       selectiveBroadcastArrivedAtProxyFromOtherConnection++;
    }
 };
 
-const std::string DBusBroadcastTest::serviceAddress_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService";
-const CommonAPI::ConnectionId_t DBusBroadcastTest::connectionId_ = "connection";
+const std::string DBusBroadcastTest::serviceAddress_ = "local:CommonAPI.DBus.tests.TestInterface:CommonAPI.DBus.tests.TestInterfaceManager.TestService";
+const std::string DBusBroadcastTest::managerServiceAddress_ = "local:CommonAPI.DBus.tests.TestInterfaceManager:CommonAPI.DBus.tests.TestInterfaceManager";
+const CommonAPI::ConnectionId_t DBusBroadcastTest::connectionIdService_ = "service";
+const CommonAPI::ConnectionId_t DBusBroadcastTest::connectionIdClient1_ = "client1";
+const CommonAPI::ConnectionId_t DBusBroadcastTest::connectionIdClient2_ = "client2";
 
 TEST_F(DBusBroadcastTest, ProxysCanHandleBroadcast) {
     auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
 
 
-	auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
 
     VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
                     proxy->getTestPredefinedTypeBroadcastEvent();
@@ -164,6 +187,8 @@ TEST_F(DBusBroadcastTest, ProxysCanHandleBroadcast) {
     bool callbackArrived = false;
 
     broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
+            (void)intParam;
+            (void)stringParam;
             callbackArrived = true;
     });
 
@@ -176,20 +201,20 @@ TEST_F(DBusBroadcastTest, ProxysCanHandleBroadcast) {
     ASSERT_TRUE(callbackArrived);
 }
 
-TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribeAgain) {
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+TEST_F(DBusBroadcastTest, ProxysCanUnsubscribeFromBroadcastAndSubscribeAgain) {
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
 
 
-	auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
 
     VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
                     proxy->getTestPredefinedTypeBroadcastEvent();
@@ -197,6 +222,7 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
     bool callbackArrived = false;
 
     auto broadcastSubscription = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
+            (void)stringParam;
             EXPECT_EQ(intParam, 1);
             callbackArrived = true;
     });
@@ -213,9 +239,10 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
 
     callbackArrived = false;
 
-	auto broadcastSubscription2 = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
-            EXPECT_EQ(intParam, 2);
-            callbackArrived = true;
+    auto broadcastSubscription2 = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
+        (void)stringParam;
+        EXPECT_EQ(intParam, 2);
+        callbackArrived = true;
     });
 
     stub->fireTestPredefinedTypeBroadcastEvent(2, "xyz");
@@ -226,22 +253,22 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
 
     ASSERT_TRUE(callbackArrived);
 
-	broadcastEvent.unsubscribe(broadcastSubscription2);
+    broadcastEvent.unsubscribe(broadcastSubscription2);
 }
 
-TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainInALoop) {
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+TEST_F(DBusBroadcastTest, ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainInALoop) {
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
 
-	auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
 
     VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
                     proxy->getTestPredefinedTypeBroadcastEvent();
@@ -250,8 +277,9 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
         bool callbackArrived = false;
 
         auto broadcastSubscription = broadcastEvent.subscribe([&,i](uint32_t intParam, std::string stringParam) {
-                EXPECT_EQ(intParam, i);
-                callbackArrived = true;
+            (void)stringParam;
+            EXPECT_EQ(intParam, i);
+            callbackArrived = true;
         });
 
         stub->fireTestPredefinedTypeBroadcastEvent(i, "xyz");
@@ -263,31 +291,32 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
         ASSERT_TRUE(callbackArrived);
 
         broadcastEvent.unsubscribe(broadcastSubscription);
-	}
+    }
 }
 
-TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainWithOtherProxy) {
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+TEST_F(DBusBroadcastTest, ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainWithOtherProxy) {
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
 
-	auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
 
     VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
                     proxy->getTestPredefinedTypeBroadcastEvent();
 
     bool callbackArrived = false;
 
-	auto broadcastSubscription = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
-            EXPECT_EQ(intParam, 1);
-            callbackArrived = true;
+    auto broadcastSubscription = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
+        (void)stringParam;
+        EXPECT_EQ(intParam, 1);
+        callbackArrived = true;
     });
 
     stub->fireTestPredefinedTypeBroadcastEvent(1, "xyz");
@@ -300,16 +329,17 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
 
     broadcastEvent.unsubscribe(broadcastSubscription);
 
-	auto proxy2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    auto proxy2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
 
     VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent2 =
                     proxy->getTestPredefinedTypeBroadcastEvent();
 
     callbackArrived = false;
 
-	auto broadcastSubscription2 = broadcastEvent2.subscribe([&](uint32_t intParam, std::string stringParam) {
-            EXPECT_EQ(intParam, 2);
-            callbackArrived = true;
+    auto broadcastSubscription2 = broadcastEvent2.subscribe([&](uint32_t intParam, std::string stringParam) {
+        (void)stringParam;
+        EXPECT_EQ(intParam, 2);
+        callbackArrived = true;
     });
 
     stub->fireTestPredefinedTypeBroadcastEvent(2, "xyz");
@@ -320,79 +350,24 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
 
     ASSERT_TRUE(callbackArrived);
 
-	broadcastEvent.unsubscribe(broadcastSubscription2);
+    broadcastEvent.unsubscribe(broadcastSubscription2);
 }
 
-TEST_F(DBusBroadcastTest, DISABLED_ProxysCanCancelSubscriptionAndSubscribeAgainWithOtherProxy) {
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
-
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
-    for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
-        usleep(10000);
-    }
-    ASSERT_TRUE(serviceRegistered);
-
-
-	auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-
-    VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
-                    proxy->getTestPredefinedTypeBroadcastEvent();
-
-    bool callbackArrived = false;
-
-	broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
-            EXPECT_EQ(intParam, 1);
-            callbackArrived = true;
-    });
-
-    stub->fireTestPredefinedTypeBroadcastEvent(1, "xyz");
-
-    for(unsigned int i=0; i<100 && !callbackArrived; i++) {
-        usleep(10000);
-    }
-
-    ASSERT_TRUE(callbackArrived);
-
-	auto proxy2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-
-    VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent2 =
-                    proxy->getTestPredefinedTypeBroadcastEvent();
-
-    callbackArrived = false;
-
-	auto broadcastSubscription2 = broadcastEvent2.subscribe([&](uint32_t intParam, std::string stringParam) {
-            EXPECT_EQ(intParam, 2);
-            callbackArrived = true;
-    });
-
-    stub->fireTestPredefinedTypeBroadcastEvent(2, "xyz");
-
-    for(unsigned int i=0; i<100 && !callbackArrived; i++) {
-        usleep(10000);
-    }
-
-    ASSERT_TRUE(callbackArrived);
-
-	broadcastEvent2.unsubscribe(broadcastSubscription2);
-}
-
-TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainWhileOtherProxyIsStillSubscribed) {
+TEST_F(DBusBroadcastTest, ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainWhileOtherProxyIsStillSubscribed) {
     // register service
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
-    // build 2 proxies from same factory
-	auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-	auto proxy2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    // build 2 proxies
+    auto proxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
+    auto proxy2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
 
     VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
                     proxy->getTestPredefinedTypeBroadcastEvent();
@@ -405,11 +380,15 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
 
     // subscribe for each proxy's broadcast event
     auto broadcastSubscription = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
-            callback1Arrived = true;
+        (void)intParam;
+        (void)stringParam;
+        callback1Arrived = true;
     });
 
-	auto broadcastSubscription2 = broadcastEvent2.subscribe([&](uint32_t intParam, std::string stringParam) {
-            callback2Arrived = true;
+    auto broadcastSubscription2 = broadcastEvent2.subscribe([&](uint32_t intParam, std::string stringParam) {
+        (void)intParam;
+        (void)stringParam;
+        callback2Arrived = true;
     });
 
     // fire broadcast and wait for results
@@ -441,8 +420,10 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
     EXPECT_TRUE(onlyCallback2Arrived);
 
     // subscribe first proxy again
-	broadcastSubscription = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
-            callback1Arrived = true;
+    broadcastSubscription = broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
+        (void)intParam;
+        (void)stringParam;
+        callback1Arrived = true;
     });
 
     // fire broadcast another time
@@ -460,35 +441,35 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanUnsubscribeFromBroadcastAndSubscribe
     EXPECT_TRUE(callbackOnBothSubscriptionsArrivedAgain);
 
     broadcastEvent.unsubscribe(broadcastSubscription);
-	broadcastEvent2.unsubscribe(broadcastSubscription2);
+    broadcastEvent2.unsubscribe(broadcastSubscription2);
 }
 
-TEST_F(DBusBroadcastTest, DISABLED_ProxysCanSubscribeForSelectiveBroadcast)
+TEST_F(DBusBroadcastTest, ProxysCanSubscribeForSelectiveBroadcast)
 {
-	auto proxyFromSameFactory1 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-    ASSERT_TRUE((bool)proxyFromSameFactory1);
-	auto proxyFromSameFactory2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-    ASSERT_TRUE((bool)proxyFromSameFactory2);
-	auto proxyFromOtherFactory = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-    ASSERT_TRUE((bool)proxyFromOtherFactory);
+    auto proxyFromSameConnection = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), connectionIdClient1_);
+    ASSERT_TRUE((bool)proxyFromSameConnection);
+    auto proxyFromSameConnection2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), connectionIdClient1_);
+    ASSERT_TRUE((bool)proxyFromSameConnection2);
+    auto proxyFromOtherConnection = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), connectionIdClient2_);
+    ASSERT_TRUE((bool)proxyFromOtherConnection);
 
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
-    for (unsigned int i = 0; !proxyFromSameFactory1->isAvailable() && i < 200; ++i) {
+    for (unsigned int i = 0; !proxyFromSameConnection->isAvailable() && i < 200; ++i) {
         usleep(10000);
     }
-    ASSERT_TRUE(proxyFromSameFactory1->isAvailable());
+    ASSERT_TRUE(proxyFromSameConnection->isAvailable());
 
-    auto subscriptionResult1 = proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
-                    std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this));
+    auto subscriptionResult1 = proxyFromSameConnection->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+                    std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromSameConnection1, this));
 
     usleep(20000);
     ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
@@ -496,87 +477,189 @@ TEST_F(DBusBroadcastTest, DISABLED_ProxysCanSubscribeForSelectiveBroadcast)
     stub->send();
 
     usleep(200000);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 1);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 0);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection1, 1);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection2, 0);
 
 
-    auto subscriptionResult2 = proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory2, this));
-    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1); // should still be one because these were created by the same factory thus using the same connection
+    auto subscriptionResult2 = proxyFromSameConnection2->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromSameConnection2, this));
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1); // should still be one because they using the same connection
 
     stub->send();
     usleep(200000);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 2);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection1, 2);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection2, 1);
 
-    proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this));
-    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
+    proxyFromOtherConnection->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherConnection, this));
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameConnection1_ is still subscribed
 
-    proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult2);
-    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
+    proxyFromSameConnection2->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult2);
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameConnection1_ is still subscribed
 
     stub->send();
     usleep(200000);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 3);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 1);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection1, 3);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection2, 1);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromOtherConnection, 1);
 
-    // now only the last subscribed client (which is the one from the other factory) should receive the signal
+    // now only the last subscribed client (which is the one from the other connection) should receive the signal
     stub->sendToLastSubscribedClient();
     usleep(200000);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 3);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
-    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 2);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection1, 3);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection2, 1);
+    EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromOtherConnection, 2);
 
-    proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult1);
-	EXPECT_EQ(stub->getNumberOfSubscribedClients(), 1);
+    proxyFromSameConnection->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult1);
+    EXPECT_EQ(stub->getNumberOfSubscribedClients(), 1);
 }
 
 TEST_F(DBusBroadcastTest, ProxysCanBeRejectedForSelectiveBroadcast) {
-	auto proxyFromSameFactory1 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-    ASSERT_TRUE((bool)proxyFromSameFactory1);
-	auto proxyFromOtherFactory = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance());
-    ASSERT_TRUE((bool)proxyFromOtherFactory);
+    auto proxyFromSameConnection1 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), connectionIdClient1_);
+    ASSERT_TRUE((bool)proxyFromSameConnection1);
+    auto proxyFromOtherConnection = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), connectionIdClient2_);
+    ASSERT_TRUE((bool)proxyFromOtherConnection);
 
 
-	auto stub = std::make_shared<SelectiveBroadcastSender>();
-	serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+    serviceAddressInterface_ = stub->getStubAdapter()->getInterface();
 
-	bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+    bool serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
     for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
-		serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionId_);
+        serviceRegistered = runtime_->registerService(serviceAddressObject_.getDomain(), serviceAddressObject_.getInstance(), stub, connectionIdService_);
         usleep(10000);
     }
     ASSERT_TRUE(serviceRegistered);
 
-    for (unsigned int i = 0; !proxyFromSameFactory1->isAvailable() && i < 200; ++i) {
+    for (unsigned int i = 0; !proxyFromSameConnection1->isAvailable() && i < 200; ++i) {
         usleep(10000);
     }
-    ASSERT_TRUE(proxyFromSameFactory1->isAvailable());
+    ASSERT_TRUE(proxyFromSameConnection1->isAvailable());
 
-    bool subbed = false;
+    //bool subbed = false;
 
-    proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
-                    std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this));
+    proxyFromSameConnection1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+                    std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromSameConnection1, this));
     ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
     //ASSERT_TRUE(subbed);
 
     stub->acceptSubs = false;
 
-    proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(
-                    std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this));
+    proxyFromOtherConnection->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+                    std::bind(&DBusBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherConnection, this));
     ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
     //ASSERT_FALSE(subbed);
 
     stub->send();
 
     usleep(20000);
-    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 1);
-	ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 0);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameConnection1, 1);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherConnection, 0);
+}
+
+TEST_F(DBusBroadcastTest, ProxyCanBeDeletedAndBuildFromNewInManagedContext) {
+    int intParamValue = 0;
+    bool callbackArrived = false;
+    bool proxyDeleted = false;
+
+    CommonAPI::Address managerServiceAddressObject = CommonAPI::Address(managerServiceAddress_);
+
+    //build proxy of test interface manager
+    auto managerProxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceManagerProxy>(managerServiceAddressObject.getDomain(), managerServiceAddressObject.getInstance(), connectionIdClient1_);
+    ASSERT_TRUE((bool)managerProxy);
+
+    //build stub of test interface manager
+    auto managerStub = std::make_shared<VERSION::commonapi::tests::TestInterfaceManagerStubDefault>();
+    const std::string managerServiceInterface = managerStub->getStubAdapter()->getInterface();
+
+    //register test interface manager
+    bool managerServiceRegistered = runtime_->registerService(managerServiceAddressObject.getDomain(), managerServiceAddressObject.getInstance(), managerStub, connectionIdService_);
+    for (unsigned int i = 0; !managerServiceRegistered && i < 100; ++i) {
+        managerServiceRegistered = runtime_->registerService(managerServiceAddressObject.getDomain(), managerServiceAddressObject.getInstance(), managerStub, connectionIdService_);
+        usleep(10000);
+    }
+    ASSERT_TRUE(managerServiceRegistered);
+
+    for (unsigned int i = 0; !managerProxy->isAvailable() && i < 200; ++i) {
+        usleep(10000);
+    }
+    ASSERT_TRUE(managerProxy->isAvailable());
+
+    //stub and proxy of test interface
+    auto stubTestInterface = std::make_shared<SelectiveBroadcastSender>();
+    std::shared_ptr<VERSION::commonapi::tests::TestInterfaceProxy<>> proxyTestInterface;
+
+    //subscribe for instance availability changed event
+    CommonAPI::ProxyManager& testInterfaceProxyManager = managerProxy->getProxyManagerTestInterface();
+    testInterfaceProxyManager.getInstanceAvailabilityStatusChangedEvent().subscribe
+            ([&](const std::string instanceName, CommonAPI::AvailabilityStatus availabilityStatus) {
+    (void)instanceName;
+
+        if(availabilityStatus == CommonAPI::AvailabilityStatus::AVAILABLE) {
+            //Create proxy for managed test interface
+            proxyTestInterface = testInterfaceProxyManager.buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(serviceAddressObject_.getInstance());
+            ASSERT_TRUE((bool)proxyTestInterface);
+
+            for (unsigned int i = 0; !proxyTestInterface->isAvailable() && i < 200; ++i) {
+                usleep(10000);
+            }
+            ASSERT_TRUE(proxyTestInterface->isAvailable());
+
+            VERSION::commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
+                            proxyTestInterface->getTestPredefinedTypeBroadcastEvent();
+
+            //subscribe for broadcast event
+            broadcastEvent.subscribe([&](uint32_t intParam, std::string stringParam) {
+                (void)stringParam;
+                EXPECT_EQ(intParam, intParamValue);
+                callbackArrived = true;
+            });
+
+            stubTestInterface->fireTestPredefinedTypeBroadcastEvent(intParamValue, "xyz");
+
+        } else if(availabilityStatus == CommonAPI::AvailabilityStatus::NOT_AVAILABLE) {
+            //delete proxy
+            proxyTestInterface = nullptr;
+            proxyDeleted = true;
+        }
+    });
+
+    //register managed test interface
+    intParamValue++;
+    bool managedServiceRegistered = managerStub->registerManagedStubTestInterface(stubTestInterface, serviceAddressObject_.getInstance());
+    ASSERT_TRUE(managedServiceRegistered);
+
+    for(unsigned int i=0; i<200 && !callbackArrived; i++) {
+         usleep(10000);
+    }
+    ASSERT_TRUE(callbackArrived);
+
+    //deregister managed test interface
+    managerStub->deregisterManagedStubTestInterface(serviceAddressObject_.getInstance());
+
+    for(unsigned int i=0; i<200 && !proxyDeleted; i++) {
+        usleep(10000);
+    }
+    ASSERT_TRUE(proxyDeleted);
+
+    //register managed test interface again
+    intParamValue++;
+    callbackArrived = false;
+
+    managedServiceRegistered = managerStub->registerManagedStubTestInterface(stubTestInterface, serviceAddressObject_.getInstance());
+    ASSERT_TRUE(managedServiceRegistered);
+
+    for(unsigned int i=0; i<200 && !callbackArrived; i++) {
+         usleep(10000);
+    }
+    ASSERT_TRUE(callbackArrived);
+
+    managerStub->deregisterManagedStubTestInterface(serviceAddressObject_.getInstance());
+    runtime_->unregisterService(managerServiceAddressObject.getDomain(), managerServiceInterface, managerServiceAddressObject.getInstance());
 }
 
 #ifndef __NO_MAIN__
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
+    ::testing::AddGlobalTestEnvironment(new Environment());
     return RUN_ALL_TESTS();
 }
 #endif