service/resource-container/unittests/ResourceContainerTestSimulator.h

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <memory>
  22 #include <mutex>
  23 #include <atomic>
  24
  25 #include "UnitTestHelper.h"
  26
  27 #include "RCSDiscoveryManager.h"
  28 #include "RCSRemoteResourceObject.h"
  29 #include "RCSResourceAttributes.h"
  30 #include "RCSAddress.h"
  31
  32 using namespace testing;
  33 using namespace OIC::Service;
  34
  35 class ResourceContainerTestSimulator
  36     : public std::enable_shared_from_this<ResourceContainerTestSimulator>
  37 {
  38     public:
  39         typedef std::shared_ptr<ResourceContainerTestSimulator> Ptr;
  40
  41         RCSResourceObject::Ptr server;
  42         RCSRemoteResourceObject::Ptr remoteResource;
  43
  44         static constexpr int DEFAULT_WAITTIME = 3000;
  45
  46     private:
  47         std::mutex mutexForDiscovery;
  48
  49         std::string MULTICASTURI;
  50         std::string RESOURCEURI;
  51         std::string RESOURCETYPE;
  52         std::string RESOURCEINTERFACE;
  53         std::string ATTR_KEY;
  54         int ATTR_VALUE;
  55         std::unique_ptr<RCSDiscoveryManager::DiscoveryTask> discoveryTask;
  56
  57     public:
  58         ResourceContainerTestSimulator()
  59             : server(nullptr), remoteResource(nullptr),
  60               mutexForDiscovery(),
  61               MULTICASTURI("/oic/res"),
  62               RESOURCEURI("/a/TempHumSensor/Container"),
  63               RESOURCETYPE("resource.container"),
  64               RESOURCEINTERFACE("oic.if.baseline"),
  65               ATTR_KEY("TestResourceContainer"),
  66               ATTR_VALUE(0)
  67         {
  68         }
  69
  70         ~ResourceContainerTestSimulator()
  71         {
  72             try
  73             {
  74                 if (remoteResource != nullptr && remoteResource->isCaching())
  75                 {
  76                     remoteResource->stopCaching();
  77                 }
  78                 if (remoteResource != nullptr && remoteResource->isMonitoring())
  79                 {
  80                     remoteResource->stopMonitoring();
  81                 }
  82             }
  83             catch (RCSException &e)
  84             {
  85                 std::cout << "exception : " << e.what() << std::endl;
  86             }
  87         }
  88
  89     private:
  90         void onDiscoveryResource_Impl(RCSRemoteResourceObject::Ptr resourceObject)
  91         {
  92             if (remoteResource != nullptr)
  93             {
  94                 return;
  95             }
  96
  97             if (RESOURCEURI.compare(resourceObject->getUri()) != 0)
  98             {
  99                 return;
 100             }
 101
 102             remoteResource = resourceObject;
 103             mutexForDiscovery.unlock();
 104         }
 105
 106         static void onDiscoveryResource(RCSRemoteResourceObject::Ptr resourceObject,
 107                                         std::weak_ptr<ResourceContainerTestSimulator> rPtr)
 108         {
 109             std::shared_ptr<ResourceContainerTestSimulator> ptr = rPtr.lock();
 110             if (ptr != nullptr)
 111             {
 112                 ptr->onDiscoveryResource_Impl(resourceObject);
 113             }
 114             else
 115             {
 116                 std::cout << "Aleady delete simulator\n";
 117             }
 118         }
 119         void waitForDiscovery()
 120         {
 121             std::chrono::milliseconds interval(DEFAULT_WAITTIME);
 122             while (true)
 123             {
 124                 if (mutexForDiscovery.try_lock())
 125                 {
 126                     mutexForDiscovery.unlock();
 127                     return;
 128                 }
 129                 std::this_thread::sleep_for(interval);
 130             }
 131         }
 132
 133     public:
 134         void defaultRunSimulator()
 135         {
 136             createResource();
 137             discoveryResource();
 138             waitForDiscovery();
 139         }
 140
 141         void createResource()
 142         {
 143             server = RCSResourceObject::Builder(RESOURCEURI, RESOURCETYPE, RESOURCEINTERFACE)
 144                      .setDiscoverable(true).setObservable(true).build();
 145             server->setAttribute(ATTR_KEY, ATTR_VALUE);
 146         }
 147
 148         void discoveryResource()
 149         {
 150             discoveryResource(RESOURCETYPE);
 151         }
 152
 153         void discoveryResource(std::string &resourceType)
 154         {
 155             try
 156             {
 157                 discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
 158                                     RCSAddress::multicast(), MULTICASTURI, resourceType,
 159                                     std::bind(onDiscoveryResource, std::placeholders::_1,
 160                                               std::weak_ptr<ResourceContainerTestSimulator>(shared_from_this())));
 161                 mutexForDiscovery.lock();
 162             }
 163             catch (RCSInvalidParameterException &e)
 164             {
 165                 std::cout << "exception : " << e.what() << std::endl;
 166             }
 167         }
 168
 169         std::string getServerUri() const
 170         {
 171             return RESOURCEURI;
 172         }
 173
 174         RCSResourceObject::Ptr getResourceServer() const
 175         {
 176             return server;
 177         }
 178
 179         RCSRemoteResourceObject::Ptr getRemoteResource() const
 180         {
 181             return remoteResource;
 182         }
 183
 184         void ChangeAttributeValue()
 185         {
 186             std::chrono::milliseconds interval(DEFAULT_WAITTIME);
 187             if (server != nullptr)
 188             {
 189                 server->setAttribute(ATTR_KEY, ATTR_VALUE + 10);
 190             }
 191             std::this_thread::sleep_for(interval);
 192         }
 193
 194 };