From fb5bd9d3850692564af58daa92721c93720528e6 Mon Sep 17 00:00:00 2001 From: "jyong2.kim" Date: Tue, 22 Sep 2015 15:58:28 +0900 Subject: [PATCH] Update unittest of notification-manager. Adding unittest for HostingObject Class, and fixing release of smart pointer. Change-Id: Ia27070b5908c5b42348a430dc602e136b70a9217 Signed-off-by: jyong2.kim Reviewed-on: https://gerrit.iotivity.org/gerrit/2911 Tested-by: jenkins-iotivity Reviewed-by: Hun-je Yeon Reviewed-by: Madan Lanka --- .../src/unittest/HostingObjectUnitTest.cpp | 199 +++++++++++++++++++++ .../src/unittest/RequestObjectUnitTest.cpp | 22 +-- .../unittest/ResourceEncapsulationTestSimulator.h | 13 +- ...HostingTest.cpp => ResourceHostingUnitTest.cpp} | 17 +- 4 files changed, 219 insertions(+), 32 deletions(-) create mode 100644 service/notification-manager/NotificationManager/src/unittest/HostingObjectUnitTest.cpp rename service/notification-manager/NotificationManager/src/unittest/{ResourceHostingTest.cpp => ResourceHostingUnitTest.cpp} (89%) diff --git a/service/notification-manager/NotificationManager/src/unittest/HostingObjectUnitTest.cpp b/service/notification-manager/NotificationManager/src/unittest/HostingObjectUnitTest.cpp new file mode 100644 index 0000000..4f28cec --- /dev/null +++ b/service/notification-manager/NotificationManager/src/unittest/HostingObjectUnitTest.cpp @@ -0,0 +1,199 @@ +//****************************************************************** +// +// Copyright 2015 Samsung Electronics All Rights Reserved. +// +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +#include + +#include "ResourceEncapsulationTestSimulator.h" +#include "HostingObject.h" + +#include "RCSDiscoveryManager.h" + +using namespace testing; +using namespace OIC::Service; + +namespace +{ + bool isDeleted = false; + void onDestroy(std::weak_ptr rPtr) + { + HostingObject::Ptr ptr = rPtr.lock(); + if(ptr) ptr.reset(); + isDeleted = true; + } + void onDiscoveryResource(RCSRemoteResourceObject::Ptr){ } + + void onUpdatedCache(const RCSResourceAttributes &) { } +} + +class HostingObjectTest : public TestWithMock +{ +public: + ResourceEncapsulationTestSimulator::Ptr testObject; + RCSRemoteResourceObject::Ptr remoteObject; + + std::mutex mutexForCondition; + std::condition_variable responseCon; + +protected: + + void SetUp() + { + TestWithMock::SetUp(); + + testObject = std::make_shared(); + testObject->defaultRunSimulator(); + remoteObject = testObject->getRemoteResource(); + + isDeleted = false; + } + + void TearDown() + { + TestWithMock::TearDown(); + + if(remoteObject.use_count() > 0) + { + if(remoteObject->isCaching()) + { + remoteObject->stopCaching(); + } + if(remoteObject->isMonitoring()) + { + remoteObject->stopMonitoring(); + } + } + testObject->destroy(); + } + +public: + void waitForCondition(int waitingTime = 1000) + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds{ waitingTime }); + } + + void notifyCondition() + { + responseCon.notify_all(); + } + +}; + +TEST_F(HostingObjectTest, startCachingAtInitialize) +{ + HostingObject::Ptr instance = std::make_shared(); + instance->initializeHostingObject( + remoteObject, std::bind(onDestroy, std::weak_ptr(instance))); + + EXPECT_TRUE(remoteObject->isCaching()); +} + +TEST_F(HostingObjectTest, startMonitoringAtInitialize) +{ + HostingObject::Ptr instance = std::make_shared(); + instance->initializeHostingObject( + remoteObject, std::bind(onDestroy, std::weak_ptr(instance))); + + ASSERT_TRUE(remoteObject->isMonitoring()); +} + +TEST_F(HostingObjectTest, getRemoteResourceisValid) +{ + HostingObject::Ptr instance = std::make_shared(); + instance->initializeHostingObject( + remoteObject, std::bind(onDestroy, std::weak_ptr(instance))); + + ASSERT_EQ(remoteObject->getUri(), instance->getRemoteResource()->getUri()); +} + +TEST_F(HostingObjectTest, createMirroredServer) +{ + int waitForResponse = 1000; + std::string uri = ""; + + HostingObject::Ptr instance = std::make_shared(); + instance->initializeHostingObject( + remoteObject, std::bind(onDestroy, std::weak_ptr(instance))); + std::this_thread::sleep_for(std::chrono::milliseconds {waitForResponse}); + + std::unique_ptr discoveryTask = { }; + + mocks.OnCallFunc(onDiscoveryResource).Do( + [this, &uri, &discoveryTask](RCSRemoteResourceObject::Ptr ptr) + { + if(ptr->getUri() == testObject->getHostedServerUri()) + { + uri = ptr->getUri(); + discoveryTask->cancel(); + notifyCondition(); + } + }); + + discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType( + RCSAddress::multicast(), "resource.hosting", onDiscoveryResource); + waitForCondition(waitForResponse); + + EXPECT_EQ(testObject->getHostedServerUri(), uri); +} + +TEST_F(HostingObjectTest, UpdateCachedDataWhenChangedOriginResource) +{ + int waitForResponse = 1000; + HostingObject::Ptr instance = std::make_shared(); + instance->initializeHostingObject( + remoteObject, std::bind(onDestroy, std::weak_ptr(instance))); + std::this_thread::sleep_for(std::chrono::milliseconds {waitForResponse}); + + std::unique_ptr discoveryTask = { }; + RCSRemoteResourceObject::Ptr discoveredResource = { }; + + mocks.OnCallFunc(onDiscoveryResource).Do( + [this, &discoveredResource, &discoveryTask](RCSRemoteResourceObject::Ptr ptr) + { + if(ptr->getUri() == testObject->getHostedServerUri()) + { + discoveredResource = ptr; + discoveryTask->cancel(); + notifyCondition(); + } + }); + + discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType( + RCSAddress::multicast(), "resource.hosting", onDiscoveryResource); + waitForCondition(waitForResponse); + + RCSResourceAttributes::Value result = { }; + mocks.OnCallFunc(onUpdatedCache).Do( + [this, &result](const RCSResourceAttributes & att) + { + result = att.at("Temperature"); + notifyCondition(); + }); + + discoveredResource->startCaching(onUpdatedCache); + std::this_thread::sleep_for(std::chrono::milliseconds {waitForResponse}); + + RCSResourceAttributes::Value settingValue = 10; + testObject->getResourceServer()->setAttribute("Temperature", settingValue); + waitForCondition(waitForResponse); + + EXPECT_EQ(result.toString(), settingValue.toString()); + +} diff --git a/service/notification-manager/NotificationManager/src/unittest/RequestObjectUnitTest.cpp b/service/notification-manager/NotificationManager/src/unittest/RequestObjectUnitTest.cpp index 03fe833..94df26b 100644 --- a/service/notification-manager/NotificationManager/src/unittest/RequestObjectUnitTest.cpp +++ b/service/notification-manager/NotificationManager/src/unittest/RequestObjectUnitTest.cpp @@ -51,24 +51,24 @@ protected: testObject = std::make_shared(); testObject->defaultRunSimulator(); - server = testObject->getResourceServer(); remoteObject = testObject->getRemoteResource(); } void TearDown() { TestWithMock::TearDown(); - if(remoteObject){ - if(remoteObject->isCaching()) - { - remoteObject->stopCaching(); - } - if(remoteObject->isMonitoring()) - { - remoteObject->stopMonitoring(); - } + if(remoteObject) + { + if(remoteObject->isCaching()) + { + remoteObject->stopCaching(); + } + if(remoteObject->isMonitoring()) + { + remoteObject->stopMonitoring(); + } } - testObject->destroy(); + testObject->destroy(); } public: diff --git a/service/notification-manager/NotificationManager/src/unittest/ResourceEncapsulationTestSimulator.h b/service/notification-manager/NotificationManager/src/unittest/ResourceEncapsulationTestSimulator.h index 69fbf09..ac3c61d 100644 --- a/service/notification-manager/NotificationManager/src/unittest/ResourceEncapsulationTestSimulator.h +++ b/service/notification-manager/NotificationManager/src/unittest/ResourceEncapsulationTestSimulator.h @@ -69,9 +69,7 @@ public: ATTR_VALUE(0) { } ~ResourceEncapsulationTestSimulator() - { - std::cout << "~ResourceEncapsulationTestSimulator()" << std::endl; - } + { } private: void onDiscoveryResource_Impl(RCSRemoteResourceObject::Ptr resourceObject) @@ -98,10 +96,6 @@ private: { ptr->onDiscoveryResource_Impl(resourceObject); } - else - { - std::cout << "Aleady delete simulator\n"; - } } void waitForDiscovery() { @@ -127,9 +121,8 @@ private: public: void destroy() { - server.reset(); - remoteResource.reset(); - std::cout << "waitforptrbeingunique" << std::endl; + if(server.use_count()) server.reset(); + if(remoteResource.use_count()) remoteResource.reset(); WaitForPtrBeingUnique(); } void defaultRunSimulator() diff --git a/service/notification-manager/NotificationManager/src/unittest/ResourceHostingTest.cpp b/service/notification-manager/NotificationManager/src/unittest/ResourceHostingUnitTest.cpp similarity index 89% rename from service/notification-manager/NotificationManager/src/unittest/ResourceHostingTest.cpp rename to service/notification-manager/NotificationManager/src/unittest/ResourceHostingUnitTest.cpp index d0f630c..404c953 100644 --- a/service/notification-manager/NotificationManager/src/unittest/ResourceHostingTest.cpp +++ b/service/notification-manager/NotificationManager/src/unittest/ResourceHostingUnitTest.cpp @@ -62,12 +62,10 @@ public: { std::unique_lock< std::mutex > lock{ mutexForCondition }; responseCon.wait_for(lock, std::chrono::milliseconds{ waitingTime }); - std::cout << "condition return back" << std::endl; } void notifyCondition() { - std::cout << "notify condition to all" << std::endl; responseCon.notify_all(); } @@ -89,15 +87,12 @@ TEST_F(ResourceHostingTest, HostingFoundBeforeMakeOriginServer) std::string uri = ""; mocks.OnCallFunc(onDiscoveryResource).Do( - [this, &uri, &testObject](RCSRemoteResourceObject::Ptr ptr) + [this, &uri, &testObject, &discoveryTask](RCSRemoteResourceObject::Ptr ptr) { - if(testObject.use_count() <= 0) - { - return; - } - if(ptr->getUri() == testObject->getServerUri()) + if(ptr->getUri() == testObject->getHostedServerUri()) { uri = ptr->getUri(); + discoveryTask->cancel(); notifyCondition(); } }); @@ -106,7 +101,7 @@ TEST_F(ResourceHostingTest, HostingFoundBeforeMakeOriginServer) RCSAddress::multicast(), "resource.hosting", onDiscoveryResource); waitForCondition(2000); - std::string mirroredUri = { testObject->getServerUri() }; + std::string mirroredUri = { testObject->getHostedServerUri() }; testObject->destroy(); @@ -133,8 +128,8 @@ TEST_F(ResourceHostingTest, stopHosting) ResourceHosting::getInstance()->startHosting(); std::this_thread::sleep_for(std::chrono::milliseconds{1000}); - + testObject->destroy(); ResourceHosting::getInstance()->stopHosting(); -} \ No newline at end of file +} -- 2.7.4