Update unittest for remote opertion in scene manager

In some cases, unittest would produces unexpected results especially when
creation and deletion of scene objects are repeated in continuous unittests.
This patch fixes this issue.

Change-Id: I0294215e5f2578145b4398808146bee1c8199a73
Signed-off-by: Jihun Ha <jihun.ha@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/10451
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: JungYong KIM <jyong2.kim@samsung.com>
Reviewed-by: Madan Lanka <lanka.madan@samsung.com>

diff --git a/service/scene-manager/unittests/RemoteSceneActionTest.cpp b/service/scene-manager/unittests/RemoteSceneActionTest.cpp
index a2cc988..48256dc 100755 (executable)
--- a/service/scene-manager/unittests/RemoteSceneActionTest.cpp
+++ b/service/scene-manager/unittests/RemoteSceneActionTest.cpp
@@ -29,6 +29,8 @@
 #include "RCSResourceObject.h"
 #include "RCSRemoteResourceObject.h"
 #include "OCPlatform.h"
+#include "RCSDiscoveryManager.h"
+#include "RCSAddress.h"
 
 using namespace std;
 using namespace OIC::Service;
@@ -43,88 +45,72 @@ constexpr char VALUE[]{ "off" };
 
 static int lightNum = 0;
 
-RCSRemoteResourceObject::Ptr pListResource;
-RemoteSceneList::Ptr pSceneList;
-RemoteSceneCollection::Ptr pSceneCollection;
-RemoteScene::Ptr pScene;
-RemoteSceneAction::Ptr pSceneAction;
-RCSRemoteResourceObject::Ptr pLightResource;
-std::condition_variable cond;
-std::mutex g_mutex;
+SceneList* g_sceneList = SceneList::getInstance();
+RCSRemoteResourceObject::Ptr pListResource = nullptr;
+RemoteSceneList::Ptr pSceneList = nullptr;
+RemoteSceneCollection::Ptr pSceneCollection = nullptr;
+RemoteScene::Ptr pScene = nullptr;
+RemoteSceneAction::Ptr pSceneAction = nullptr;
+RCSRemoteResourceObject::Ptr pLightResource = nullptr;
 
-void onRemoteSceneListCreated(RemoteSceneList::Ptr remoteSceneList, int)
+void discoverSceneListServer()
 {
-    pSceneList = std::move(remoteSceneList);
-    cond.notify_all();
-}
-
-void onRemoteSceneCollectionCreated(RemoteSceneCollection::Ptr remoteSceneCol, int)
-{
-    pSceneCollection = remoteSceneCol;
-    cond.notify_all();
-}
-
-void onRemoteSceneCreated(RemoteScene::Ptr remoteScene, int)
-{
-    pScene = remoteScene;
-    cond.notify_all();
-}
-
-void onRemoteSceneActionCreated(RemoteSceneAction::Ptr remoteSceneAction, int)
-{
-    pSceneAction = remoteSceneAction;
-    cond.notify_all();
-}
-
-void onActionUpdated(int)
-{
-    cond.notify_all();
-}
-void createListServer()
-{
-    std::vector< std::string > vecRT{ SCENE_LIST_RT };
-    std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
-
-    pListResource = SceneUtils::createRCSResourceObject(
-        "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
-        SCENE_CONNECTIVITY, vecRT, vecIF);
-}
+    if(pListResource == nullptr)
+    {
+        std::vector< std::string > vecRT{ SCENE_LIST_RT };
+        std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
 
-void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
-{
-    std::unique_lock< std::mutex > lock{ g_mutex };
-    cond.wait_for(lock, std::chrono::milliseconds{ waitingTime });
+        pListResource = SceneUtils::createRCSResourceObject(
+                            "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
+                            SCENE_CONNECTIVITY, vecRT, vecIF);
+    }
 }
 
