+#******************************************************************
+#
+# 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')
# 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
--- /dev/null
+//******************************************************************
+//
+// 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 <iostream>
+
+#include "OCPlatform.h"
+#include "OCApi.h"
+
+class NSConsumerSimulator
+{
+private:
+ std::function<void(const int&, const std::string&, const std::string&,
+ const std::string&)> m_messageFunc;
+ std::function<void(const int&, const int&)> m_syncFunc;
+
+ std::shared_ptr<OC::OCResource> m_syncResource;
+ std::shared_ptr<OC::OCResource> 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<void(const int&, const std::string&,
+ const std::string&, const std::string&)> messageFunc,
+ const std::function<void(const int&, const int&)> & 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<OC::OCResource> 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<OC::OCResource> resource)
+ {
+ std::cout << __func__ << " " << rep.getHost() << " result : " << eCode << std::endl;
+
+ OC::QueryParamsMap map;
+ map.insert(std::pair<std::string,std::string>(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<std::string> 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<std::string>(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<OC::OCResource> )
+ {
+ 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<int>("MESSAGE_ID") != 1)
+ {
+ std::cout << "ID : " << rep.getValue<int>("ID") << std::endl;
+ std::cout << "TITLE : " << rep.getValueToString("TITLE") << std::endl;
+ std::cout << "CONTENT : " << rep.getValueToString("CONTENT") << std::endl;
+ m_messageFunc(int(rep.getValue<int>("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<int>("STATE")), int(rep.getValue<int>("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
--- /dev/null
+//******************************************************************
+//
+// 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 <gtest/gtest.h>
+#include <HippoMocks/hippomocks.h>
+#include <atomic>
+#include <functional>
+#include <condition_variable>
+#include <mutex>
+#include <chrono>
+
+#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>().~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();
+
+}
--- /dev/null
+//******************************************************************
+//
+// 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 <iostream>
+
+#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<OC::OCResourceResponse> getResponse(
+ std::shared_ptr< OC::OCResourceRequest > requests, requestType type)
+ {
+ auto response = std::make_shared<OC::OCResourceResponse>();
+ 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<int>("MESSAGE_ID", (int)1);
+ rep.setValue("PROVIDER_ID", providerId);
+
+ auto response = std::make_shared<OC::OCResourceResponse>();
+ 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<int>("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<int>("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<int>("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_ */
--- /dev/null
+//******************************************************************
+//
+// 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 <gtest/gtest.h>
+#include <HippoMocks/hippomocks.h>
+#include <atomic>
+#include <functional>
+#include <condition_variable>
+#include <mutex>
+#include <chrono>
+
+#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>().~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);
+}
--- /dev/null
+#******************************************************************
+#
+# 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
projects / platform / upstream / iotivity.git / commitdiff