From 352fb70b55c95bf74217fc2fc950d62d6288530d Mon Sep 17 00:00:00 2001 From: "nikhil.a" Date: Fri, 12 Aug 2016 17:16:19 +0530 Subject: [PATCH] Notification cpp-wrapper UnitTest 1)Added ProviderService unittest 2)Added ConsumerService unittest Change-Id: Ibb510f4e1e6407ca3ecab791ea4d2e76f03e669c Signed-off-by: nikhil.a Reviewed-on: https://gerrit.iotivity.org/gerrit/10345 Tested-by: jenkins-iotivity Reviewed-by: Madan Lanka --- service/notification/cpp-wrapper/SConscript | 23 + .../unittest/NSConsumerServiceSimulator.h | 194 +++++++++ .../cpp-wrapper/unittest/NSConsumerServiceTest.cpp | 476 +++++++++++++++++++++ .../unittest/NSProviderServiceSimulator.h | 333 ++++++++++++++ .../cpp-wrapper/unittest/NSProviderServiceTest.cpp | 337 +++++++++++++++ .../notification/cpp-wrapper/unittest/SConscript | 99 +++++ 6 files changed, 1462 insertions(+) create mode 100644 service/notification/cpp-wrapper/unittest/NSConsumerServiceSimulator.h create mode 100644 service/notification/cpp-wrapper/unittest/NSConsumerServiceTest.cpp create mode 100644 service/notification/cpp-wrapper/unittest/NSProviderServiceSimulator.h create mode 100644 service/notification/cpp-wrapper/unittest/NSProviderServiceTest.cpp create mode 100644 service/notification/cpp-wrapper/unittest/SConscript diff --git a/service/notification/cpp-wrapper/SConscript b/service/notification/cpp-wrapper/SConscript index 8178583..81316e3 100755 --- a/service/notification/cpp-wrapper/SConscript +++ b/service/notification/cpp-wrapper/SConscript @@ -1,3 +1,23 @@ +#****************************************************************** +# +# Copyright 2016 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. +# +#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + # build producer notification wrapper SConscript('provider/SConscript') @@ -6,3 +26,6 @@ SConscript('consumer/SConscript') # Go to build sample apps using wrapper SConscript('examples/linux/SConscript') + +# Go to build Unit test +SConscript('unittest/SConscript') \ No newline at end of file diff --git a/service/notification/cpp-wrapper/unittest/NSConsumerServiceSimulator.h b/service/notification/cpp-wrapper/unittest/NSConsumerServiceSimulator.h new file mode 100644 index 0000000..cf22831 --- /dev/null +++ b/service/notification/cpp-wrapper/unittest/NSConsumerServiceSimulator.h @@ -0,0 +1,194 @@ +//****************************************************************** +// +// Copyright 2016 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. +// +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +#ifndef _NS_CONSUMER_SERVICE_SIMULATOR_H_ +#define _NS_CONSUMER_SERVICE_SIMULATOR_H_ + +#include + +#include "OCPlatform.h" +#include "OCApi.h" + +class NSConsumerSimulator +{ +private: + std::function m_messageFunc; + std::function m_syncFunc; + + std::shared_ptr m_syncResource; + std::shared_ptr m_msgResource; + +public: + NSConsumerSimulator() + : m_messageFunc(), m_syncFunc(), + m_syncResource() { }; + ~NSConsumerSimulator() = default; + + NSConsumerSimulator(const NSConsumerSimulator &) = delete; + NSConsumerSimulator & operator = (const NSConsumerSimulator &) = delete; + + NSConsumerSimulator(NSConsumerSimulator &&) = delete; + NSConsumerSimulator & operator = (NSConsumerSimulator &&) = delete; + + void findProvider() + { + OC::OCPlatform::findResource("", std::string("/oic/res?rt=oic.r.notification"), + OCConnectivityType::CT_DEFAULT, + std::bind(&NSConsumerSimulator::findResultCallback, this, std::placeholders::_1), + OC::QualityOfService::LowQos); + } + + void syncToProvider(int & type, const int & id, const std::string & providerID) + { + if (m_syncResource == nullptr) + { + std::cout << "m_syncResource is null" << std::endl; + return; + } + + OC::OCRepresentation rep; + rep.setValue("PROVIDER_ID", providerID); + rep.setValue("MESSAGE_ID", id); + rep.setValue("STATE", type); + + m_syncResource->post(rep, OC::QueryParamsMap(), &onPost, OC::QualityOfService::LowQos); + } + + bool cancelObserves() + { + if(!msgResourceCancelObserve(OC::QualityOfService::HighQos) && + !syncResourceCancelObserve(OC::QualityOfService::HighQos)) + return true; + return false; + } + + void setCallback(std::function messageFunc, + const std::function & syncFunc) + { + m_messageFunc = messageFunc; + m_syncFunc = syncFunc; + } + +private: + static void onPost(const OC::HeaderOptions &/*headerOption*/, + const OC::OCRepresentation & /*rep*/ , const int eCode) + { + std::cout << __func__ << " result : " << eCode << std::endl; + } + void findResultCallback(std::shared_ptr resource) + { + + std::cout << __func__ << " " << resource->host() << std::endl; + + if(resource->uri() == "/notification") + { + resource->get(OC::QueryParamsMap(), + std::bind(&NSConsumerSimulator::onGet, this, + std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, resource), + OC::QualityOfService::LowQos); + } + } + void onGet(const OC::HeaderOptions &/*headerOption*/, + const OC::OCRepresentation & rep , const int eCode, + std::shared_ptr resource) + { + std::cout << __func__ << " " << rep.getHost() << " result : " << eCode << std::endl; + + OC::QueryParamsMap map; + map.insert(std::pair(std::string("consumerid"), std::string("123456789012345678901234567890123456"))); + + try + { + std::cout << "resourc : host " << resource->host() << std::endl; + std::cout << "resourc : uri " << resource->uri() << std::endl; + std::cout << " resource->connectivityType() " << resource->connectivityType() << std::endl; + std::cout << "resourc : getResourceInterfaces " << resource->getResourceInterfaces()[0] << std::endl; + std::cout << "resourc : getResourceTypes " << resource->getResourceTypes()[0] << std::endl; + + std::vector rts{"oic.r.notification"}; + + m_msgResource + = OC::OCPlatform::constructResourceObject( + std::string(resource->host()), std::string(resource->uri() + "/message"), + OCConnectivityType(resource->connectivityType()), true, rts, + std::vector(resource->getResourceInterfaces())); + + m_msgResource->observe(OC::ObserveType::Observe, map, + std::bind(&NSConsumerSimulator::onObserve, this, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4, resource), + OC::QualityOfService::LowQos); + } + catch(std::exception & e) + { + std::cout << "OC::ResoureInitException : " << e.what() << std::endl; + } + m_syncResource + = OC::OCPlatform::constructResourceObject(resource->host(), resource->uri() + "/sync", + resource->connectivityType(), true, resource->getResourceTypes(), + resource->getResourceInterfaces()); + + m_syncResource->observe(OC::ObserveType::Observe, map, + std::bind(&NSConsumerSimulator::onObserve, this, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4, resource), + OC::QualityOfService::LowQos); + + } + void onObserve(const OC::HeaderOptions &/*headerOption*/, + const OC::OCRepresentation &rep , const int &eCode, const int &, + std::shared_ptr ) + { + std::cout << __func__ << " " << rep.getHost() << " result : " << eCode; + std::cout << " uri : " << rep.getUri() << std::endl; + + if (rep.getUri() == "/notification/message" && rep.hasAttribute("MESSAGE_ID") + && rep.getValue("MESSAGE_ID") != 1) + { + std::cout << "ID : " << rep.getValue("ID") << std::endl; + std::cout << "TITLE : " << rep.getValueToString("TITLE") << std::endl; + std::cout << "CONTENT : " << rep.getValueToString("CONTENT") << std::endl; + m_messageFunc(int(rep.getValue("MESSAGE_ID")), + std::string(rep.getValueToString("TITLE")), + std::string(rep.getValueToString("CONTENT")), + std::string(rep.getValueToString("SOURCE"))); + } + else if (rep.getUri() == "/notification/sync") + { + std::cout << "else if (rep.getUri() == sync) " << std::endl; + m_syncFunc(int(rep.getValue("STATE")), int(rep.getValue("ID"))); + } + } + + OCStackResult msgResourceCancelObserve(OC::QualityOfService qos) + { + return m_msgResource->cancelObserve(qos); + } + + OCStackResult syncResourceCancelObserve(OC::QualityOfService qos) + { + return m_syncResource->cancelObserve(qos); + } +}; + + +#endif //_NS_CONSUMER_SERVICE_SIMULATOR_H_ \ No newline at end of file diff --git a/service/notification/cpp-wrapper/unittest/NSConsumerServiceTest.cpp b/service/notification/cpp-wrapper/unittest/NSConsumerServiceTest.cpp new file mode 100644 index 0000000..686e7df --- /dev/null +++ b/service/notification/cpp-wrapper/unittest/NSConsumerServiceTest.cpp @@ -0,0 +1,476 @@ +//****************************************************************** +// +// Copyright 2016 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 +#include +#include +#include +#include +#include + +#include "ocstack.h" + +#include "NSUtils.h" +#include "NSSyncInfo.h" +#include "NSMessage.h" +#include "NSMediaContents.h" +#include "NSConsumerService.h" + +#include "NSProviderServiceSimulator.h" + +namespace +{ + NSProviderSimulator g_providerSimul; + OIC::Service::NSProvider * g_provider; + + std::atomic_bool g_isStartedStack(false); + + std::chrono::milliseconds g_waitForResponse(2000); + + std::condition_variable responseCon; + std::mutex mutexForCondition; + + enum class NSSelector + { + NS_SELECTION_CONSUMER = 0, + NS_SELECTION_PROVIDER = 1 + }; + +} + +class TestWithMock: public testing::Test +{ +public: + MockRepository mocks; + +protected: + virtual ~TestWithMock() noexcept(noexcept(std::declval().~Test())) + { + + } + + virtual void TearDown() + { + try + { + mocks.VerifyAll(); + } + catch (...) + { + mocks.reset(); + throw; + } + } +}; + +class NotificationServiceConsumerTest : public TestWithMock +{ +public: + NotificationServiceConsumerTest() = default; + ~NotificationServiceConsumerTest() = default; + + static void ProviderDiscoveredCallbackEmpty( OIC::Service::NSProvider *) + { + std::cout << __func__ << std::endl; + } + + static void NotificationReceivedCallbackEmpty( OIC::Service::NSMessage *) + { + std::cout << __func__ << std::endl; + } + + static void SyncCallbackEmpty(OIC::Service::NSSyncInfo *) + { + std::cout << __func__ << std::endl; + } + + static void FoundResourceEmpty(std::shared_ptr< OC::OCResource >) + { + std::cout << __func__ << std::endl; + } + + static void ProviderChangedCallbackEmpty( OIC::Service::NSProvider * , OIC::Service::NSResponse ) + { + std::cout << __func__ << std::endl; + } + +protected: + + void SetUp() + { + TestWithMock::SetUp(); + + if (g_isStartedStack == false) + { + OC::PlatformConfig cfg + { + OC::ServiceType::InProc, + OC::ModeType::Both, + "0.0.0.0", + 0, + OC::QualityOfService::LowQos + }; + OC::OCPlatform::Configure(cfg); + + try + { + OC::OCPlatform::stopPresence(); + } + catch (...) + { + + } + + g_isStartedStack = true; + } + + } + + void TearDown() + { + TestWithMock::TearDown(); + } + +}; + +TEST_F(NotificationServiceConsumerTest, StartConsumerPositive) +{ + OIC::Service::NSConsumerService::ConsumerConfig cfg; + cfg.m_discoverCb = ProviderDiscoveredCallbackEmpty; + cfg.m_changedCb = ProviderChangedCallbackEmpty; + OIC::Service::NSConsumerService::getInstance()->Start(cfg); +} + +TEST_F(NotificationServiceConsumerTest, StopConsumerPositive) +{ + OIC::Service::NSConsumerService::getInstance()->Stop(); +} + +TEST_F(NotificationServiceConsumerTest, DiscoverProviderWithNonAccepterWhenStartedConsumerFirst) +{ + mocks.ExpectCallFunc(ProviderDiscoveredCallbackEmpty).Do( + [this]( OIC::Service::NSProvider * provider) + { + std::cout << "Call Discovered" << std::endl; + g_provider = provider; + g_provider->subscribe(); + g_provider->setListener((OIC::Service::NSProvider::MessageReceivedCallback)NotificationReceivedCallbackEmpty, + (OIC::Service::NSProvider::SyncInfoReceivedCallback)SyncCallbackEmpty); + responseCon.notify_all(); + }); + + OIC::Service::NSConsumerService::ConsumerConfig cfg; + cfg.m_discoverCb = ProviderDiscoveredCallbackEmpty; + cfg.m_changedCb = ProviderChangedCallbackEmpty; + OIC::Service::NSConsumerService::getInstance()->Start(cfg); + + g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER); + g_providerSimul.createNotificationResource(); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + + OIC::Service::NSConsumerService::getInstance()->Stop(); + g_providerSimul.deleteNotificationResource(); +} + +TEST_F(NotificationServiceConsumerTest, DiscoverProviderWithNonAccepterWhenStartedConsumerAfter) +{ + g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER); + g_providerSimul.createNotificationResource(); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + mocks.ExpectCallFunc(ProviderDiscoveredCallbackEmpty).Do( + [this]( OIC::Service::NSProvider * provider) + { + std::cout << "Call Discovered" << std::endl; + g_provider->subscribe(); + g_provider->setListener((OIC::Service::NSProvider::MessageReceivedCallback)NotificationReceivedCallbackEmpty, + (OIC::Service::NSProvider::SyncInfoReceivedCallback)SyncCallbackEmpty); + responseCon.notify_all(); + }); + + OIC::Service::NSConsumerService::ConsumerConfig cfg; + cfg.m_discoverCb = ProviderDiscoveredCallbackEmpty; + cfg.m_changedCb = ProviderChangedCallbackEmpty; + OIC::Service::NSConsumerService::getInstance()->Start(cfg); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + +} + +TEST_F(NotificationServiceConsumerTest, DiscoverProviderWithNonAccepterWhenRescan) +{ + g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER); + mocks.ExpectCallFunc(ProviderDiscoveredCallbackEmpty).Do( + [this]( OIC::Service::NSProvider * provider) + { + std::cout << "Call Discovered" << std::endl; + g_provider = provider; + g_provider->subscribe(); + g_provider->setListener((OIC::Service::NSProvider::MessageReceivedCallback)NotificationReceivedCallbackEmpty, + (OIC::Service::NSProvider::SyncInfoReceivedCallback)SyncCallbackEmpty); + std::cout << g_provider->getProviderId() << std::endl; + responseCon.notify_all(); + }); + + OIC::Service::NSConsumerService::getInstance()->RescanProvider(); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + +// OIC::Service::NSConsumerService::getInstance()->Stop(); +} + +TEST_F(NotificationServiceConsumerTest, ExpectSubscribeSuccess) +{ +// mocks.ExpectCallFunc(ProviderChangedCallbackEmpty).Do( +// []( OIC::Service::NSProvider * , OIC::Service::NSResponse) +// { +// std::cout << "Income Accepted subscription : " << std::endl; +// }); + + g_provider->subscribe(); + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); +} + +TEST_F(NotificationServiceConsumerTest, ExpectReceiveNotification) +{ + uint64_t id = 10; + std::string title = "title"; + std::string msg = "msg"; + + mocks.ExpectCallFunc(NotificationReceivedCallbackEmpty).Do( + []( OIC::Service::NSMessage * message) + { + std::cout << "Income Notification : " << message->getMessageId() << std::endl; + }); + + g_providerSimul.notifyMessage(id, title, msg); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + + OIC::Service::NSConsumerService::getInstance()->Stop(); +} + +TEST_F(NotificationServiceConsumerTest, ExpectReceiveNotificationWithAccepterisProvider) +{ + uint64_t id = 11; + std::string title = "title"; + std::string msg = "msg"; + + g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_PROVIDER); + + OIC::Service::NSConsumerService::ConsumerConfig cfg; + cfg.m_discoverCb = ProviderDiscoveredCallbackEmpty; + cfg.m_changedCb = ProviderChangedCallbackEmpty; + OIC::Service::NSConsumerService::getInstance()->Start(cfg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + mocks.ExpectCallFunc(NotificationReceivedCallbackEmpty).Do( + []( OIC::Service::NSMessage * message) + { + std::cout << "Income Notification : " << message->getMessageId() << std::endl; + }); + + g_providerSimul.notifyMessage(id, title, msg); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + +// g_providerSimul.deleteNotificationResource(); +// OIC::Service::NSConsumerService::getInstance()->Stop(); +} + +TEST_F(NotificationServiceConsumerTest, ExpectCallbackReadCheckWhenProviderNotifySync) +{ + uint64_t id = 12; + std::string title = "title"; + std::string msg = "msg"; + + OIC::Service::NSSyncInfo::NSSyncType type = OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED; + + mocks.OnCallFunc(NotificationReceivedCallbackEmpty).Do( + []( OIC::Service::NSMessage * message) + { + std::cout << "Income Notification : " << message->getMessageId() << std::endl; + }); + + mocks.ExpectCallFunc(SyncCallbackEmpty).Do( + [& type](OIC::Service::NSSyncInfo * sync) + { + std::cout << "Income SyncInfo : " << sync->getMessageId() + << ", State : " << (int) sync->getState() << std::endl; + type = sync->getState(); + + }); + + g_providerSimul.notifyMessage(id, title, msg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + g_providerSimul.sendRead(id); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + +// g_providerSimul.deleteNotificationResource(); +// OIC::Service::NSConsumerService::getInstance()->Stop(); + + EXPECT_EQ(OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ, type); +} + +TEST_F(NotificationServiceConsumerTest, ExpectCallbackDismissCheckWhenProviderNotifySync) +{ + uint64_t id = 13; + std::string title = "title"; + std::string msg = "msg"; + + OIC::Service::NSSyncInfo::NSSyncType type = OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ; + + mocks.OnCallFunc(NotificationReceivedCallbackEmpty).Do( + []( OIC::Service::NSMessage * message) + { + std::cout << "Income Notification : " << message->getMessageId() << std::endl; + }); + + mocks.ExpectCallFunc(SyncCallbackEmpty).Do( + [& type](OIC::Service::NSSyncInfo * sync) + { + std::cout << "Income Notification : " << sync->getMessageId() + << ", State : " << (int) sync->getState() << std::endl; + type = sync->getState(); + + }); + + g_providerSimul.notifyMessage(id, title, msg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + g_providerSimul.sendDismiss(id); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + +// g_providerSimul.deleteNotificationResource(); +// OIC::Service::NSConsumerService::getInstance()->Stop(); + + EXPECT_EQ(OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED, type); +} + +TEST_F(NotificationServiceConsumerTest, ExpectCallbackReadCheckWhenConsumerPostSync) +{ + uint64_t id = 14; + std::string title = "title"; + std::string msg = "msg"; + + OIC::Service::NSSyncInfo::NSSyncType type = OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED; + + mocks.OnCallFunc(NotificationReceivedCallbackEmpty).Do( + []( OIC::Service::NSMessage * message) + { + std::cout << "Income Notification : " << message->getMessageId() << std::endl; + g_provider->SendSyncInfo(message->getMessageId(), OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ); + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + }); + + mocks.ExpectCallFunc(SyncCallbackEmpty).Do( + [& type](OIC::Service::NSSyncInfo * sync) + { + std::cout << "Income Notification : " << sync->getMessageId() + << ", State : " << (int) sync->getState() << std::endl; + type = sync->getState(); + + }); + + g_providerSimul.notifyMessage(id, title, msg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + +// g_providerSimul.deleteNotificationResource(); +// OIC::Service::NSConsumerService::getInstance()->Stop(); + + EXPECT_EQ(OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ, type); +} + +TEST_F(NotificationServiceConsumerTest, ExpectCallbackDismissCheckWhenConsumerPostSync) +{ + uint64_t id = 15; + std::string title = "title"; + std::string msg = "msg"; + + OIC::Service::NSSyncInfo::NSSyncType type = OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ; + + mocks.OnCallFunc(NotificationReceivedCallbackEmpty).Do( + []( OIC::Service::NSMessage * message) + { + std::cout << "Income Notification : " << message->getMessageId() << std::endl; + g_provider->SendSyncInfo(message->getMessageId(), OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED); + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + }); + + mocks.ExpectCallFunc(SyncCallbackEmpty).Do( + [& type](OIC::Service::NSSyncInfo * sync) + { + std::cout << "Income Notification : " << sync->getMessageId() + << ", State : " << (int) sync->getState() << std::endl; + type = sync->getState(); + + }); + + g_providerSimul.notifyMessage(id, title, msg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + EXPECT_EQ(OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED, type); +} + +TEST_F(NotificationServiceConsumerTest, ExpectUnsubscribeSuccess) +{ + g_provider->unSubscribe(); + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + + g_providerSimul.deleteNotificationResource(); + OIC::Service::NSConsumerService::getInstance()->Stop(); + +} diff --git a/service/notification/cpp-wrapper/unittest/NSProviderServiceSimulator.h b/service/notification/cpp-wrapper/unittest/NSProviderServiceSimulator.h new file mode 100644 index 0000000..1371e89 --- /dev/null +++ b/service/notification/cpp-wrapper/unittest/NSProviderServiceSimulator.h @@ -0,0 +1,333 @@ +//****************************************************************** +// +// Copyright 2016 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. +// +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +#ifndef _NS_PROVIDER_SERVICE_SIMULATOR_H_ +#define _NS_PROVIDER_SERVICE_SIMULATOR_H_ + +#include + +#include "OCPlatform.h" +#include "OCApi.h" +#include "OCResourceResponse.h" + +namespace +{ + enum class requestType + { + NS_NOTIFICATION, + NS_MESSAGE, + NS_SYNC, + }; +} + +class NSProviderSimulator +{ +private: + OCResourceHandle m_notificationHandle; + OCResourceHandle m_messageHandle; + OCResourceHandle m_syncHandle; + OC::OCRepresentation m_syncRep; + OC::OCRepresentation m_messageRep; + int m_accepter; + + std::string m_notificationUri; + std::string m_messageUri; + std::string m_syncUri; + + OC::ObservationIds m_syncObservers; + +public: + NSProviderSimulator() + : m_notificationHandle(), m_messageHandle(), m_syncHandle(), + m_syncRep(), m_messageRep(), m_accepter(0), + m_notificationUri(std::string("/notification")), + m_messageUri(std::string("/message")), + m_syncUri(std::string("/sync")), + m_syncObservers() + { + + }; + + ~NSProviderSimulator() = default; + + NSProviderSimulator(const NSProviderSimulator &) = delete; + NSProviderSimulator & operator = (const NSProviderSimulator &) = delete; + + NSProviderSimulator(NSProviderSimulator &&) = delete; + NSProviderSimulator & operator = (NSProviderSimulator &&) = delete; + +private: + std::shared_ptr getResponse( + std::shared_ptr< OC::OCResourceRequest > requests, requestType type) + { + auto response = std::make_shared(); + response->setRequestHandle(requests->getRequestHandle()); + response->setResourceHandle(requests->getResourceHandle()); + + int requestFlag = requests->getRequestHandlerFlag(); + if (requestFlag == OC::RequestHandlerFlag::RequestFlag) + { + std::string request = requests->getRequestType(); + + response->setErrorCode(200); + response->setResponseResult(OC_EH_OK); + + if (request == "GET") + { + OC::OCRepresentation rep; + + if (type == requestType::NS_NOTIFICATION) + { + std::string msgUri = m_notificationUri + m_messageUri; + std::string syncUri = m_notificationUri + m_syncUri; + std::string providerId = "123456789012345678901234567890123456"; + rep.setValue("ACCEPTER", m_accepter); + rep.setValue("MESSAGE_URI", msgUri); + rep.setValue("SYNC_URI", syncUri); + rep.setValue("PROVIDER_ID", providerId); + } + else if (type == requestType::NS_SYNC) + { + rep = m_syncRep; + } + else if (type == requestType::NS_MESSAGE) + { + rep = m_messageRep; + } + else + { + return NULL; + } + + response->setResourceRepresentation(rep); + return response; + } + + else if (request == "POST" && type == requestType::NS_SYNC) + { + m_syncRep = requests->getResourceRepresentation(); + + std::cout << "Receive POST at Sync" << std::endl; + std::cout << "Sync Id : " << m_syncRep.getValueToString("ID") << std::endl; + std::cout << "Sync State : " << m_syncRep.getValueToString("STATE") << std::endl; + + response->setResourceRepresentation(m_syncRep); + + OC::OCPlatform::notifyListOfObservers(m_syncHandle, m_syncObservers, response); + + return response; + } + } + + return NULL; + } + + void setObserver(std::shared_ptr< OC::OCResourceRequest > requests, requestType type) + { + if (type == requestType::NS_SYNC) + { + OC::ObservationInfo observationInfo = requests->getObservationInfo(); + if (OC::ObserveAction::ObserveRegister == observationInfo.action) + { + m_syncObservers.push_back(observationInfo.obsId); + } + else if (OC::ObserveAction::ObserveUnregister == observationInfo.action) + { + m_syncObservers.erase(std::remove( + m_syncObservers.begin(), m_syncObservers.end(), + observationInfo.obsId), m_syncObservers.end()); + } + } + else if (type == requestType::NS_MESSAGE) + { + OC::OCRepresentation rep; + std::string providerId = "123456789012345678901234567890123456"; + rep.setValue("MESSAGE_ID", (int)1); + rep.setValue("PROVIDER_ID", providerId); + + auto response = std::make_shared(); + response->setRequestHandle(requests->getRequestHandle()); + response->setResourceHandle(requests->getResourceHandle()); + response->setErrorCode(200); + response->setResponseResult(OC_EH_OK); + response->setResourceRepresentation(rep); + + OC::ObservationIds ids; + ids.push_back(requests->getObservationInfo().obsId); + + OC::OCPlatform::notifyListOfObservers(m_messageHandle, ids, response); + } + } + + OCEntityHandlerResult entityHandler( + std::shared_ptr< OC::OCResourceRequest > request, requestType type) + { + if (!request) + { + return OC_EH_ERROR; + } + + std::cout << "Provider : Income request : " << request->getRequestHandlerFlag() << std::endl; + if ((request->getRequestHandlerFlag() & OC::RequestHandlerFlag::ObserverFlag)) + { + std::cout << "Provider : Income Observe : " << std::endl; + setObserver(request, type); + return OC_EH_OK; + } + + auto pResponse = getResponse(request, type); + if (pResponse == nullptr) + { + return OC_EH_ERROR; + } + + try + { + OC::OCPlatform::sendResponse(pResponse); + } + catch (std::exception & e) + { + return OC_EH_ERROR; + } + + return OC_EH_OK; + } + +public: + + void setAccepter(int accepter) + { + m_accepter = accepter; + } + + void notifyMessage() + { + std::cout << "Provider : notify~" << std::endl; + OC::OCPlatform::notifyAllObservers(m_messageHandle); + } + + void notifyMessage(const uint64_t & id, const std::string & title, const std::string & content) + { + setMessage(id, title, content); + notifyMessage(); + } + + void sendRead(const uint64_t & id) + { + std::string providerId = "123456789012345678901234567890123456"; + m_syncRep.setValue("MESSAGE_ID", id); + m_syncRep.setValue("STATE", (int)1); + m_syncRep.setValue("PROVIDER_ID", providerId); + OC::OCPlatform::notifyAllObservers(m_syncHandle); + } + void sendDismiss(const uint64_t & id) + { + std::string providerId = "123456789012345678901234567890123456"; + m_syncRep.setValue("MESSAGE_ID", id); + m_syncRep.setValue("STATE", (int)2); + m_syncRep.setValue("PROVIDER_ID", providerId); + OC::OCPlatform::notifyAllObservers(m_syncHandle); + } + + void setMessage(const uint64_t & id, const std::string & title, const std::string & content) + { + std::string providerId = "123456789012345678901234567890123456"; + m_messageRep.setValue("MESSAGE_ID", id); + m_messageRep.setValue("TITLE", title); + m_messageRep.setValue("CONTENTTEXT", content); + m_messageRep.setValue("PROVIDER_ID", providerId); + } + + void deleteNotificationResource() + { + OC::OCPlatform::unregisterResource(m_notificationHandle); + OC::OCPlatform::unregisterResource(m_messageHandle); + OC::OCPlatform::unregisterResource(m_syncHandle); + } + + void createNotificationResource() + { + createNotificationResource(m_notificationUri); + } + + void createNotificationResource(const std::string & uri) + { + if (m_notificationUri != uri) + { + m_notificationUri = uri; + } + + OC::OCPlatform::startPresence(30); + + std::string notificationUri = m_notificationUri; + std::string resourceTypeName = "oic.r.message.notification"; + std::string resourceInterface = OC::DEFAULT_INTERFACE; + + uint8_t resourceProperty = OC_OBSERVABLE; + std::string childUri = uri + m_messageUri; + try + { + OC::OCPlatform::registerResource( + m_messageHandle, childUri, + resourceTypeName, resourceInterface, + std::bind(& NSProviderSimulator::entityHandler, this, + std::placeholders::_1, requestType::NS_MESSAGE), + resourceProperty); + } + catch (std::exception & e) + { + std::cout << e.what() << std::endl; + } + + resourceTypeName = "oic.r.sync.notification"; + childUri = uri + m_syncUri; + try + { + OC::OCPlatform::registerResource( + m_syncHandle, childUri, + resourceTypeName, resourceInterface, + std::bind(& NSProviderSimulator::entityHandler, this, + std::placeholders::_1, requestType::NS_SYNC), + resourceProperty); + } + catch (std::exception & e) + { + std::cout << e.what() << std::endl; + } + + resourceProperty = OC_DISCOVERABLE; + resourceTypeName = "oic.r.notification"; + try + { + OC::OCPlatform::registerResource( + m_notificationHandle, notificationUri, + resourceTypeName, resourceInterface, + std::bind(& NSProviderSimulator::entityHandler, this, + std::placeholders::_1, requestType::NS_NOTIFICATION), + resourceProperty); + } + catch (std::exception & e) + { + std::cout << e.what() << std::endl; + } + } +}; + +#endif /* _NS_PROVIDER_SERVICE_SIMULATOR_H_ */ diff --git a/service/notification/cpp-wrapper/unittest/NSProviderServiceTest.cpp b/service/notification/cpp-wrapper/unittest/NSProviderServiceTest.cpp new file mode 100644 index 0000000..5e9fd0e --- /dev/null +++ b/service/notification/cpp-wrapper/unittest/NSProviderServiceTest.cpp @@ -0,0 +1,337 @@ +//****************************************************************** +// +// Copyright 2016 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 +#include +#include +#include +#include +#include + +#include "NSProviderService.h" +#include "NSConsumerServiceSimulator.h" +#include "NSUtils.h" +#include "NSSyncInfo.h" +#include "NSMessage.h" +#include "NSMediaContents.h" + +namespace +{ + std::atomic_bool g_isStartedStack(false); + + std::chrono::milliseconds g_waitForResponse(3000); + + std::condition_variable responseCon; + std::mutex mutexForCondition; + + NSConsumerSimulator g_consumerSimul; + OIC::Service::NSConsumer * g_consumer; +} + +class TestWithMock: public testing::Test +{ +public: + MockRepository mocks; + +protected: + virtual ~TestWithMock() noexcept(noexcept(std::declval().~Test())) {} + + virtual void TearDown() { + try + { + mocks.VerifyAll(); + } + catch (...) + { + mocks.reset(); + throw; + } + } +}; + +class NotificationProviderServiceTest : public TestWithMock +{ +public: + NotificationProviderServiceTest() = default; + ~NotificationProviderServiceTest() = default; + + static void ConsumerSubscribedCallbackEmpty(OIC::Service::NSConsumer *) + { + std::cout << __func__ << std::endl; + } + + static void MessageSynchronizedCallbackEmpty(OIC::Service::NSSyncInfo *) + { + std::cout << __func__ << std::endl; + } + + static void MessageCallbackFromConsumerEmpty( + const int &, const std::string &, const std::string &, const std::string &) + { + std::cout << __func__ << std::endl; + } + + static void SyncCallbackFromConsumerEmpty(int, int) + { + std::cout << __func__ << std::endl; + } + +protected: + + void SetUp() + { + TestWithMock::SetUp(); + + if (g_isStartedStack == false) + { + OC::PlatformConfig cfg + { + OC::ServiceType::InProc, + OC::ModeType::Both, + "0.0.0.0", + 0, + OC::QualityOfService::HighQos + }; + OC::OCPlatform::Configure(cfg); + + try + { + OC::OCPlatform::stopPresence(); + } + catch (...) + { + + } + + g_isStartedStack = true; + } + + } + + void TearDown() + { + TestWithMock::TearDown(); + } + +}; + +TEST_F(NotificationProviderServiceTest, StartProviderPositiveWithPolicyTrue) +{ + OIC::Service::NSProviderService::ProviderConfig config; + config.m_subscribeRequestCb = ConsumerSubscribedCallbackEmpty; + config.m_syncInfoCb = MessageSynchronizedCallbackEmpty; + config.policy = true; + + OIC::Service::NSResult ret = OIC::Service::NSProviderService::getInstance()->Start(config); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + + EXPECT_EQ(ret, OIC::Service::NSResult::OK); +} + +TEST_F(NotificationProviderServiceTest, StopProviderPositive) +{ + OIC::Service::NSResult ret = OIC::Service::NSProviderService::getInstance()->Stop(); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + + EXPECT_EQ(ret, OIC::Service::NSResult::OK); +} + +TEST_F(NotificationProviderServiceTest, StartProviderPositiveWithPolicyFalse) +{ + OIC::Service::NSProviderService::ProviderConfig config; + config.m_subscribeRequestCb = ConsumerSubscribedCallbackEmpty; + config.m_syncInfoCb = MessageSynchronizedCallbackEmpty; + config.policy = false; + + OIC::Service::NSResult ret = OIC::Service::NSProviderService::getInstance()->Start(config); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds(3000)); + g_consumerSimul.findProvider(); + + responseCon.wait_for(lock, std::chrono::milliseconds(3000)); + OIC::Service::NSProviderService::getInstance()->Stop(); + EXPECT_EQ(ret, OIC::Service::NSResult::OK); +} + +TEST_F(NotificationProviderServiceTest, ExpectCallbackWhenReceiveSubscribeRequestWithAccepterProvider) +{ + mocks.ExpectCallFunc(ConsumerSubscribedCallbackEmpty).Do( + []( OIC::Service::NSConsumer * consumer) + { + std::cout << "ConsumerSubscribedCallbackEmpty" << std::endl; + g_consumer = new OIC::Service::NSConsumer(consumer->getConsumerId()); + responseCon.notify_all(); + }); + + OIC::Service::NSProviderService::ProviderConfig config; + config.m_subscribeRequestCb = ConsumerSubscribedCallbackEmpty; + config.m_syncInfoCb = MessageSynchronizedCallbackEmpty; + config.policy = true; + + OIC::Service::NSProviderService::getInstance()->Start(config); + + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + g_consumerSimul.setCallback(MessageCallbackFromConsumerEmpty, + SyncCallbackFromConsumerEmpty); + g_consumerSimul.findProvider(); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds(1000)); +} + +TEST_F(NotificationProviderServiceTest, NeverCallNotifyOnConsumerByAcceptIsFalse) +{ + bool expectTrue = true; + int msgID; + + mocks.OnCallFunc(MessageCallbackFromConsumerEmpty).Do( + [& expectTrue, &msgID](const int &id, const std::string&, const std::string&, const std::string&) + { + if (id == msgID) + { + std::cout << "This function never call" << std::endl; + expectTrue = false; + } + }); + + g_consumer->acceptSubscription(g_consumer, false); + + OIC::Service::NSMessage * msg = OIC::Service::NSProviderService::getInstance()->CreateMessage(); + msgID = (int)msg->getMessageId(); + msg->setTitle(std::string("Title")); + msg->setContentText(std::string("ContentText")); + msg->setSourceName(std::string("OCF")); + + OIC::Service::NSProviderService::getInstance()->SendMessage(msg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds(1000)); + + EXPECT_EQ(expectTrue, true); +} + +TEST_F(NotificationProviderServiceTest, ExpectCallNotifyOnConsumerByAcceptIsTrue) +{ + int msgID; + + mocks.ExpectCallFunc(MessageCallbackFromConsumerEmpty).Do( + [&msgID](const int &id, const std::string&, const std::string&, const std::string&) + { + if (id == msgID) + { + std::cout << "ExpectCallNotifyOnConsumerByAcceptIsTrue" << std::endl; + responseCon.notify_all(); + } + }); + + g_consumer->acceptSubscription(g_consumer, true); + + OIC::Service::NSMessage * msg = OIC::Service::NSProviderService::getInstance()->CreateMessage(); + msgID = (int)msg->getMessageId(); + msg->setTitle(std::string("Title")); + msg->setContentText(std::string("ContentText")); + msg->setSourceName(std::string("OCF")); + + OIC::Service::NSProviderService::getInstance()->SendMessage(msg); + { + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); + } + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, g_waitForResponse); +} + +TEST_F(NotificationProviderServiceTest, ExpectCallbackSyncOnReadToConsumer) +{ + int id; + + mocks.ExpectCallFunc(SyncCallbackFromConsumerEmpty).Do( + [& id](int & type, int &syncId) + { + std::cout << "MessageSynchronizedCallbackEmpty" << std::endl; + if (syncId == id && + type == (int)OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ) + { + std::cout << "ExpectCallbackSyncOnReadFromConsumer" << std::endl; + responseCon.notify_all(); + } + }); + + OIC::Service::NSMessage * msg = OIC::Service::NSProviderService::getInstance()->CreateMessage(); + id = (int)msg->getMessageId(); + msg->setTitle(std::string("Title")); + msg->setContentText(std::string("ContentText")); + msg->setSourceName(std::string("OCF")); + + OIC::Service::NSProviderService::getInstance()->SendSyncInfo(msg->getMessageId(), OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ); + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds(5000)); +} + +TEST_F(NotificationProviderServiceTest, ExpectCallbackSyncOnReadFromConsumer) +{ + int type = (int)OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ; + int id; + mocks.ExpectCallFunc(MessageSynchronizedCallbackEmpty).Do( + [& id](OIC::Service::NSSyncInfo * sync) + { + std::cout << "MessageSynchronizedCallbackEmpty" << std::endl; + if ((int)sync->getMessageId() == id && sync->getState() == OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ) + { + std::cout << "ExpectCallbackSyncOnReadFromConsumer" << std::endl; + responseCon.notify_all(); + } + }); + + OIC::Service::NSMessage * msg = OIC::Service::NSProviderService::getInstance()->CreateMessage(); + id = (int)msg->getMessageId(); + msg->setTitle(std::string("Title")); + msg->setContentText(std::string("ContentText")); + msg->setSourceName(std::string("OCF")); + + g_consumerSimul.syncToProvider(type, id, msg->getProviderId()); + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds(5000)); +} + +TEST_F(NotificationProviderServiceTest, CancelObserves) +{ + bool ret = g_consumerSimul.cancelObserves(); + + std::unique_lock< std::mutex > lock{ mutexForCondition }; + responseCon.wait_for(lock, std::chrono::milliseconds(5000)); + + EXPECT_EQ(ret, true); +} diff --git a/service/notification/cpp-wrapper/unittest/SConscript b/service/notification/cpp-wrapper/unittest/SConscript new file mode 100644 index 0000000..0ff9943 --- /dev/null +++ b/service/notification/cpp-wrapper/unittest/SConscript @@ -0,0 +1,99 @@ +#****************************************************************** +# +# Copyright 2016 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. +# +#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +## +# Notification Unit Test build script +## + +Import('env') + +if env.get('RELEASE'): + env.AppendUnique(CCFLAGS = ['-Os']) + env.AppendUnique(CPPDEFINES = ['NDEBUG']) +else: + env.AppendUnique(CCFLAGS = ['-g']) + +if env.get('LOGGING'): + env.AppendUnique(CPPDEFINES = ['TB_LOG']) + +lib_env = env.Clone() +SConscript(env.get('SRC_DIR') + '/service/third_party_libs.scons', 'lib_env') + +###################################################################### +#unit test setting +###################################################################### +src_dir = lib_env.get('SRC_DIR') +gtest_dir = src_dir + '/extlibs/gtest/gtest-1.7.0' + +notification_wrapper_test_env = lib_env.Clone() +target_os = env.get('TARGET_OS') + +###################################################################### +# Build flags +###################################################################### +GTest = File(gtest_dir + '/lib/.libs/libgtest.a') +GTest_Main = File(gtest_dir + '/lib/.libs/libgtest_main.a') + +notification_wrapper_test_env.AppendUnique(LIBPATH = [lib_env.get('BUILD_DIR')]) +notification_wrapper_test_env.AppendUnique(LIBS = [ + 'connectivity_abstraction', 'oc', 'octbstack', 'oc_logger', 'coap', 'notification_provider', 'notification_consumer' , + GTest_Main, GTest]) + +if target_os not in ['windows', 'winrt']: + notification_wrapper_test_env.AppendUnique(CXXFLAGS = ['-O2', '-g', '-Wall', '-fmessage-length=0', '-std=c++0x']) + +notification_wrapper_test_env.AppendUnique(LINKFLAGS = ['-Wl,--no-as-needed']) + +notification_wrapper_test_env.AppendUnique(CXXFLAGS = ['-pthread']) +notification_wrapper_test_env.AppendUnique(LIBS = ['pthread']) + +notification_wrapper_test_env.PrependUnique(CPPPATH = [ src_dir + '/extlibs/hippomocks-master', gtest_dir + '/include']) +notification_wrapper_test_env.AppendUnique(CPPPATH = ['../provider/inc']) +notification_wrapper_test_env.AppendUnique(CPPPATH = ['../consumer/inc']) +notification_wrapper_test_env.AppendUnique(CPPPATH = ['../common']) +notification_wrapper_test_env.AppendUnique(CPPPATH = ['../../include']) +notification_wrapper_test_env.AppendUnique(CPPPATH = ['../../src/provider']) +notification_wrapper_test_env.AppendUnique(CPPPATH = ['../../src/consumer']) + +###################################################################### +# Build Test +###################################################################### + +notification_consumer_wrapper_test_env = notification_wrapper_test_env.Clone() +notification_consumer_wrapper_test_env.AppendUnique(LIBS = ['notification_consumer_wrapper']) + +notification_provider_wrapper_test_env = notification_wrapper_test_env.Clone() +notification_provider_wrapper_test_env.AppendUnique(LIBS = ['notification_provider_wrapper']) + +notification_consumer_wrapper_test_src = env.Glob('./NSConsumerServiceTest.cpp') +notification_consumer_wrapper_test = notification_consumer_wrapper_test_env.Program('notification_consumer_wrapper_test', notification_consumer_wrapper_test_src) +Alias("notification_consumer_wrapper_test", notification_consumer_wrapper_test) +env.AppendTarget('notification_consumer_wrapper_test') + +notification_provider_wrapper_test_src = env.Glob('./NSProviderServiceTest.cpp') +notification_provider_wrapper_test = notification_provider_wrapper_test_env.Program('notification_provider_wrapper_test', notification_provider_wrapper_test_src) +Alias("notification_provider_wrapper_test", notification_provider_wrapper_test) +env.AppendTarget('notification_provider_wrapper_test') + +if env.get('TEST') == '1': + if target_os == 'linux': + from tools.scons.RunTest import * + run_test(notification_consumer_wrapper_test_env, '', 'service/notification/cpp-wrapper/unittest/notification_consumer_wrapper_test') + run_test(notification_provider_wrapper_test_env, '', 'service/notification/cpp-wrapper/unittest/notification_provider_wrapper_test') \ No newline at end of file -- 2.7.4