-void setup()
+class RemoteSceneActionTest : public TestWithMock
 {
-    SceneList::getInstance()->getName();
-    createListServer();
-
-    RemoteSceneList::createInstance(pListResource, onRemoteSceneListCreated);
+protected:
+    void SetUp()
+    {
+        TestWithMock::SetUp();
 
-    waitForCallback();
+        g_sceneList->getName();
+        discoverSceneListServer();
 
-    pSceneList->addNewSceneCollection(onRemoteSceneCollectionCreated);
+        if(pSceneList == nullptr)
+        {
+            RemoteSceneList::createInstance(pListResource, std::bind(
+                &RemoteSceneActionTest::onRemoteSceneListCreated, this,
+                placeholders::_1, placeholders::_2));
 
-    waitForCallback();
+            waitForCallback();
+        }
 
-    pSceneCollection->addNewScene("Test Scene", onRemoteSceneCreated);
+        if(pSceneCollection == nullptr)
+        {
+            pSceneList->addNewSceneCollection(std::bind(
+                &RemoteSceneActionTest::onRemoteSceneCollectionCreated, this,
+                placeholders::_1, placeholders::_2));
 
-    waitForCallback();
-}
+            waitForCallback();
+        }
 
+        if(pScene == nullptr)
+        {
+            pSceneCollection->addNewScene("Test Scene", std::bind(
+                &RemoteSceneActionTest::onRemoteSceneCreated, this,
+                placeholders::_1, placeholders::_2));
 
-class RemoteSceneActionTest : public TestWithMock
-{
-protected:
-    void SetUp()
-    {
-        TestWithMock::SetUp();
+            waitForCallback();
+        }
     }
 
     void createLightServer()
     {
+        if(pLightResource != nullptr)
+        {
+            return ;
+        }
+
         RCSResourceObject::Ptr pResource = RCSResourceObject::Builder(
             RESOURCE_URI, RESOURCE_TYPE, DEFAULT_INTERFACE).build();
         pResource->setAttribute(KEY, RCSResourceAttributes::Value(VALUE));
@@ -133,19 +119,62 @@ protected:
             = SceneUtils::createRCSResourceObject(
             "coap://" + SceneUtils::getNetAddress() + RESOURCE_URI
             + "/" + std::to_string(lightNum++),
-            SCENE_CONNECTIVITY, pResource->getTypes(), pResource->getInterfaces());
+            (OCConnectivityType)(CT_ADAPTER_IP|CT_IP_USE_V4),
+            pResource->getTypes(), pResource->getInterfaces());
+    }
+
+    void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
+    {
+        std::unique_lock< std::mutex > lock{ mutex };
+        cond.wait_for(lock, std::chrono::milliseconds{ waitingTime });
+    }
+
+public:
+    bool executionSucceeded;
+    std::condition_variable cond;
+    std::mutex mutex;
+
+    void onRemoteSceneListCreated(RemoteSceneList::Ptr remoteSceneList, int)
+    {
+        pSceneList = std::move(remoteSceneList);
+        cond.notify_all();
+    }
+
+    void onRemoteSceneCollectionCreated(RemoteSceneCollection::Ptr remoteSceneCol, int)
+    {
+        pSceneCollection = remoteSceneCol;
+        cond.notify_all();
+    }
+
+    void onRemoteSceneCreated(RemoteScene::Ptr remoteScene, int)
+    {
+        pScene = remoteScene;
+        cond.notify_all();
+    }
+
+    void onRemoteSceneActionCreated(RemoteSceneAction::Ptr remoteSceneAction, int)
+    {
+        pSceneAction = remoteSceneAction;
+        cond.notify_all();
+    }
+
+    void onActionUpdated(int)
+    {
+        cond.notify_all();
     }
 };
 
 TEST_F(RemoteSceneActionTest, createSceneAction)
 {
-    setup();
     createLightServer();
 
-    pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
-        onRemoteSceneActionCreated);
-
-    waitForCallback();
+    if(pSceneAction == nullptr)
+    {
+        pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
+            std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     ASSERT_NE(nullptr, pSceneAction);
 }
