service/things-manager/unittests/ThingsManagerTest.cpp

   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 "UnitTestHelper.h"
  22 #include "MaintenanceCollection.h"
  23 #include "ConfigurationCollection.h"
  24 #include "FactorySetCollection.h"
  25
  26 #include "timer.h"
  27 #include "ActionSet.h"
  28 #include "GroupManager.h"
  29 #include "ThingsConfiguration.h"
  30 #include "ThingsMaintenance.h"
  31 #include "ocstack.h"
  32 #include "OCPlatform.h"
  33 #include "OCApi.h"
  34
  35 #include <iostream>
  36 #include <functional>
  37 #include <pthread.h>
  38 #include <condition_variable>
  39
  40 #define SUCCESS_RESPONSE 0
  41 constexpr int DEFAULT_WAITING_TIME_IN_MILLIS = 3000;
  42
  43 using namespace OIC;
  44 using namespace OC;
  45 using namespace std;
  46 namespace PH = std::placeholders;
  47
  48 int result = 0;
  49 bool isSlowResponse = false;
  50
  51 std::string defaultDeviceName = "Legacy Device";
  52 std::string defaultLocation = "37.256616, 127.052806";
  53 std::string defaultLocationName = "Living Room";
  54 std::string defaultRegion = "Won";
  55 std::string defaultCurrency = "Seoul, Korea";
  56
  57 OCResourceHandle resourceHandle;
  58 OCResourceHandle foundResourceHandle;
  59
  60 std::shared_ptr< OCResource > g_resource;
  61 std::shared_ptr< OCResource > g_room_resource;
  62 std::shared_ptr< OCResource > g_light;
  63 std::shared_ptr< OCResource > configurationResource;
  64 std::vector< string > lights;
  65 std::vector< OCResourceHandle > resourceHandleVector;
  66
  67 GroupManager *groupMgr = new GroupManager();
  68 ConfigurationResource *myConfigurationResource;
  69 MaintenanceResource *myMaintenanceResource;
  70 FactorySetResource *myFactorySetResource;
  71
  72 std::condition_variable cv1;
  73 std::condition_variable cv2;
  74 std::condition_variable cv3;
  75 std::condition_variable cv4;
  76 std::condition_variable cv5;
  77
  78 bool prepareResponseForResource(std::shared_ptr< OCResourceRequest > request);
  79 OCStackResult sendResponseForResource(std::shared_ptr< OCResourceRequest > pRequest);
  80 OCEntityHandlerResult entityHandlerForResource(std::shared_ptr< OCResourceRequest > request);
  81 OCEntityHandlerResult entityHandlerBootstrap(std::shared_ptr< OCResourceRequest > request);
  82
  83 typedef std::function< void(OCRepresentation &) > putFunc;
  84 typedef std::function< OCRepresentation(void) > getFunc;
  85
  86 void *ChangeLightRepresentation(void *param);
  87 void *handleSlowResponse(void *param, std::shared_ptr< OCResourceRequest > pRequest);
  88
  89 /****** Light Resource [Required to gtestcases of GroupManager APIs]  ******/
  90
  91 class LightResource
  92 {
  93 public:
  94     std::string m_power;
  95     std::string testing;
  96     std::string m_lightUri;
  97     OCResourceHandle m_resourceHandle;
  98     OCRepresentation m_lightRep;
  99
 100 public:
 101     LightResource() :
 102             m_power("on"), m_lightUri("/a/light"), m_resourceHandle(0)
 103     {
 104         m_lightRep.setUri(m_lightUri);
 105         m_lightRep.setValue("power", m_power);
 106     }
 107
 108     void createResource()
 109     {
 110         std::string resourceURI = m_lightUri;
 111         std::string resourceTypeName = "core.light";
 112         std::string resourceInterface = DEFAULT_INTERFACE;
 113         EntityHandler cb = std::bind(&LightResource::entityHandler, this, PH::_1);
 114
 115         OCStackResult result = OCPlatform::registerResource(m_resourceHandle, resourceURI,
 116                 resourceTypeName, resourceInterface, cb, OC_DISCOVERABLE | OC_OBSERVABLE);
 117
 118         if (OC_STACK_OK != result)
 119         {
 120             printf("\nLightResource : OC_STACK_OK != result...");
 121         }
 122         else
 123         {
 124             cv2.notify_all();
 125             std::mutex blocker;
 126             std::condition_variable cv;
 127             std::unique_lock < std::mutex > lock(blocker);
 128             cv.wait(lock);
 129         }
 130     }
 131
 132     OCResourceHandle getHandle()
 133     {
 134         return m_resourceHandle;
 135     }
 136
 137     void put(OCRepresentation &rep)
 138     {
 139         try
 140         {
 141             std::string test;
 142             if (rep.getValue < std::string > ("power", test))
 143             {
 144                 cout << "\t\t\t\t" << "power: " << test << endl;
 145             }
 146             else
 147             {
 148                 cout << "\t\t\t\t" << "power not found in the representation" << endl;
 149             }
 150         }
 151         catch (exception &e)
 152         {
 153             cout << e.what() << endl;
 154         }
 155     }
 156
 157     OCRepresentation post(OCRepresentation &rep)
 158     {
 159         put(rep);
 160         return get();
 161     }
 162
 163     OCRepresentation get()
 164     {
 165         m_lightRep.setValue("power", m_power);
 166
 167         return m_lightRep;
 168     }
 169
 170     void addType(const std::string &type) const
 171     {
 172         OCStackResult result = OCPlatform::bindTypeToResource(m_resourceHandle, type);
 173         if (OC_STACK_OK != result)
 174         {
 175             cout << "Binding TypeName to Resource was unsuccessful\n";
 176         }
 177     }
 178
 179     void addInterface(const std::string &interface) const
 180     {
 181         OCStackResult result = OCPlatform::bindInterfaceToResource(m_resourceHandle, interface);
 182         if (OC_STACK_OK != result)
 183         {
 184             cout << "Binding TypeName to Resource was unsuccessful\n";
 185         }
 186     }
 187
 188 private:
 189     OCEntityHandlerResult entityHandler(std::shared_ptr< OCResourceRequest > request)
 190     {
 191         cout << "\tIn Server CPP entity handler:\n";
 192         OCEntityHandlerResult ehResult = OC_EH_ERROR;
 193         if (request)
 194         {
 195             std::string requestType = request->getRequestType();
 196             int requestFlag = request->getRequestHandlerFlag();
 197
 198             if (requestFlag & RequestHandlerFlag::RequestFlag)
 199             {
 200                 cout << "\t\trequestFlag : Request\n";
 201                 auto pResponse = std::make_shared< OC::OCResourceResponse >();
 202                 pResponse->setRequestHandle(request->getRequestHandle());
 203                 pResponse->setResourceHandle(request->getResourceHandle());
 204
 205                 if (requestType == "GET")
 206                 {
 207                     cout << "\t\t\trequestType : GET\n";
 208                     if (isSlowResponse)
 209                     {
 210                         static int startedThread = 0;
 211                         if (!startedThread)
 212                         {
 213                             std::thread t(handleSlowResponse, (void *) this, request);
 214                             startedThread = 1;
 215                             t.detach();
 216                         }
 217                         ehResult = OC_EH_SLOW;
 218                     }
 219                     else
 220                     {
 221                         pResponse->setErrorCode(200);
 222                         pResponse->setResponseResult(OC_EH_OK);
 223                         pResponse->setResourceRepresentation(get());
 224                         if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 225                         {
 226                             ehResult = OC_EH_OK;
 227                         }
 228                     }
 229                 }
 230                 else if (requestType == "PUT")
 231                 {
 232                     cout << "\t\t\trequestType : PUT\n";
 233                     OCRepresentation rep = request->getResourceRepresentation();
 234                     put(rep);
 235                     pResponse->setErrorCode(200);
 236                     pResponse->setResponseResult(OC_EH_OK);
 237                     pResponse->setResourceRepresentation(rep);
 238                     if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 239                     {
 240                         ehResult = OC_EH_OK;
 241                     }
 242                 }
 243                 else if (requestType == "POST")
 244                 {
 245                     cout << "\t\t\trequestType : POST\n";
 246
 247                     OCRepresentation rep = request->getResourceRepresentation();
 248                     OCRepresentation rep_post = post(rep);
 249
 250                     pResponse->setResourceRepresentation(rep_post);
 251                     pResponse->setErrorCode(200);
 252                     if (rep_post.hasAttribute("createduri"))
 253                     {
 254                         pResponse->setResponseResult(OC_EH_RESOURCE_CREATED);
 255                         pResponse->setNewResourceUri(
 256                                 rep_post.getValue < std::string > ("createduri"));
 257                     }
 258
 259                     if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 260                     {
 261                         ehResult = OC_EH_OK;
 262                     }
 263                 }
 264                 else if (requestType == "DELETE")
 265                 {
 266                 }
 267             }
 268         }
 269         else
 270         {
 271             std::cout << "Request invalid" << std::endl;
 272         }
 273         return ehResult;
 274     }
 275 };
 276
 277 void *handleSlowResponse(void *param, std::shared_ptr< OCResourceRequest > pRequest)
 278 {
 279     LightResource *lightPtr = (LightResource *) param;
 280     sleep(10);
 281
 282     auto pResponse = std::make_shared< OC::OCResourceResponse >();
 283     pResponse->setRequestHandle(pRequest->getRequestHandle());
 284     pResponse->setResourceHandle(pRequest->getResourceHandle());
 285     pResponse->setResourceRepresentation(lightPtr->get());
 286     pResponse->setErrorCode(200);
 287     pResponse->setResponseResult(OC_EH_OK);
 288
 289     isSlowResponse = false;
 290     OCPlatform::sendResponse(pResponse);
 291     return NULL;
 292 }
 293
 294 /****** Configuration Resource  ******/
 295
 296 void ConfigurationResource::createResources(ResourceEntityHandler callback)
 297 {
 298     using namespace OC::OCPlatform;
 299
 300     if (callback == NULL)
 301     {
 302         std::cout << "callback should be binded\t";
 303         return;
 304     }
 305
 306     OCStackResult result = registerResource(m_configurationHandle, m_configurationUri,
 307             m_configurationTypes[0], m_configurationInterfaces[0], callback,
 308             OC_DISCOVERABLE | OC_OBSERVABLE);
 309
 310     if (OC_STACK_OK != result)
 311     {
 312         std::cout << "Resource creation (configuration) was unsuccessful\n";
 313     }
 314     else
 315     {
 316         cv2.notify_all();
 317         std::mutex blocker;
 318         std::condition_variable cv;
 319         std::unique_lock < std::mutex > lock(blocker);
 320         cv.wait(lock);
 321     }
 322 }
 323
 324 void ConfigurationResource::setConfigurationRepresentation(OCRepresentation &rep)
 325 {
 326     string value;
 327     if (rep.getValue("n", value))
 328     {
 329         m_deviceName = value;
 330         std::cout << "\t\t\t\t" << "m_deviceName: " << m_deviceName << std::endl;
 331     }
 332
 333     if (rep.getValue("loc", value))
 334     {
 335         m_location = value;
 336         std::cout << "\t\t\t\t" << "m_location: " << m_location << std::endl;
 337     }
 338
 339     if (rep.getValue("locn", value))
 340     {
 341         m_locationName = value;
 342         std::cout << "\t\t\t\t" << "m_locationName: " << m_locationName << std::endl;
 343     }
 344
 345     if (rep.getValue("c", value))
 346     {
 347         m_currency = value;
 348         std::cout << "\t\t\t\t" << "m_currency: " << m_currency << std::endl;
 349     }
 350
 351     if (rep.getValue("r", value))
 352     {
 353         m_region = value;
 354         std::cout << "\t\t\t\t" << "m_region: " << m_region << std::endl;
 355     }
 356 }
 357
 358 OCRepresentation ConfigurationResource::getConfigurationRepresentation()
 359 {
 360     m_configurationRep.setValue("n", m_deviceName);
 361     m_configurationRep.setValue("loc", m_location);
 362     m_configurationRep.setValue("locn", m_locationName);
 363     m_configurationRep.setValue("c", m_currency);
 364     m_configurationRep.setValue("r", m_region);
 365
 366     return m_configurationRep;
 367 }
 368
 369 std::string ConfigurationResource::getUri()
 370 {
 371     return m_configurationUri;
 372 }
 373
 374 void ConfigurationResource::factoryReset()
 375 {
 376     m_deviceName = defaultDeviceName;
 377     m_location = defaultLocation;
 378     m_locationName = defaultLocationName;
 379     m_currency = defaultCurrency;
 380     m_region = defaultRegion;
 381 }
 382
 383 /****** FactorySet  Resource  ******/
 384
 385 FactorySetResource::FactorySetResource()
 386 {
 387     m_configurationUri = "/factoryset"; // URI of the resource
 388     m_configurationTypes.clear();
 389     m_configurationTypes.push_back("factoryset"); // resource type name.
 390     m_configurationRep.setUri(m_configurationUri);
 391     m_configurationRep.setResourceTypes(m_configurationTypes);
 392 }
 393
 394 FactorySetResource::~FactorySetResource()
 395 {
 396 }
 397
 398 void FactorySetResource::createResources(ResourceEntityHandler callback)
 399 {
 400     using namespace OC::OCPlatform;
 401
 402     if (callback == NULL)
 403     {
 404         std::cout << "callback should be binded\t";
 405         return;
 406     }
 407
 408     OCStackResult result = registerResource(m_configurationHandle, m_configurationUri,
 409             m_configurationTypes[0], m_configurationInterfaces[0], callback,
 410             OC_DISCOVERABLE | OC_OBSERVABLE);
 411
 412     if (OC_STACK_OK != result)
 413     {
 414         std::cout << "Resource creation (configuration) was unsuccessful\n";
 415     }
 416
 417     else
 418     {
 419         cv4.notify_all();
 420         std::mutex blocker;
 421         std::condition_variable cv;
 422         std::unique_lock < std::mutex > lock(blocker);
 423         cv.wait(lock);
 424     }
 425 }
 426
 427 void FactorySetResource::setFactorySetRepresentation(OCRepresentation &rep)
 428 {
 429     string value;
 430
 431     if (rep.getValue("n", value))
 432     {
 433         m_deviceName = value;
 434         std::cout << "\t\t\t\t" << "m_deviceName: " << m_deviceName << std::endl;
 435     }
 436
 437     if (rep.getValue("loc", value))
 438     {
 439         m_location = value;
 440         std::cout << "\t\t\t\t" << "m_location: " << m_location << std::endl;
 441     }
 442
 443     if (rep.getValue("locn", value))
 444     {
 445         m_locationName = value;
 446         std::cout << "\t\t\t\t" << "m_locationName: " << m_locationName << std::endl;
 447     }
 448
 449     if (rep.getValue("c", value))
 450     {
 451         m_currency = value;
 452         std::cout << "\t\t\t\t" << "m_currency: " << m_currency << std::endl;
 453     }
 454
 455     if (rep.getValue("r", value))
 456     {
 457         m_region = value;
 458         std::cout << "\t\t\t\t" << "m_region: " << m_region << std::endl;
 459     }
 460 }
 461
 462 OCRepresentation FactorySetResource::getFactorySetRepresentation()
 463 {
 464     m_configurationRep.setValue("n", m_deviceName);
 465     m_configurationRep.setValue("loc", m_location);
 466     m_configurationRep.setValue("locn", m_locationName);
 467     m_configurationRep.setValue("c", m_currency);
 468     m_configurationRep.setValue("r", m_region);
 469
 470     return m_configurationRep;
 471 }
 472
 473 std::string FactorySetResource::getUri()
 474 {
 475     return m_configurationUri;
 476 }
 477
 478 /****** Maintenance Resource ********/
 479
 480 void MaintenanceResource::createResources(ResourceEntityHandler callback)
 481 {
 482     using namespace OC::OCPlatform;
 483
 484     if (callback == NULL)
 485     {
 486         std::cout << "callback should be binded\t";
 487         return;
 488     }
 489
 490     OCStackResult result = registerResource(m_maintenanceHandle, m_maintenanceUri,
 491             m_maintenanceTypes[0], m_maintenanceInterfaces[0], callback,
 492             OC_DISCOVERABLE | OC_OBSERVABLE);
 493
 494     if (OC_STACK_OK != result)
 495     {
 496         std::cout << "Resource creation (maintenance) was unsuccessful\n";
 497     }
 498
 499     thread exec(
 500             std::function< void(int second) >(
 501                     std::bind(&MaintenanceResource::maintenanceMonitor, this,
 502                             std::placeholders::_1)), 10);
 503     exec.detach();
 504     cv3.notify_all();
 505     std::mutex blocker;
 506     std::condition_variable cv;
 507     std::unique_lock < std::mutex > lock(blocker);
 508     cv.wait(lock);
 509
 510     std::cout << "maintenance Resource is Created!\n";
 511 }
 512
 513 void MaintenanceResource::setMaintenanceRepresentation(OCRepresentation &rep)
 514 {
 515     string value;
 516
 517     if (rep.getValue("fr", value))
 518     {
 519         m_factoryReset = value;
 520         std::cout << "\t\t\t\t" << "m_factoryReset: " << m_factoryReset << std::endl;
 521     }
 522
 523     if (rep.getValue("rb", value))
 524     {
 525         m_reboot = value;
 526         std::cout << "\t\t\t\t" << "m_reboot: " << m_reboot << std::endl;
 527     }
 528
 529     if (rep.getValue("ssc", value))
 530     {
 531         m_startStatCollection = value;
 532         std::cout << "\t\t\t\t" << "m_startStatCollection: " << m_startStatCollection << std::endl;
 533     }
 534 }
 535
 536 OCRepresentation MaintenanceResource::getMaintenanceRepresentation()
 537 {
 538     m_maintenanceRep.setValue("fr", m_factoryReset);
 539     m_maintenanceRep.setValue("rb", m_reboot);
 540     m_maintenanceRep.setValue("ssc", m_startStatCollection);
 541
 542     return m_maintenanceRep;
 543 }
 544
 545 std::string MaintenanceResource::getUri()
 546 {
 547     return m_maintenanceUri;
 548 }
 549
 550 void MaintenanceResource::maintenanceMonitor(int second)
 551 {
 552     while (1)
 553     {
 554         sleep(second);
 555
 556         if (m_reboot == "true")
 557         {
 558             int res;
 559             std::cout << "Reboot will be soon..." << std::endl;
 560             m_reboot = defaultReboot;
 561             res = system("/usr/bin/sudo /etc/init.d/reboot");
 562
 563             std::cout << "return: " << res << std::endl;
 564
 565         }
 566         else if (m_factoryReset == "true")
 567         {
 568             std::cout << "Factory Reset will be soon..." << std::endl;
 569             m_factoryReset = defaultFactoryReset;
 570             factoryReset();
 571         }
 572     }
 573 }
 574
 575 getFunc getGetFunction(std::string uri)
 576 {
 577     getFunc res = NULL;
 578
 579     if (uri == myConfigurationResource->getUri())
 580     {
 581         res = std::bind(&ConfigurationResource::getConfigurationRepresentation,
 582                 myConfigurationResource);
 583     }
 584     else if (uri == myMaintenanceResource->getUri())
 585     {
 586         res = std::bind(&MaintenanceResource::getMaintenanceRepresentation, myMaintenanceResource);
 587     }
 588     return res;
 589 }
 590
 591 putFunc getPutFunction(std::string uri)
 592 {
 593     putFunc res = NULL;
 594
 595     if (uri == myConfigurationResource->getUri())
 596     {
 597         res = std::bind(&ConfigurationResource::setConfigurationRepresentation,
 598                 myConfigurationResource, std::placeholders::_1);
 599     }
 600     else if (uri == myMaintenanceResource->getUri())
 601     {
 602         res = std::bind(&MaintenanceResource::setMaintenanceRepresentation, myMaintenanceResource,
 603                 std::placeholders::_1);
 604     }
 605     return res;
 606 }
 607
 608 bool prepareResponseForResource(std::shared_ptr< OCResourceRequest > request)
 609 {
 610     std::cout << "\tIn Server CPP prepareResponseForResource:\n";
 611     bool result = false;
 612     if (request)
 613     {
 614         std::string requestType = request->getRequestType();
 615         int requestFlag = request->getRequestHandlerFlag();
 616
 617         if (requestFlag == RequestHandlerFlag::RequestFlag)
 618         {
 619             std::cout << "\t\trequestFlag : Request\n";
 620             if (requestType == "GET")
 621             {
 622                 std::cout << "\t\t\trequestType : GET\n";
 623                 result = true;
 624             }
 625             else if (requestType == "PUT")
 626             {
 627                 std::cout << "\t\t\trequestType : PUT\n";
 628                 putFunc putFunction;
 629                 OCRepresentation rep = request->getResourceRepresentation();
 630
 631                 putFunction = getPutFunction(request->getResourceUri());
 632                 putFunction(rep);
 633                 result = true;
 634             }
 635             else if (requestType == "POST")
 636             {
 637             }
 638             else if (requestType == "DELETE")
 639             {
 640             }
 641         }
 642         else if (requestFlag == RequestHandlerFlag::ObserverFlag)
 643         {
 644             std::cout << "\t\trequestFlag : Observer\n";
 645         }
 646     }
 647     else
 648     {
 649         std::cout << "Request invalid" << std::endl;
 650     }
 651
 652     return result;
 653 }
 654
 655 OCStackResult sendResponseForResource(std::shared_ptr< OCResourceRequest > pRequest)
 656 {
 657     auto pResponse = std::make_shared< OC::OCResourceResponse >();
 658     QueryParamsMap queryParamsMap = pRequest->getQueryParameters();
 659
 660     pResponse->setRequestHandle(pRequest->getRequestHandle());
 661     pResponse->setResourceHandle(pRequest->getResourceHandle());
 662
 663     getFunc getFunction;
 664     getFunction = getGetFunction(pRequest->getResourceUri());
 665
 666     OCRepresentation rep;
 667     rep = getFunction();
 668
 669     auto findRes = queryParamsMap.find("if");
 670
 671     if (findRes != queryParamsMap.end())
 672     {
 673         pResponse->setResourceRepresentation(rep, findRes->second);
 674     }
 675     else
 676     {
 677         pResponse->setResourceRepresentation(rep, DEFAULT_INTERFACE);
 678     }
 679
 680     pResponse->setErrorCode(200);
 681     pResponse->setResponseResult(OC_EH_OK);
 682
 683     return OCPlatform::sendResponse(pResponse);
 684 }
 685
 686 OCEntityHandlerResult entityHandlerForResource(std::shared_ptr< OCResourceRequest > request)
 687 {
 688     std::cout << "\tIn Server CPP (entityHandlerForResource) entity handler:\n";
 689     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 690
 691     QueryParamsMap test = request->getQueryParameters();
 692
 693     if (prepareResponseForResource(request))
 694     {
 695         if (OC_STACK_OK == sendResponseForResource(request))
 696         {
 697             ehResult = OC_EH_OK;
 698         }
 699         else
 700         {
 701             std::cout << "sendResponse failed." << std::endl;
 702         }
 703     }
 704     else
 705     {
 706         std::cout << "PrepareResponse failed." << std::endl;
 707     }
 708     return ehResult;
 709 }
 710
 711 /****** BootStrap Resource [Required for doBootstrap API of ThingsConfiguration class]  ******/
 712
 713 class BootstrapResource
 714 {
 715 public:
 716     std::string m_bootstrapUri;
 717     std::vector< std::string > m_bootstrapTypes;
 718     std::vector< std::string > m_bootstrapInterfaces;
 719     OCResourceHandle m_bootstrapHandle;
 720     OCRepresentation m_bootstrapRep;
 721
 722 public:
 723     BootstrapResource()
 724     {
 725         m_bootstrapUri = "/bootstrap";
 726         m_bootstrapTypes.push_back("bootstrap");
 727         m_bootstrapInterfaces.push_back(DEFAULT_INTERFACE);
 728         m_bootstrapRep.setUri(m_bootstrapUri);
 729         m_bootstrapRep.setResourceTypes(m_bootstrapTypes);
 730         m_bootstrapRep.setResourceInterfaces(m_bootstrapInterfaces);
 731         m_bootstrapHandle = NULL;
 732     }
 733     void createResources()
 734     {
 735         using namespace OC::OCPlatform;
 736         OCStackResult result = registerResource(m_bootstrapHandle, m_bootstrapUri,
 737                 m_bootstrapTypes[0], m_bootstrapInterfaces[0], entityHandlerBootstrap,
 738                 OC_DISCOVERABLE | OC_OBSERVABLE);
 739
 740         if (OC_STACK_OK != result)
 741         {
 742             cout << "Resource creation (room) was unsuccessful\n";
 743         }
 744
 745         cv5.notify_all();
 746         std::mutex blocker;
 747         std::condition_variable cv;
 748         std::unique_lock < std::mutex > lock(blocker);
 749         cv.wait(lock);
 750     }
 751
 752     void setBootstrapRepresentation(OCRepresentation& /*rep*/)
 753     {
 754     }
 755
 756     OCRepresentation getBootstrapRepresentation()
 757     {
 758         m_bootstrapRep.setValue < std::string > ("n", defaultDeviceName);
 759         m_bootstrapRep.setValue < std::string > ("loc", defaultLocation);
 760         m_bootstrapRep.setValue < std::string > ("locn", defaultLocationName);
 761         m_bootstrapRep.setValue < std::string > ("c", defaultCurrency);
 762         m_bootstrapRep.setValue < std::string > ("r", defaultRegion);
 763
 764         return m_bootstrapRep;
 765     }
 766 };
 767
 768 BootstrapResource myBootstrapResource;
 769
 770 bool prepareResponse(std::shared_ptr< OCResourceRequest > request)
 771 {
 772     cout << "\tIn Server CPP prepareResponse:\n";
 773     bool result = false;
 774     if (request)
 775     {
 776         std::string requestType = request->getRequestType();
 777         int requestFlag = request->getRequestHandlerFlag();
 778
 779         if (requestFlag == RequestHandlerFlag::RequestFlag)
 780         {
 781             cout << "\t\trequestFlag : Request\n";
 782             if (requestType == "GET")
 783             {
 784                 cout << "\t\t\trequestType : GET\n";
 785                 result = true;
 786             }
 787             else if (requestType == "PUT")
 788             {
 789                 cout << "\t\t\trequestType : PUT\n";
 790
 791                 OCRepresentation rep = request->getResourceRepresentation();
 792                 myBootstrapResource.setBootstrapRepresentation(rep);
 793                 result = true;
 794             }
 795             else if (requestType == "POST")
 796             {
 797             }
 798             else if (requestType == "DELETE")
 799             {
 800             }
 801         }
 802         else if (requestFlag == RequestHandlerFlag::ObserverFlag)
 803         {
 804             cout << "\t\trequestFlag : Observer\n";
 805         }
 806     }
 807     else
 808     {
 809         std::cout << "Request invalid" << std::endl;
 810     }
 811
 812     return result;
 813 }
 814
 815 OCStackResult sendResponse(std::shared_ptr< OCResourceRequest > pRequest)
 816 {
 817     auto pResponse = std::make_shared< OC::OCResourceResponse >();
 818     pResponse->setRequestHandle(pRequest->getRequestHandle());
 819     pResponse->setResourceHandle(pRequest->getResourceHandle());
 820     pResponse->setResourceRepresentation(myBootstrapResource.getBootstrapRepresentation());
 821     pResponse->setErrorCode(200);
 822     pResponse->setResponseResult(OC_EH_OK);
 823
 824     return OCPlatform::sendResponse(pResponse);
 825 }
 826
 827 OCEntityHandlerResult entityHandlerBootstrap(std::shared_ptr< OCResourceRequest > request)
 828 {
 829     cout << "\tIn Server CPP (entityHandlerBootstrap) entity handler:\n";
 830     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 831
 832     if (prepareResponse(request))
 833     {
 834         if (OC_STACK_OK == sendResponse(request))
 835         {
 836             ehResult = OC_EH_OK;
 837         }
 838         else
 839         {
 840             std::cout << "sendResponse failed." << std::endl;
 841         }
 842     }
 843     else
 844     {
 845         std::cout << "PrepareResponse failed." << std::endl;
 846     }
 847     return ehResult;
 848 }
 849
 850 /****** gtest class ******/
 851
 852 class ThingsManagerTest: public TestWithMock
 853 {
 854 public:
 855     void Proceed()
 856     {
 857         cond.notify_all();
 858     }
 859
 860     void Wait(int waitingTime = DEFAULT_WAITING_TIME_IN_MILLIS)
 861     {
 862         std::unique_lock < std::mutex > lock
 863         { mutex };
 864         cond.wait_for(lock, std::chrono::milliseconds
 865         { waitingTime });
 866     }
 867
 868 protected:
 869     void SetUp()
 870     {
 871         TestWithMock::SetUp();
 872     }
 873
 874     void TearDown()
 875     {
 876         TestWithMock::TearDown();
 877     }
 878
 879 private:
 880     std::condition_variable cond;
 881     std::mutex mutex;
 882 };
 883
 884 //Callbacks
 885 void onUpdate(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
 886         const int /*eCode*/)
 887 {
 888 }
 889
 890 void onGetBootstrapInformation(const HeaderOptions& /*headerOptions*/,
 891         const OCRepresentation& /*rep*/, const int /*eCode*/)
 892 {
 893 }
 894
 895 void onReboot(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
 896         const int /*eCode*/)
 897 {
 898 }
 899
 900 void onFactoryReset(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
 901         const int /*eCode*/)
 902 {
 903 }
 904
 905 void onGet(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
 906         const int /*eCode*/)
 907 {
 908 }
 909
 910 void onPut(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
 911         const int /*eCode*/)
 912 {
 913 }
 914
 915 void onPost(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
 916         const int /*eCode*/)
 917 {
 918 }
 919
 920 void foundResources(std::vector< std::shared_ptr< OC::OCResource > > listOfResource)
 921 {
 922     for (auto rsrc = listOfResource.begin(); rsrc != listOfResource.end(); ++rsrc)
 923     {
 924         if(((*rsrc)->connectivityType() & CT_ADAPTER_TCP) == CT_ADAPTER_TCP)
 925         {
 926             continue;
 927         }
 928
 929         std::string resourceURI = (*rsrc)->uri();
 930         std::string hostAddress = (*rsrc)->host();
 931
 932         if (resourceURI == "/a/light")
 933         {
 934             result = OCPlatform::registerResource(foundResourceHandle, (*rsrc));
 935             if (result == OC_STACK_OK)
 936             {
 937                 OCPlatform::bindResource(resourceHandle, foundResourceHandle);
 938                 resourceHandleVector.push_back(foundResourceHandle);
 939             }
 940             else
 941             {
 942                 cout << "\tresource Error!" << endl;
 943             }
 944             lights.push_back((hostAddress + resourceURI));
 945
 946             g_light = (*rsrc);
 947             cv2.notify_all();
 948         }
 949         else
 950         {
 951             configurationResource = (*rsrc);
 952             cv2.notify_all();
 953         }
 954     }
 955     cv2.notify_all();
 956 }
 957
 958 void foundGroupResource(std::shared_ptr< OCResource > resource)
 959 {
 960     if((resource->connectivityType() & CT_ADAPTER_TCP) == CT_ADAPTER_TCP)
 961     {
 962         return ;
 963     }
 964
 965     std::string resourceURI;
 966     resourceURI = resource->uri();
 967     if (resourceURI == "/core/a/collection")
 968     {
 969         g_resource = resource;
 970     }
 971     else
 972     {
 973         g_room_resource = resource;
 974     }
 975     cv1.notify_all();
 976 }
 977
 978 //This test case is to create the lightserver , BootstrapServer & configuration sever
 979 TEST_F(ThingsManagerTest, testCreateResources)
 980 {
 981     PlatformConfig cfg
 982     {   OC::ServiceType::InProc, OC::ModeType::Both, "0.0.0.0", 0, OC::QualityOfService::LowQos};
 983     OCPlatform::Configure(cfg);
 984
 985     LightResource myLight;
 986     std::thread t1(&LightResource::createResource, &myLight);
 987     t1.detach();
 988     std::mutex blocker1;
 989     std::unique_lock < std::mutex > lock1(blocker1);
 990     cv2.wait(lock1);
 991
 992     std::thread t2(&BootstrapResource::createResources, &myBootstrapResource);
 993     t2.detach();
 994     std::mutex blocker2;
 995     std::unique_lock < std::mutex > lock2(blocker2);
 996     cv5.wait(lock2);
 997
 998     myConfigurationResource = new ConfigurationResource();
 999     std::thread t3(&ConfigurationResource::createResources, myConfigurationResource,
1000             &entityHandlerForResource);
1001
1002     t3.detach();
1003     std::mutex blocker3;
1004     std::unique_lock < std::mutex > lock3(blocker3);
1005     cv2.wait(lock3);
1006
1007     myMaintenanceResource = new MaintenanceResource();
1008     std::thread t4(&MaintenanceResource::createResources, myMaintenanceResource,
1009             &entityHandlerForResource);
1010     t4.detach();
1011
1012     std::mutex blocker4;
1013     std::unique_lock < std::mutex > lock4(blocker4);
1014     cv3.wait(lock4);
1015
1016     myFactorySetResource = new FactorySetResource();
1017     std::thread t5(&FactorySetResource::createResources, myFactorySetResource,
1018             &entityHandlerForResource);
1019     t5.detach();
1020
1021     std::mutex blocker5;
1022     std::unique_lock < std::mutex > lock5(blocker5);
1023     cv4.wait(lock5);
1024
1025     myMaintenanceResource->factoryReset = std::function < void()
1026     > (std::bind(&ConfigurationResource::factoryReset,
1027                     myConfigurationResource));
1028 }
1029
1030 //Check findCandidateResources
1031 TEST_F(ThingsManagerTest, testFindCandidateResources)
1032 {
1033
1034     string resourceURI = "/core/a/collection";
1035     string resourceTypeName = "a.collection";
1036     string resourceInterface = BATCH_INTERFACE;
1037
1038     OCStackResult res = OCPlatform::registerResource(resourceHandle, resourceURI,
1039             resourceTypeName, resourceInterface, NULL, OC_DISCOVERABLE);
1040
1041     if ( res != OC_STACK_OK )
1042     {
1043         cout << "Resource registeration failed." << endl;
1044     }
1045
1046     OCPlatform::bindInterfaceToResource(resourceHandle, GROUP_INTERFACE);
1047     OCPlatform::bindInterfaceToResource(resourceHandle, DEFAULT_INTERFACE);
1048
1049     std::string query = OC_RSRVD_WELL_KNOWN_URI;
1050     query.append("?rt=");
1051     query.append(resourceTypeName);
1052
1053     OCPlatform::findResource("", query, CT_DEFAULT, &foundGroupResource);
1054
1055     std::mutex blocker1;
1056     std::unique_lock < std::mutex > lock1(blocker1);
1057     cv1.wait(lock1);
1058
1059     GroupManager *instance = new GroupManager();
1060     vector<string> types;
1061     types.push_back("core.light");
1062
1063     result = instance->findCandidateResources(types, &foundResources);
1064
1065     std::mutex blocker2;
1066     std::unique_lock < std::mutex > lock2(blocker2);
1067     cv2.wait(lock2);
1068 }
1069
1070 //Find Candidate Resource when no resources are specified
1071 TEST_F(ThingsManagerTest, testFindCandidateResourcesEmptyResourceType)
1072 {
1073     GroupManager *instance = new GroupManager();
1074     vector<string> types;
1075     result = instance->findCandidateResources(types, &foundResources);
1076     EXPECT_TRUE(result == OC_STACK_ERROR);
1077     delete instance;
1078 }
1079
1080 //Find Candidate Resource when Callback is null
1081 TEST_F(ThingsManagerTest, testFindCandidateResourcesNullCallback)
1082 {
1083     GroupManager *instance = new GroupManager();
1084     vector<string> types;
1085     types.push_back("core.light");
1086     result = instance->findCandidateResources(types, NULL);
1087     EXPECT_TRUE(result == OC_STACK_ERROR);
1088     delete instance;
1089 }
1090
1091 //test bind resource to group
1092 TEST_F(ThingsManagerTest, testBindResourceToGroup)
1093 {
1094     GroupManager *instance = new GroupManager();
1095     OCResourceHandle rHandle = NULL;
1096
1097     string resourceURI = "/core/room-large";
1098     string resourceTypeName = "core.room-large";
1099     string resourceInterface = BATCH_INTERFACE;
1100
1101     OCStackResult res = OCPlatform::registerResource(rHandle, resourceURI,
1102             resourceTypeName, resourceInterface, NULL, OC_DISCOVERABLE);
1103
1104     if ( res != OC_STACK_OK )
1105     {
1106         cout << "Resource registeration failed." << endl;
1107     }
1108
1109     OCPlatform::bindInterfaceToResource(rHandle, GROUP_INTERFACE);
1110     OCPlatform::bindInterfaceToResource(rHandle, DEFAULT_INTERFACE);
1111
1112     std::string query = OC_RSRVD_WELL_KNOWN_URI;
1113     query.append("?rt=");
1114     query.append(resourceTypeName);
1115
1116     OCPlatform::findResource("", query, CT_DEFAULT, &foundGroupResource);
1117
1118     std::mutex blocker1;
1119     std::unique_lock < std::mutex > lock1(blocker1);
1120     cv1.wait(lock1);
1121
1122     result = instance->bindResourceToGroup (resourceHandle, g_room_resource, rHandle);
1123
1124     EXPECT_TRUE(result == OC_STACK_OK);
1125     delete instance;
1126 }
1127
1128 //Add actionset
1129 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOff)
1130 {
1131     string actionsetDesc;
1132     ActionSet *allBulbOff = new ActionSet();
1133     allBulbOff->actionsetName = "AllBulbOff";
1134
1135     mocks.ExpectCallFunc(onPut).
1136     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1137             const int /*eCode*/) {   Proceed();});
1138
1139     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1140     {
1141         Action *action = new Action();
1142         action->target = (*iter);
1143
1144         Capability *capa = new Capability();
1145         capa->capability = "power";
1146         capa->status = "off";
1147
1148         action->listOfCapability.push_back(capa);
1149         allBulbOff->listOfAction.push_back(action);
1150     }
1151     if (g_resource)
1152     {
1153         result = groupMgr->addActionSet(g_resource, allBulbOff, &onPut);
1154         Wait();
1155         EXPECT_TRUE(result == OC_STACK_OK);
1156         result = 0;
1157     }
1158     delete allBulbOff;
1159 }
1160
1161 //Add actionset with NULL resource
1162 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOffResourceNull)
1163 {
1164     string actionsetDesc;
1165     ActionSet *allBulbOff = new ActionSet();
1166     allBulbOff->actionsetName = "AllBulbOff";
1167
1168     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1169     {
1170         Action *action = new Action();
1171         action->target = (*iter);
1172
1173         Capability *capa = new Capability();
1174         capa->capability = "power";
1175         capa->status = "off";
1176
1177         action->listOfCapability.push_back(capa);
1178         allBulbOff->listOfAction.push_back(action);
1179     }
1180
1181     result = groupMgr->addActionSet(NULL, allBulbOff, &onPut);
1182     Wait();
1183     EXPECT_TRUE(result == OC_STACK_ERROR);
1184     result = 0;
1185
1186     delete allBulbOff;
1187 }
1188
1189 //Add actionset with NULL ActionSet
1190 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOffActionsetNull)
1191 {
1192     if (g_resource)
1193     {
1194         result = groupMgr->addActionSet(g_resource, NULL, &onPut);
1195         Wait();
1196         EXPECT_TRUE(result == OC_STACK_ERROR);
1197         result = 0;
1198     }
1199 }
1200
1201 //Add actionset
1202 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOn)
1203 {
1204     string actionsetDesc;
1205     ActionSet *allBulbON = new ActionSet();
1206     allBulbON->actionsetName = "AllBulbOn";
1207
1208     mocks.ExpectCallFunc(onPut).
1209     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1210             const int /*eCode*/) {   Proceed();});
1211
1212     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1213     {
1214         Action *action = new Action();
1215         action->target = (*iter);
1216
1217         Capability *capa = new Capability();
1218         capa->capability = "power";
1219         capa->status = "on";
1220
1221         action->listOfCapability.push_back(capa);
1222         allBulbON->listOfAction.push_back(action);
1223     }
1224     if (g_resource)
1225     {
1226         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1227         Wait();
1228         EXPECT_TRUE(result == OC_STACK_OK);
1229         result = 0;
1230     }
1231     delete allBulbON;
1232 }
1233
1234 //Add actionset with NULL Resource
1235 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOnResourceNull)
1236 {
1237     string actionsetDesc;
1238     ActionSet *allBulbON = new ActionSet();
1239     allBulbON->actionsetName = "AllBulbOn";
1240
1241     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1242     {
1243         Action *action = new Action();
1244         action->target = (*iter);
1245
1246         Capability *capa = new Capability();
1247         capa->capability = "power";
1248         capa->status = "on";
1249
1250         action->listOfCapability.push_back(capa);
1251         allBulbON->listOfAction.push_back(action);
1252     }
1253
1254     result = groupMgr->addActionSet(NULL, allBulbON, onPut);
1255     Wait();
1256     EXPECT_TRUE(result == OC_STACK_ERROR);
1257     result = 0;
1258
1259     delete allBulbON;
1260 }
1261
1262 //Add actionset with NULL ActionSet
1263 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOnActionSetNull)
1264 {
1265     if (g_resource)
1266     {
1267         result = groupMgr->addActionSet(g_resource, NULL, onPut);
1268         Wait();
1269         EXPECT_TRUE(result == OC_STACK_ERROR);
1270         result = 0;
1271     }
1272 }
1273
1274 //Execute actionset
1275 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOn)
1276 {
1277     string actionsetDesc;
1278     ActionSet *allBulbON = new ActionSet();
1279     allBulbON->actionsetName = "AllBulbOn1";
1280
1281     mocks.ExpectCallFunc(onPut).
1282     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1283             const int /*eCode*/) {   Proceed();});
1284
1285     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1286     {
1287         Action *action = new Action();
1288         action->target = (*iter);
1289
1290         Capability *capa = new Capability();
1291         capa->capability = "power";
1292         capa->status = "on";
1293
1294         action->listOfCapability.push_back(capa);
1295         allBulbON->listOfAction.push_back(action);
1296     }
1297     if (g_resource)
1298     {
1299         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1300         Wait();
1301         EXPECT_TRUE(result == OC_STACK_OK);
1302         result = 0;
1303     }
1304
1305     mocks.ExpectCallFunc(onPost).
1306     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1307             const int /*eCode*/) {   Proceed();});
1308
1309     if (g_resource)
1310     {
1311         result = groupMgr->executeActionSet(g_resource, "AllBulbOn", &onPost);
1312         Wait();
1313         EXPECT_TRUE(result == OC_STACK_OK);
1314         result = 0;
1315     }
1316     delete allBulbON;
1317 }
1318
1319 //Execute actionset with NULL Resource
1320 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOnResourceNull)
1321 {
1322     result = groupMgr->executeActionSet(NULL, "AllBulbOn", &onPost);
1323     Wait();
1324     EXPECT_TRUE(result == OC_STACK_ERROR);
1325     result = 0;
1326 }
1327
1328 //Execute actionset
1329 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOff)
1330 {
1331     mocks.ExpectCallFunc(onPost).
1332     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1333             const int /*eCode*/) {   Proceed();});
1334
1335     if (g_resource)
1336     {
1337         result = groupMgr->executeActionSet(g_resource, "AllBulbOff", &onPost);
1338         Wait();
1339         EXPECT_TRUE(result == OC_STACK_OK);
1340         result = 0;
1341     }
1342 }
1343
1344 //Execute actionset with NULL resource
1345 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOffResourceNull)
1346 {
1347     result = groupMgr->executeActionSet(NULL, "AllBulbOff", &onPost);
1348     Wait();
1349     EXPECT_TRUE(result == OC_STACK_ERROR);
1350     result = 0;
1351 }
1352
1353 //Execute actionset with Delay
1354 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelay)
1355 {
1356     string actionsetDesc;
1357     ActionSet *allBulbON = new ActionSet();
1358     allBulbON->actionsetName = "AllBulbOnDelay";
1359     allBulbON->setDelay(1);
1360
1361     mocks.ExpectCallFunc(onPut).
1362     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1363             const int /*eCode*/) {   Proceed();});
1364
1365     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1366     {
1367         Action *action = new Action();
1368         action->target = (*iter);
1369
1370         Capability *capa = new Capability();
1371         capa->capability = "power";
1372         capa->status = "off";
1373
1374         action->listOfCapability.push_back(capa);
1375         allBulbON->listOfAction.push_back(action);
1376     }
1377     if (g_resource)
1378     {
1379         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1380         Wait();
1381     }
1382
1383     mocks.ExpectCallFunc(onPost).
1384     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1385             const int /*eCode*/) {   Proceed();});
1386
1387     if (g_resource)
1388     {
1389         result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", &onPost);
1390         Wait();
1391         EXPECT_TRUE(result == OC_STACK_OK);
1392         result = 0;
1393     }
1394
1395     delete allBulbON;
1396 }
1397
1398 //Execute actionset with Delay = 0
1399 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelayEqulasZero)
1400 {
1401     string actionsetDesc;
1402     ActionSet *allBulbON = new ActionSet();
1403     allBulbON->actionsetName = "AllBulbOnDelay";
1404
1405     mocks.ExpectCallFunc(onPut).
1406     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1407             const int /*eCode*/) {   Proceed();});
1408
1409     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1410     {
1411         Action *action = new Action();
1412         action->target = (*iter);
1413
1414         Capability *capa = new Capability();
1415         capa->capability = "power";
1416         capa->status = "off";
1417
1418         action->listOfCapability.push_back(capa);
1419         allBulbON->listOfAction.push_back(action);
1420     }
1421     if (g_resource)
1422     {
1423         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1424         Wait();
1425     }
1426
1427     if (g_resource)
1428     {
1429         result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", 0, &onPost);
1430         Wait();
1431         EXPECT_TRUE(result == OC_STACK_INVALID_PARAM);
1432         result = 0;
1433     }
1434
1435     delete allBulbON;
1436 }
1437
1438 //Execute actionset with invalid Delay
1439 TEST_F(ThingsManagerTest, testExcecuteActionSetWithInvalidDelay)
1440 {
1441     string actionsetDesc;
1442     ActionSet *allBulbON = new ActionSet();
1443     allBulbON->actionsetName = "AllBulbOnDelay";
1444
1445     mocks.ExpectCallFunc(onPut).
1446     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1447             const int /*eCode*/) {   Proceed();});
1448
1449     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1450     {
1451         Action *action = new Action();
1452         action->target = (*iter);
1453
1454         Capability *capa = new Capability();
1455         capa->capability = "power";
1456         capa->status = "off";
1457
1458         action->listOfCapability.push_back(capa);
1459         allBulbON->listOfAction.push_back(action);
1460     }
1461     if (g_resource)
1462     {
1463         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1464         Wait();
1465     }
1466
1467     if (g_resource)
1468     {
1469         result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", -10, &onPost);
1470         Wait();
1471         EXPECT_TRUE(result == OC_STACK_INVALID_PARAM);
1472         result = 0;
1473     }
1474
1475     delete allBulbON;
1476 }
1477
1478 //Execute actionset with delay on NULL Resource
1479 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelayWithResourceNull)
1480 {
1481     string actionsetDesc;
1482     ActionSet *allBulbON = new ActionSet();
1483     allBulbON->actionsetName = "AllBulbOnDelay";
1484     allBulbON->setDelay(5);
1485
1486     mocks.ExpectCallFunc(onPut).
1487     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1488             const int /*eCode*/) {   Proceed();});
1489
1490     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1491     {
1492         Action *action = new Action();
1493         action->target = (*iter);
1494
1495         Capability *capa = new Capability();
1496         capa->capability = "power";
1497         capa->status = "off";
1498
1499         action->listOfCapability.push_back(capa);
1500         allBulbON->listOfAction.push_back(action);
1501     }
1502     if (g_resource)
1503     {
1504         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1505         Wait();
1506     }
1507     result = groupMgr->executeActionSet(NULL, "AllBulbOnDelay", &onPost);
1508     EXPECT_TRUE(result == OC_STACK_ERROR);
1509     result = 0;
1510
1511     delete allBulbON;
1512 }
1513
1514 //Cancel ActionSet
1515 TEST_F(ThingsManagerTest, testCancelActionSet)
1516 {
1517     mocks.ExpectCallFunc(onPost).
1518     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1519             const int /*eCode*/) {   Proceed();});
1520
1521     if (g_resource)
1522     {
1523         result = groupMgr->cancelActionSet(g_resource, "AllBulbOff", &onPost);
1524         Wait();
1525         EXPECT_TRUE(result == OC_STACK_OK);
1526         result = 0;
1527     }
1528 }
1529
1530 //Cancel ActionSet on NULL Resource
1531 TEST_F(ThingsManagerTest, testCancelActionSetResourceNull)
1532 {
1533     result = groupMgr->cancelActionSet(NULL, "AllBulbOff", &onPost);
1534     Wait();
1535     EXPECT_TRUE(result == OC_STACK_ERROR);
1536     result = 0;
1537 }
1538
1539 //Delete ActionSet
1540 TEST_F(ThingsManagerTest, testDeleteActionSet)
1541 {
1542     mocks.ExpectCallFunc(onPut).
1543     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1544             const int /*eCode*/) {   Proceed();});
1545
1546     if (g_resource)
1547     {
1548         result = groupMgr->deleteActionSet(g_resource, "AllBulbOff", &onPut);
1549         Wait();
1550         EXPECT_TRUE(result == OC_STACK_OK);
1551         result = 0;
1552     }
1553 }
1554
1555 //Delete ActionSet on NULL Resource
1556 TEST_F(ThingsManagerTest, testDeleteActionSetResourceNull)
1557 {
1558     result = groupMgr->deleteActionSet(NULL, "AllBulbOff", &onPut);
1559     Wait();
1560     EXPECT_TRUE(result == OC_STACK_ERROR);
1561     result = 0;
1562 }
1563
1564 //Get ActionSet
1565 TEST_F(ThingsManagerTest, testGetActionSet)
1566 {
1567     mocks.ExpectCallFunc(onPost).
1568     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1569             const int /*eCode*/) {   Proceed();});
1570
1571     if (g_resource)
1572     {
1573         result = groupMgr->getActionSet(g_resource, "AllBulbOn", &onPost);
1574         Wait();
1575         EXPECT_TRUE(result == OC_STACK_OK);
1576         result = 0;
1577     }
1578 }
1579
1580 //Get ActionSet on NULL Resource
1581 TEST_F(ThingsManagerTest, testGetActionSetResourceNull)
1582 {
1583     result = groupMgr->getActionSet(NULL, "AllBulbOn", &onPost);
1584     Wait();
1585     EXPECT_TRUE(result == OC_STACK_ERROR);
1586     result = 0;
1587 }
1588
1589 //Get Configurations
1590 TEST_F(ThingsManagerTest, testGetConfigurations)
1591 {
1592     ConfigurationName name = "all";
1593
1594     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1595     std::vector< ConfigurationName > configurations;
1596
1597     configurations.push_back(name);
1598
1599     mocks.ExpectCallFunc(onGet).
1600     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1601             const int /*eCode*/) {   Proceed();});
1602
1603     vector<string> types;
1604     types.push_back("oic.wk.con");
1605
1606     result = groupMgr->findCandidateResources(types, &foundResources, 3);
1607
1608     std::mutex blocker;
1609     std::unique_lock < std::mutex > lock(blocker);
1610     cv2.wait(lock);
1611
1612     if (result == OC_STACK_OK)
1613     {
1614         result = g_thingsConf->getConfigurations(configurationResource, configurations, &onGet);
1615         Wait();
1616         EXPECT_TRUE(result == OC_STACK_OK);
1617         result = 0;
1618     }
1619 }
1620
1621 //Get Configurations with empty Configuration
1622 TEST_F(ThingsManagerTest, testGetConfigurationsEmptyConfiguration)
1623 {
1624     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1625     std::vector< ConfigurationName > configurations;
1626
1627     vector<string> types;
1628     types.push_back("oic.wk.con");
1629
1630     result = groupMgr->findCandidateResources(types, &foundResources, 3);
1631
1632     std::mutex blocker;
1633     std::unique_lock < std::mutex > lock(blocker);
1634     cv2.wait(lock);
1635
1636     if (result == OC_STACK_OK)
1637     {
1638         result = g_thingsConf->getConfigurations(configurationResource, configurations, &onGet);
1639         Wait();
1640         EXPECT_TRUE(result == OC_STACK_ERROR);
1641         result = 0;
1642     }
1643 }
1644
1645 //Get Configurations on NULL Resource
1646 TEST_F(ThingsManagerTest, testGetConfigurationsResourceNull)
1647 {
1648     ConfigurationName name = "all";
1649     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1650     std::vector< ConfigurationName > configurations;
1651
1652     configurations.push_back(name);
1653
1654     result = g_thingsConf->getConfigurations(NULL, configurations, &onGet);
1655     Wait();
1656     EXPECT_TRUE(result == OC_STACK_ERROR);
1657     result = 0;
1658 }
1659
1660 //Get all supported Configurations
1661 TEST_F(ThingsManagerTest, testGetallSupportedCOnfigurations)
1662 {
1663     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1664     string retVal = g_thingsConf->getListOfSupportedConfigurationUnits();
1665     EXPECT_FALSE(retVal.size() == 0);
1666 }
1667
1668 //DoBootstrap
1669 TEST_F(ThingsManagerTest, testDoBootstrap)
1670 {
1671     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1672
1673     mocks.ExpectCallFunc(onGetBootstrapInformation).
1674     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1675             const int /*eCode*/) {   Proceed();});
1676     result = g_thingsConf->doBootstrap(&onGetBootstrapInformation);
1677     Wait();
1678     EXPECT_TRUE(result == OC_STACK_OK);
1679     result = 0;
1680 }
1681
1682 //DoBootstrap with NULL callback
1683 TEST_F(ThingsManagerTest, testDoBootstrapCallBackNull)
1684 {
1685     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1686
1687     result = g_thingsConf->doBootstrap(NULL);
1688     Wait();
1689     EXPECT_TRUE(result == OC_STACK_ERROR);
1690     result = 0;
1691 }
1692
1693 //Update Configuration
1694 TEST_F(ThingsManagerTest, testUpdateConfiguration)
1695 {
1696     ConfigurationName name = "r";
1697     ConfigurationValue value = "INDIA";
1698
1699     std::map< ConfigurationName, ConfigurationValue > configurations;
1700     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1701     configurations.insert(std::make_pair(name, value));
1702
1703     mocks.ExpectCallFunc(onUpdate).
1704     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1705             const int /*eCode*/) {   Proceed();});
1706
1707     vector<string> types;
1708     types.push_back("oic.wk.con");
1709     result = groupMgr->findCandidateResources(types, &foundResources, 3);
1710
1711     std::mutex blocker2;
1712     std::unique_lock < std::mutex > lock2(blocker2);
1713     cv2.wait(lock2);
1714
1715     if (result == OC_STACK_OK)
1716     {
1717         result = g_thingsConf->updateConfigurations(configurationResource, configurations,
1718                                                     &onUpdate);
1719         Wait();
1720         EXPECT_TRUE(result == OC_STACK_OK);
1721         result = 0;
1722     }
1723 }
1724
1725 //Update Configuration with Empty Configuration
1726 TEST_F(ThingsManagerTest, testUpdateConfigurationEmptyConfiguration)
1727 {
1728     std::map< ConfigurationName, ConfigurationValue > configurations;
1729     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1730
1731     vector<string> types;
1732     types.push_back("oic.wk.con");
1733     result = groupMgr->findCandidateResources(types, &foundResources, 3);
1734
1735     std::mutex blocker2;
1736     std::unique_lock < std::mutex > lock2(blocker2);
1737     cv2.wait(lock2);
1738
1739     if (result == OC_STACK_OK)
1740     {
1741         result = g_thingsConf->updateConfigurations(configurationResource, configurations,
1742                                                     &onUpdate);
1743         Wait();
1744         EXPECT_TRUE(result == OC_STACK_ERROR);
1745         result = 0;
1746     }
1747 }
1748
1749 //Update Configuration on NULL Resource
1750 TEST_F(ThingsManagerTest, testUpdateConfigurationResourceNull)
1751 {
1752     ConfigurationName name = "r";
1753     ConfigurationValue value = "INDIA";
1754
1755     std::map< ConfigurationName, ConfigurationValue > configurations;
1756     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1757
1758     configurations.insert(std::make_pair(name, value));
1759
1760     result = g_thingsConf->updateConfigurations(NULL, configurations, &onUpdate);
1761     Wait();
1762     EXPECT_TRUE(result == OC_STACK_ERROR);
1763     result = 0;
1764 }
1765
1766 //Reboot
1767 TEST_F(ThingsManagerTest, testReboot)
1768 {
1769     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1770
1771     mocks.ExpectCallFunc(onReboot).
1772     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1773             const int /*eCode*/) {   Proceed();});
1774
1775     vector<string> types;
1776     types.push_back("oic.wk.mnt");
1777     result = groupMgr->findCandidateResources(types, &foundResources, 3);
1778
1779     std::mutex blocker;
1780     std::unique_lock < std::mutex > lock(blocker);
1781     cv2.wait(lock);
1782
1783     if (result == OC_STACK_OK)
1784     {
1785         result = g_thingsMnt->reboot(configurationResource, &onReboot);
1786         Wait();
1787         EXPECT_TRUE(result == OC_STACK_OK);
1788         result = 0;
1789     }
1790 }
1791
1792 //Reboot on NULL Resource
1793 TEST_F(ThingsManagerTest, testRebootResourceNull)
1794 {
1795     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1796
1797     result = g_thingsMnt->reboot(NULL, &onReboot);
1798     Wait();
1799     EXPECT_TRUE(result == OC_STACK_ERROR);
1800     result = 0;
1801 }
1802
1803 //Factory Reset
1804 TEST_F(ThingsManagerTest, testFactoryReset)
1805 {
1806     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1807
1808     mocks.ExpectCallFunc(onFactoryReset).
1809     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1810             const int /*eCode*/) {   Proceed();});
1811
1812     vector<string> types;
1813     types.push_back("oic.wk.mnt");
1814     result = groupMgr->findCandidateResources(types, &foundResources, 3);
1815
1816     std::mutex blocker;
1817     std::unique_lock < std::mutex > lock(blocker);
1818     cv2.wait(lock);
1819
1820     if (result == OC_STACK_OK)
1821     {
1822         result = g_thingsMnt->factoryReset(configurationResource, &onFactoryReset);
1823         Wait();
1824         EXPECT_TRUE(result == OC_STACK_OK);
1825         result = 0;
1826     }
1827 }
1828
1829 //Factory Reset on NULL Resource
1830 TEST_F(ThingsManagerTest, testFactoryResetResourceNull)
1831 {
1832     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1833
1834     result = g_thingsMnt->factoryReset(NULL, &onFactoryReset);
1835     Wait();
1836     EXPECT_TRUE(result == OC_STACK_ERROR);
1837     result = 0;
1838 }
1839