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     private:
  45         std::mutex mutexForDiscovery;
  46
  47         std::string MULTICASTURI;
  48         std::string RESOURCEURI;
  49         std::string RESOURCETYPE;
  50         std::string RESOURCEINTERFACE;
  51         std::string ATTR_KEY;
  52         int ATTR_VALUE;
  53         std::unique_ptr<RCSDiscoveryManager::DiscoveryTask> discoveryTask;
  54
  55     public:
  56         ResourceContainerTestSimulator()
  57             : server(nullptr), remoteResource(nullptr),
  58               mutexForDiscovery(),
  59               MULTICASTURI("/oic/res"),
  60               RESOURCEURI("/a/TempHumSensor/Container"),
  61               RESOURCETYPE("resource.container"),
  62               RESOURCEINTERFACE("oic.if.baseline"),
  63               ATTR_KEY("Temperature"),
  64               ATTR_VALUE(0)
  65         { }
  66
  67         ~ResourceContainerTestSimulator()
  68         {
  69             if (remoteResource != nullptr && remoteResource->isCaching())
  70             {
  71                 remoteResource->stopCaching();
  72             }
  73             if (remoteResource != nullptr && remoteResource->isMonitoring())
  74             {
  75                 remoteResource->stopMonitoring();
  76             }
  77         }
  78
  79     private:
  80         void onDiscoveryResource_Impl(RCSRemoteResourceObject::Ptr resourceObject)
  81         {
  82             if (remoteResource != nullptr)
  83             {
  84                 return;
  85             }
  86
  87             if (RESOURCEURI.compare(resourceObject->getUri()) != 0)
  88             {
  89                 return;
  90             }
  91
  92             remoteResource = resourceObject;
  93             mutexForDiscovery.unlock();
  94         }
  95
  96         static void onDiscoveryResource(RCSRemoteResourceObject::Ptr resourceObject,
  97                                         std::weak_ptr<ResourceContainerTestSimulator> rPtr)
  98         {
  99             std::shared_ptr<ResourceContainerTestSimulator> ptr = rPtr.lock();
 100             if (ptr != nullptr)
 101             {
 102                 ptr->onDiscoveryResource_Impl(resourceObject);
 103             }
 104             else
 105             {
 106                 std::cout << "Aleady delete simulator\n";
 107             }
 108         }
 109         void waitForDiscovery()
 110         {
 111             std::chrono::milliseconds interval(100);
 112             while (true)
 113             {
 114                 if (mutexForDiscovery.try_lock())
 115                 {
 116                     mutexForDiscovery.unlock();
 117                     return;
 118                 }
 119                 std::this_thread::sleep_for(interval);
 120             }
 121         }
 122
 123     public:
 124         void defaultRunSimulator()
 125         {
 126             createResource();
 127             discoveryResource();
 128             waitForDiscovery();
 129         }
 130
 131         void createResource()
 132         {
 133             server = RCSResourceObject::Builder(RESOURCEURI, RESOURCETYPE, RESOURCEINTERFACE)
 134                      .setDiscoverable(true).setObservable(true).build();
 135             server->setAttribute(ATTR_KEY, ATTR_VALUE);
 136         }
 137
 138         void discoveryResource()
 139         {
 140             discoveryResource(RESOURCETYPE);
 141         }
 142
 143         void discoveryResource(std::string &resourceType)
 144         {
 145             try
 146             {
 147                 discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
 148                                     RCSAddress::multicast(), MULTICASTURI, resourceType,
 149                                     std::bind(onDiscoveryResource, std::placeholders::_1,
 150                                               std::weak_ptr<ResourceContainerTestSimulator>(shared_from_this())));
 151                 mutexForDiscovery.lock();
 152             }
 153             catch (std::exception &e)
 154             {
 155                 std::cout << "exception : " << e.what() << std::endl;
 156             }
 157         }
 158
 159         std::string getServerUri() const
 160         {
 161             return RESOURCEURI;
 162         }
 163
 164         RCSResourceObject::Ptr getResourceServer() const
 165         {
 166             return server;
 167         }
 168
 169         RCSRemoteResourceObject::Ptr getRemoteResource() const
 170         {
 171             return remoteResource;
 172         }
 173
 174         void ChangeAttributeValue()
 175         {
 176             std::chrono::milliseconds interval(100);
 177             if (server != nullptr)
 178                 server->setAttribute(ATTR_KEY, ATTR_VALUE + 10);
 179             std::this_thread::sleep_for(interval);
 180         }
 181
 182         void ChangeResourceState()
 183         {
 184             std::chrono::milliseconds interval(400);
 185             if (server != nullptr)
 186                 server = nullptr;
 187             std::this_thread::sleep_for(interval);
 188         }
 189
 190 };