@@ -153,18 +182,21 @@ TEST_F(RemoteSceneActionTest, createSceneAction)
 TEST_F(RemoteSceneActionTest, createSceneActionWithEmptyRCSRemoteResourceObjectPtr)
 {
     ASSERT_THROW(pScene->addNewSceneAction(nullptr, KEY, RCSResourceAttributes::Value(VALUE),
-        onRemoteSceneActionCreated), RCSInvalidParameterException);
+        std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
+        placeholders::_1, placeholders::_2)), RCSInvalidParameterException);
 }
 
 TEST_F(RemoteSceneActionTest, getAllRemoteSceneActions)
 {
-    setup();
     createLightServer();
 
-    pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
-        onRemoteSceneActionCreated);
-
-    waitForCallback();
+    if(pSceneAction == nullptr)
+    {
+        pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
+            std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     vector< RemoteSceneAction::Ptr > actions
         = pScene->getRemoteSceneActions();
@@ -178,10 +210,13 @@ TEST_F(RemoteSceneActionTest, getRemoteSceneAction)
 {
     createLightServer();
 
-    pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
-        onRemoteSceneActionCreated);
-
-    waitForCallback();
+    if(pSceneAction == nullptr)
+    {
+        pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
+            std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     RemoteSceneAction::Ptr action = pScene->getRemoteSceneAction(pLightResource);
 
@@ -193,13 +228,17 @@ TEST_F(RemoteSceneActionTest, updateSceneAction)
 {
     createLightServer();
 
-    pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
-        onRemoteSceneActionCreated);
-
-    waitForCallback();
+    if(pSceneAction == nullptr)
+    {
+        pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
+            std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     pSceneAction->resetExecutionParameter(
-        KEY, RCSResourceAttributes::Value("on"), onActionUpdated);
+        KEY, RCSResourceAttributes::Value("on"), std::bind(&RemoteSceneActionTest::onActionUpdated, this,
+        placeholders::_1));
 
     waitForCallback();
 

diff --git a/service/scene-manager/unittests/RemoteSceneCollectionTest.cpp b/service/scene-manager/unittests/RemoteSceneCollectionTest.cpp
old mode 100644 (file)
new mode 100755 (executable)
index bcc0888..a82a86e
--- a/service/scene-manager/unittests/RemoteSceneCollectionTest.cpp
+++ b/service/scene-manager/unittests/RemoteSceneCollectionTest.cpp
@@ -29,6 +29,8 @@
 #include "RCSResourceObject.h"
 #include "RCSRemoteResourceObject.h"
 #include "OCPlatform.h"
+#include "RCSDiscoveryManager.h"
+#include "RCSAddress.h"
 
 using namespace std;
 using namespace OIC::Service;
@@ -36,6 +38,25 @@ using namespace OC;
 
 constexpr int DEFAULT_WAITTIME = 2000;
 
+SceneList* g_sceneList = SceneList::getInstance();
+RCSRemoteResourceObject::Ptr pListResource = nullptr;
+RemoteSceneList::Ptr pSceneList = nullptr;
+RemoteSceneCollection::Ptr pSceneCollection = nullptr;
+RemoteScene::Ptr pScene = nullptr;
+
+void discoverSceneListServer()
+{
+    if(pListResource == nullptr)
+    {
+        std::vector< std::string > vecRT{ SCENE_LIST_RT };
+        std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
+
+        pListResource = SceneUtils::createRCSResourceObject(
+                            "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
+                            SCENE_CONNECTIVITY, vecRT, vecIF);
+    }
+}
+
 class RemoteSceneCollectionTest : public TestWithMock
 {
 protected:
@@ -43,24 +64,15 @@ protected:
     {
         TestWithMock::SetUp();
 
-        SceneList::getInstance()->getName();
-        createListServer();
-
-        RemoteSceneList::createInstance(pListResource, std::bind(
-            &RemoteSceneCollectionTest::onRemoteSceneListCreated, this,
-            placeholders::_1, placeholders::_2));
+        g_sceneList->getName();
+        discoverSceneListServer();
 
-        waitForCallback();
-    }
-
-    void createListServer()
-    {
-        std::vector< std::string > vecRT{ SCENE_LIST_RT };
-        std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
-
-        pListResource = SceneUtils::createRCSResourceObject(
-            "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
-            SCENE_CONNECTIVITY, vecRT, vecIF);
+        if(pSceneList == nullptr){
+            RemoteSceneList::createInstance(pListResource, std::bind(
+                &RemoteSceneCollectionTest::onRemoteSceneListCreated, this,
+                placeholders::_1, placeholders::_2));
+            waitForCallback();
+        }
     }
 
     void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
@@ -70,9 +82,6 @@ protected:
     }
 
 public:
-    RCSRemoteResourceObject::Ptr pListResource;
-    RemoteSceneList::Ptr pSceneList;
-    RemoteSceneCollection::Ptr pSceneCollection;
     std::condition_variable cond;
     std::mutex mutex;
 
@@ -88,8 +97,9 @@ public:
         cond.notify_all();
     }
 
-    void onRemoteSceneCreated(RemoteScene::Ptr, int)
+    void onRemoteSceneCreated(RemoteScene::Ptr remoteScene, int)
     {
+        pScene = remoteScene;
         cond.notify_all();
     }
 
@@ -101,17 +111,21 @@ public:
 
 TEST_F(RemoteSceneCollectionTest, addNewRemoteSceneCollection)
 {
-    pSceneList->addNewSceneCollection(std::bind(
-        &RemoteSceneCollectionTest::onRemoteSceneCollectionCreated, this,
-        placeholders::_1, placeholders::_2));
-
-    waitForCallback();
-
-    pSceneCollection->addNewScene("Default", std::bind(
-        &RemoteSceneCollectionTest::onRemoteSceneCreated, this,
-        placeholders::_1, placeholders::_2));
+    if(pSceneCollection == nullptr)
+    {
+        pSceneList->addNewSceneCollection(std::bind(
+            &RemoteSceneCollectionTest::onRemoteSceneCollectionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
-    waitForCallback();
+    if(pScene == nullptr)
+    {
+        pSceneCollection->addNewScene("Default", std::bind(
+            &RemoteSceneCollectionTest::onRemoteSceneCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     EXPECT_NE(nullptr, pSceneCollection);
 }
@@ -144,17 +158,21 @@ TEST_F(RemoteSceneCollectionTest, getRemoteSceneCollectionList)
 
 TEST_F(RemoteSceneCollectionTest, setAndGetSceneCollectionName)
 {
-    pSceneList->addNewSceneCollection(std::bind(
-        &RemoteSceneCollectionTest::onRemoteSceneCollectionCreated, this,
-        placeholders::_1, placeholders::_2));
-
-    waitForCallback();
-
-    pSceneCollection->addNewScene("Default", std::bind(
-        &RemoteSceneCollectionTest::onRemoteSceneCreated, this,
-        placeholders::_1, placeholders::_2));
+    if(pSceneCollection == nullptr)
+    {
+        pSceneList->addNewSceneCollection(std::bind(
+            &RemoteSceneCollectionTest::onRemoteSceneCollectionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
-    waitForCallback();
+    if(pScene == nullptr)
+    {
+        pSceneCollection->addNewScene("Default", std::bind(
+            &RemoteSceneCollectionTest::onRemoteSceneCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     pSceneCollection->setName("Kitchen", std::bind(
         &RemoteSceneCollectionTest::onSetName, this, placeholders::_1));

diff --git a/service/scene-manager/unittests/RemoteSceneListTest.cpp b/service/scene-manager/unittests/RemoteSceneListTest.cpp
old mode 100644 (file)
new mode 100755 (executable)
index b2575b7..e5e22ae
--- a/service/scene-manager/unittests/RemoteSceneListTest.cpp
+++ b/service/scene-manager/unittests/RemoteSceneListTest.cpp
@@ -22,12 +22,13 @@
 #include <condition_variable>
 
 #include "RemoteSceneList.h"
-
 #include "UnitTestHelper.h"
 #include "SceneCommons.h"
 #include "SceneList.h"
 #include "RCSRemoteResourceObject.h"
 #include "OCPlatform.h"
+#include "RCSDiscoveryManager.h"
+#include "RCSAddress.h"
 
 using namespace std;
 using namespace OIC::Service;
@@ -35,16 +36,13 @@ using namespace OC;
 
 constexpr int DEFAULT_WAITTIME = 2000;
 
-class RemoteSceneListTest : public TestWithMock
-{
-protected:
-    void SetUp()
-    {
-        TestWithMock::SetUp();
-        SceneList::getInstance()->getName();
-    }
+SceneList* g_sceneList = SceneList::getInstance();
+RCSRemoteResourceObject::Ptr pListResource = nullptr;
+RemoteSceneList::Ptr pSceneList = nullptr;
 
-    void createListServer()
+void discoverSceneListServer()
+{
+    if(pListResource == nullptr)
     {
         std::vector< std::string > vecRT{ SCENE_LIST_RT };
         std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
@@ -53,6 +51,16 @@ protected:
                             "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
                             SCENE_CONNECTIVITY, vecRT, vecIF);
     }
+}
+
+class RemoteSceneListTest : public TestWithMock
+{
+protected:
+    void SetUp()
+    {
+        TestWithMock::SetUp();
+        g_sceneList->getName();
+    }
 
     void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
     {
@@ -61,8 +69,6 @@ protected:
     }
 
 public:
-    RCSRemoteResourceObject::Ptr pListResource;
-    RemoteSceneList::Ptr pSceneList;
     std::condition_variable cond;
     std::mutex mutex;
 
@@ -80,22 +86,30 @@ public:
 
 TEST_F(RemoteSceneListTest, createRemoteSceneListInstance)
 {
-    createListServer();
-    RemoteSceneList::createInstance(pListResource, std::bind(
-        &RemoteSceneListTest::onRemoteSceneListCreated, this, placeholders::_1, placeholders::_2));
+    discoverSceneListServer();
+    if(pSceneList == nullptr)
+    {
+        RemoteSceneList::createInstance(pListResource, std::bind(
+            &RemoteSceneListTest::onRemoteSceneListCreated, this,
+            placeholders::_1, placeholders::_2));
 
-    waitForCallback();
+        waitForCallback();
+    }
 
     EXPECT_NE(nullptr, pSceneList);
 }
 
 TEST_F(RemoteSceneListTest, setAndGetRemoteSceneListName)
 {
-    createListServer();
-    RemoteSceneList::createInstance(pListResource, std::bind(
-        &RemoteSceneListTest::onRemoteSceneListCreated, this, placeholders::_1, placeholders::_2));
+    discoverSceneListServer();
+    if(pSceneList == nullptr)
+    {
+        RemoteSceneList::createInstance(pListResource, std::bind(
+            &RemoteSceneListTest::onRemoteSceneListCreated, this,
+            placeholders::_1, placeholders::_2));
 
-    waitForCallback();
+        waitForCallback();
+    }
 
     pSceneList->setName("Test Scene List", std::bind(
         &RemoteSceneListTest::onSetName, this, placeholders::_1));

diff --git a/service/scene-manager/unittests/RemoteSceneTest.cpp b/service/scene-manager/unittests/RemoteSceneTest.cpp
old mode 100644 (file)
new mode 100755 (executable)
index c51ed61..93196a8
--- a/service/scene-manager/unittests/RemoteSceneTest.cpp
+++ b/service/scene-manager/unittests/RemoteSceneTest.cpp
@@ -29,6 +29,8 @@
 #include "RCSResourceObject.h"
 #include "RCSRemoteResourceObject.h"
 #include "OCPlatform.h"
+#include "RCSDiscoveryManager.h"
+#include "RCSAddress.h"
 
 using namespace std;
 using namespace OIC::Service;
@@ -43,6 +45,27 @@ constexpr char VALUE[]{ "off" };
 
 static int lightNum = 0;
 
+SceneList* g_sceneList = SceneList::getInstance();
+RCSRemoteResourceObject::Ptr pListResource = nullptr;
+RemoteSceneList::Ptr pSceneList = nullptr;
+RemoteSceneCollection::Ptr pSceneCollection = nullptr;
+RemoteScene::Ptr pScene = nullptr;
+RemoteSceneAction::Ptr pSceneAction = nullptr;
+RCSRemoteResourceObject::Ptr pLightResource = nullptr;
+
+void discoverSceneListServer()
+{
+    if(pListResource == nullptr)
+    {
+        std::vector< std::string > vecRT{ SCENE_LIST_RT };
+        std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
+
+        pListResource = SceneUtils::createRCSResourceObject(
+                            "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
+                            SCENE_CONNECTIVITY, vecRT, vecIF);
+    }
+}
+
 class RemoteSceneTest : public TestWithMock
 {
 protected:
@@ -51,40 +74,35 @@ protected:
         TestWithMock::SetUp();
         executionSucceeded = false;
 
-        SceneList::getInstance()->getName();
-        createListServer();
+        g_sceneList->getName();
+        discoverSceneListServer();
 
-        RemoteSceneList::createInstance(pListResource, std::bind(
-            &RemoteSceneTest::onRemoteSceneListCreated, this,
-            placeholders::_1, placeholders::_2));
+        if(pSceneList == nullptr)
+        {
+            RemoteSceneList::createInstance(pListResource, std::bind(
+                &RemoteSceneTest::onRemoteSceneListCreated, this,
+                placeholders::_1, placeholders::_2));
 
-        waitForCallback();
+            waitForCallback();
+        }
 
-        pSceneList->addNewSceneCollection(std::bind(
-            &RemoteSceneTest::onRemoteSceneCollectionCreated, this,
-            placeholders::_1, placeholders::_2));
-
-        waitForCallback();
+        if(pSceneCollection == nullptr)
+        {
+            pSceneList->addNewSceneCollection(std::bind(
+                &RemoteSceneTest::onRemoteSceneCollectionCreated, this,
+                placeholders::_1, placeholders::_2));
 
-        pSceneCollection->addNewScene("Default", std::bind(
-            &RemoteSceneTest::onRemoteSceneCreated, this,
-            placeholders::_1, placeholders::_2));
-
-        waitForCallback();
-    }
-
-    void createListServer()
-    {
-        std::vector< std::string > vecRT{ SCENE_LIST_RT };
-        std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
-
-        pListResource = SceneUtils::createRCSResourceObject(
-            "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
-            SCENE_CONNECTIVITY, vecRT, vecIF);
+            waitForCallback();
+        }
     }
 
     void createLightServer()
     {
+        if(pLightResource != nullptr)
+        {
+            return ;
+        }
+
         RCSResourceObject::Ptr pResource = RCSResourceObject::Builder(
             RESOURCE_URI, RESOURCE_TYPE, DEFAULT_INTERFACE).build();
         pResource->setAttribute(KEY, RCSResourceAttributes::Value(VALUE));
@@ -93,7 +111,9 @@ protected:
             = SceneUtils::createRCSResourceObject(
             "coap://" + SceneUtils::getNetAddress() + RESOURCE_URI
             + "/" + std::to_string(lightNum++),
-            SCENE_CONNECTIVITY, pResource->getTypes(), pResource->getInterfaces());
+            (OCConnectivityType)(CT_ADAPTER_IP|CT_IP_USE_V4),
+            pResource->getTypes(), pResource->getInterfaces());
+
     }
 
     void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
@@ -103,11 +123,6 @@ protected:
     }
 
 public:
-    RCSRemoteResourceObject::Ptr pListResource;
-    RemoteSceneList::Ptr pSceneList;
-    RemoteSceneCollection::Ptr pSceneCollection;
-    RemoteScene::Ptr pScene;
-    RCSRemoteResourceObject::Ptr pLightResource;
     bool executionSucceeded;
     std::condition_variable cond;
     std::mutex mutex;
@@ -144,11 +159,13 @@ public:
 
 TEST_F(RemoteSceneTest, addNewRemoteScene)
 {
-    pSceneCollection->addNewScene("Test Scene", std::bind(
-        &RemoteSceneTest::onRemoteSceneCreated, this,
-        placeholders::_1, placeholders::_2));
-
-    waitForCallback();
+    if(pScene == nullptr)
+    {
+        pSceneCollection->addNewScene("Test Scene", std::bind(
+            &RemoteSceneTest::onRemoteSceneCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     ASSERT_NE(nullptr, pScene);
     ASSERT_EQ("Test Scene", pScene->getName());
@@ -164,11 +181,13 @@ TEST_F(RemoteSceneTest, createNewRemoteSceneWithEmptyName)
 
 TEST_F(RemoteSceneTest, getRemoteSceneBySceneName)
 {
-    pSceneCollection->addNewScene("Test Scene", std::bind(
-        &RemoteSceneTest::onRemoteSceneCreated, this,
-        placeholders::_1, placeholders::_2));
-
-    waitForCallback();
+    if(pScene == nullptr)
+    {
+        pSceneCollection->addNewScene("Test Scene", std::bind(
+            &RemoteSceneTest::onRemoteSceneCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     auto scene = pSceneCollection->getRemoteScene("Test Scene");
 
@@ -178,15 +197,17 @@ TEST_F(RemoteSceneTest, getRemoteSceneBySceneName)
 
 TEST_F(RemoteSceneTest, getAllRemoteScenes)
 {
-    pSceneCollection->addNewScene("Test Scene", std::bind(
-        &RemoteSceneTest::onRemoteSceneCreated, this,
-        placeholders::_1, placeholders::_2));
-
-    waitForCallback();
+    if(pScene == nullptr)
+    {
+        pSceneCollection->addNewScene("Test Scene", std::bind(
+            &RemoteSceneTest::onRemoteSceneCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     auto scenes = pSceneCollection->getRemoteScenes();
 
-    ASSERT_EQ((unsigned int)2, scenes.size());
+    ASSERT_EQ((unsigned int)1, scenes.size());
     ASSERT_NE(scenes.end(), scenes.find("Test Scene"));
 }
 
@@ -194,11 +215,13 @@ TEST_F(RemoteSceneTest, executeRemoteScene)
 {
     createLightServer();
 
-    pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
-        std::bind(&RemoteSceneTest::onRemoteSceneActionCreated, this,
-        placeholders::_1, placeholders::_2));
-
-    waitForCallback();
+    if(pSceneAction == nullptr)
+    {
+        pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
+            std::bind(&RemoteSceneTest::onRemoteSceneActionCreated, this,
+            placeholders::_1, placeholders::_2));
+        waitForCallback();
+    }
 
     pScene->execute(std::bind(
         &RemoteSceneTest::onRemoteSceneExecuted, this, placeholders::_1, placeholders::_2));