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         std::string resourceURI = (*rsrc)->uri();
 925         std::string hostAddress = (*rsrc)->host();
 926
 927         if (resourceURI == "/a/light")
 928         {
 929             result = OCPlatform::registerResource(foundResourceHandle, (*rsrc));
 930             if (result == OC_STACK_OK)
 931             {
 932                 OCPlatform::bindResource(resourceHandle, foundResourceHandle);
 933                 resourceHandleVector.push_back(foundResourceHandle);
 934             }
 935             else
 936             {
 937                 cout << "\tresource Error!" << endl;
 938             }
 939             lights.push_back((hostAddress + resourceURI));
 940
 941             g_light = (*rsrc);
 942         }
 943         else
 944         {
 945             configurationResource = (*rsrc);
 946         }
 947     }
 948     cv2.notify_all();
 949 }
 950
 951 void foundGroupResource(std::shared_ptr< OCResource > resource)
 952 {
 953     std::string resourceURI;
 954     resourceURI = resource->uri();
 955     if (resourceURI == "/core/a/collection")
 956     {
 957         g_resource = resource;
 958     }
 959     else
 960     {
 961         g_room_resource = resource;
 962     }
 963     cv1.notify_all();
 964 }
 965
 966 //This test case is to create the lightserver , BootstrapServer & configuration sever
 967 TEST_F(ThingsManagerTest, testCreateResources)
 968 {
 969     PlatformConfig cfg
 970     {   OC::ServiceType::InProc, OC::ModeType::Both, "0.0.0.0", 0, OC::QualityOfService::LowQos};
 971     OCPlatform::Configure(cfg);
 972
 973     LightResource myLight;
 974     std::thread t1(&LightResource::createResource, &myLight);
 975     t1.detach();
 976     std::mutex blocker1;
 977     std::unique_lock < std::mutex > lock1(blocker1);
 978     cv2.wait(lock1);
 979
 980     std::thread t2(&BootstrapResource::createResources, &myBootstrapResource);
 981     t2.detach();
 982     std::mutex blocker2;
 983     std::unique_lock < std::mutex > lock2(blocker2);
 984     cv5.wait(lock2);
 985
 986     myConfigurationResource = new ConfigurationResource();
 987     std::thread t3(&ConfigurationResource::createResources, myConfigurationResource,
 988             &entityHandlerForResource);
 989
 990     t3.detach();
 991     std::mutex blocker3;
 992     std::unique_lock < std::mutex > lock3(blocker3);
 993     cv2.wait(lock3);
 994
 995     myMaintenanceResource = new MaintenanceResource();
 996     std::thread t4(&MaintenanceResource::createResources, myMaintenanceResource,
 997             &entityHandlerForResource);
 998     t4.detach();
 999
1000     std::mutex blocker4;
1001     std::unique_lock < std::mutex > lock4(blocker4);
1002     cv3.wait(lock4);
1003
1004     myFactorySetResource = new FactorySetResource();
1005     std::thread t5(&FactorySetResource::createResources, myFactorySetResource,
1006             &entityHandlerForResource);
1007     t5.detach();
1008
1009     std::mutex blocker5;
1010     std::unique_lock < std::mutex > lock5(blocker5);
1011     cv4.wait(lock5);
1012
1013     myMaintenanceResource->factoryReset = std::function < void()
1014     > (std::bind(&ConfigurationResource::factoryReset,
1015                     myConfigurationResource));
1016 }
1017
1018 //Check findCandidateResources
1019 TEST_F(ThingsManagerTest, testFindCandidateResources)
1020 {
1021
1022     string resourceURI = "/core/a/collection";
1023     string resourceTypeName = "a.collection";
1024     string resourceInterface = BATCH_INTERFACE;
1025
1026     OCStackResult res = OCPlatform::registerResource(resourceHandle, resourceURI,
1027             resourceTypeName, resourceInterface, NULL, OC_DISCOVERABLE);
1028
1029     if ( res != OC_STACK_OK )
1030     {
1031         cout << "Resource registeration failed." << endl;
1032     }
1033
1034     OCPlatform::bindInterfaceToResource(resourceHandle, GROUP_INTERFACE);
1035     OCPlatform::bindInterfaceToResource(resourceHandle, DEFAULT_INTERFACE);
1036
1037     std::string query = OC_RSRVD_WELL_KNOWN_URI;
1038     query.append("?rt=");
1039     query.append(resourceTypeName);
1040
1041     OCPlatform::findResource("", query, CT_DEFAULT, &foundGroupResource);
1042
1043     std::mutex blocker1;
1044     std::unique_lock < std::mutex > lock1(blocker1);
1045     cv1.wait(lock1);
1046
1047     GroupManager *instance = new GroupManager();
1048     vector<string> types;
1049     types.push_back("core.light");
1050
1051     result = instance->findCandidateResources(types, &foundResources);
1052
1053     std::mutex blocker2;
1054     std::unique_lock < std::mutex > lock2(blocker2);
1055     cv2.wait(lock2);
1056 }
1057
1058 //Find Candidate Resource when no resources are specified
1059 TEST_F(ThingsManagerTest, testFindCandidateResourcesEmptyResourceType)
1060 {
1061     GroupManager *instance = new GroupManager();
1062     vector<string> types;
1063     result = instance->findCandidateResources(types, &foundResources);
1064     EXPECT_TRUE(result == OC_STACK_ERROR);
1065     delete instance;
1066 }
1067
1068 //Find Candidate Resource when Callback is null
1069 TEST_F(ThingsManagerTest, testFindCandidateResourcesNullCallback)
1070 {
1071     GroupManager *instance = new GroupManager();
1072     vector<string> types;
1073     types.push_back("core.light");
1074     result = instance->findCandidateResources(types, NULL);
1075     EXPECT_TRUE(result == OC_STACK_ERROR);
1076     delete instance;
1077 }
1078
1079 //test bind resource to group
1080 TEST_F(ThingsManagerTest, testBindResourceToGroup)
1081 {
1082     GroupManager *instance = new GroupManager();
1083     OCResourceHandle rHandle = NULL;
1084
1085     string resourceURI = "/core/room-large";
1086     string resourceTypeName = "core.room-large";
1087     string resourceInterface = BATCH_INTERFACE;
1088
1089     OCStackResult res = OCPlatform::registerResource(rHandle, resourceURI,
1090             resourceTypeName, resourceInterface, NULL, OC_DISCOVERABLE);
1091
1092     if ( res != OC_STACK_OK )
1093     {
1094         cout << "Resource registeration failed." << endl;
1095     }
1096
1097     OCPlatform::bindInterfaceToResource(rHandle, GROUP_INTERFACE);
1098     OCPlatform::bindInterfaceToResource(rHandle, DEFAULT_INTERFACE);
1099
1100     std::string query = OC_RSRVD_WELL_KNOWN_URI;
1101     query.append("?rt=");
1102     query.append(resourceTypeName);
1103
1104     OCPlatform::findResource("", query, CT_DEFAULT, &foundGroupResource);
1105
1106     std::mutex blocker1;
1107     std::unique_lock < std::mutex > lock1(blocker1);
1108     cv1.wait(lock1);
1109
1110     result = instance->bindResourceToGroup (resourceHandle, g_room_resource, rHandle);
1111
1112     EXPECT_TRUE(result == OC_STACK_OK);
1113     delete instance;
1114 }
1115
1116 //Add actionset
1117 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOff)
1118 {
1119     string actionsetDesc;
1120     ActionSet *allBulbOff = new ActionSet();
1121     allBulbOff->actionsetName = "AllBulbOff";
1122
1123     mocks.ExpectCallFunc(onPut).
1124     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1125             const int /*eCode*/) {   Proceed();});
1126
1127     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1128     {
1129         Action *action = new Action();
1130         action->target = (*iter);
1131
1132         Capability *capa = new Capability();
1133         capa->capability = "power";
1134         capa->status = "off";
1135
1136         action->listOfCapability.push_back(capa);
1137         allBulbOff->listOfAction.push_back(action);
1138     }
1139     if (g_resource)
1140     {
1141         result = groupMgr->addActionSet(g_resource, allBulbOff, &onPut);
1142         Wait();
1143         EXPECT_TRUE(result == OC_STACK_OK);
1144         result = 0;
1145     }
1146     delete allBulbOff;
1147 }
1148
1149 //Add actionset with NULL resource
1150 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOffResourceNull)
1151 {
1152     string actionsetDesc;
1153     ActionSet *allBulbOff = new ActionSet();
1154     allBulbOff->actionsetName = "AllBulbOff";
1155
1156     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1157     {
1158         Action *action = new Action();
1159         action->target = (*iter);
1160
1161         Capability *capa = new Capability();
1162         capa->capability = "power";
1163         capa->status = "off";
1164
1165         action->listOfCapability.push_back(capa);
1166         allBulbOff->listOfAction.push_back(action);
1167     }
1168
1169     result = groupMgr->addActionSet(NULL, allBulbOff, &onPut);
1170     Wait();
1171     EXPECT_TRUE(result == OC_STACK_ERROR);
1172     result = 0;
1173
1174     delete allBulbOff;
1175 }
1176
1177 //Add actionset with NULL ActionSet
1178 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOffActionsetNull)
1179 {
1180     if (g_resource)
1181     {
1182         result = groupMgr->addActionSet(g_resource, NULL, &onPut);
1183         Wait();
1184         EXPECT_TRUE(result == OC_STACK_ERROR);
1185         result = 0;
1186     }
1187 }
1188
1189 //Add actionset
1190 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOn)
1191 {
1192     string actionsetDesc;
1193     ActionSet *allBulbON = new ActionSet();
1194     allBulbON->actionsetName = "AllBulbOn";
1195
1196     mocks.ExpectCallFunc(onPut).
1197     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1198             const int /*eCode*/) {   Proceed();});
1199
1200     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1201     {
1202         Action *action = new Action();
1203         action->target = (*iter);
1204
1205         Capability *capa = new Capability();
1206         capa->capability = "power";
1207         capa->status = "on";
1208
1209         action->listOfCapability.push_back(capa);
1210         allBulbON->listOfAction.push_back(action);
1211     }
1212     if (g_resource)
1213     {
1214         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1215         Wait();
1216         EXPECT_TRUE(result == OC_STACK_OK);
1217         result = 0;
1218     }
1219     delete allBulbON;
1220 }
1221
1222 //Add actionset with NULL Resource
1223 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOnResourceNull)
1224 {
1225     string actionsetDesc;
1226     ActionSet *allBulbON = new ActionSet();
1227     allBulbON->actionsetName = "AllBulbOn";
1228
1229     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1230     {
1231         Action *action = new Action();
1232         action->target = (*iter);
1233
1234         Capability *capa = new Capability();
1235         capa->capability = "power";
1236         capa->status = "on";
1237
1238         action->listOfCapability.push_back(capa);
1239         allBulbON->listOfAction.push_back(action);
1240     }
1241
1242     result = groupMgr->addActionSet(NULL, allBulbON, onPut);
1243     Wait();
1244     EXPECT_TRUE(result == OC_STACK_ERROR);
1245     result = 0;
1246
1247     delete allBulbON;
1248 }
1249
1250 //Add actionset with NULL ActionSet
1251 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOnActionSetNull)
1252 {
1253     if (g_resource)
1254     {
1255         result = groupMgr->addActionSet(g_resource, NULL, onPut);
1256         Wait();
1257         EXPECT_TRUE(result == OC_STACK_ERROR);
1258         result = 0;
1259     }
1260 }
1261
1262 //Execute actionset
1263 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOn)
1264 {
1265     string actionsetDesc;
1266     ActionSet *allBulbON = new ActionSet();
1267     allBulbON->actionsetName = "AllBulbOn1";
1268
1269     mocks.ExpectCallFunc(onPut).
1270     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1271             const int /*eCode*/) {   Proceed();});
1272
1273     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1274     {
1275         Action *action = new Action();
1276         action->target = (*iter);
1277
1278         Capability *capa = new Capability();
1279         capa->capability = "power";
1280         capa->status = "on";
1281
1282         action->listOfCapability.push_back(capa);
1283         allBulbON->listOfAction.push_back(action);
1284     }
1285     if (g_resource)
1286     {
1287         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1288         Wait();
1289         EXPECT_TRUE(result == OC_STACK_OK);
1290         result = 0;
1291     }
1292
1293     mocks.ExpectCallFunc(onPost).
1294     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1295             const int /*eCode*/) {   Proceed();});
1296
1297     if (g_resource)
1298     {
1299         result = groupMgr->executeActionSet(g_resource, "AllBulbOn", &onPost);
1300         Wait();
1301         EXPECT_TRUE(result == OC_STACK_OK);
1302         result = 0;
1303     }
1304     delete allBulbON;
1305 }
1306
1307 //Execute actionset with NULL Resource
1308 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOnResourceNull)
1309 {
1310     result = groupMgr->executeActionSet(NULL, "AllBulbOn", &onPost);
1311     Wait();
1312     EXPECT_TRUE(result == OC_STACK_ERROR);
1313     result = 0;
1314 }
1315
1316 //Execute actionset
1317 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOff)
1318 {
1319     mocks.ExpectCallFunc(onPost).
1320     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1321             const int /*eCode*/) {   Proceed();});
1322
1323     if (g_resource)
1324     {
1325         result = groupMgr->executeActionSet(g_resource, "AllBulbOff", &onPost);
1326         Wait();
1327         EXPECT_TRUE(result == OC_STACK_OK);
1328         result = 0;
1329     }
1330 }
1331
1332 //Execute actionset with NULL resource
1333 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOffResourceNull)
1334 {
1335     result = groupMgr->executeActionSet(NULL, "AllBulbOff", &onPost);
1336     Wait();
1337     EXPECT_TRUE(result == OC_STACK_ERROR);
1338     result = 0;
1339 }
1340
1341 //Execute actionset with Delay
1342 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelay)
1343 {
1344     string actionsetDesc;
1345     ActionSet *allBulbON = new ActionSet();
1346     allBulbON->actionsetName = "AllBulbOnDelay";
1347     allBulbON->setDelay(1);
1348
1349     mocks.ExpectCallFunc(onPut).
1350     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1351             const int /*eCode*/) {   Proceed();});
1352
1353     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1354     {
1355         Action *action = new Action();
1356         action->target = (*iter);
1357
1358         Capability *capa = new Capability();
1359         capa->capability = "power";
1360         capa->status = "off";
1361
1362         action->listOfCapability.push_back(capa);
1363         allBulbON->listOfAction.push_back(action);
1364     }
1365     if (g_resource)
1366     {
1367         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1368         Wait();
1369     }
1370
1371     mocks.ExpectCallFunc(onPost).
1372     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1373             const int /*eCode*/) {   Proceed();});
1374
1375     if (g_resource)
1376     {
1377         result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", &onPost);
1378         Wait();
1379         EXPECT_TRUE(result == OC_STACK_OK);
1380         result = 0;
1381     }
1382
1383     delete allBulbON;
1384 }
1385
1386 //Execute actionset with Delay = 0
1387 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelayEqulasZero)
1388 {
1389     string actionsetDesc;
1390     ActionSet *allBulbON = new ActionSet();
1391     allBulbON->actionsetName = "AllBulbOnDelay";
1392
1393     mocks.ExpectCallFunc(onPut).
1394     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1395             const int /*eCode*/) {   Proceed();});
1396
1397     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1398     {
1399         Action *action = new Action();
1400         action->target = (*iter);
1401
1402         Capability *capa = new Capability();
1403         capa->capability = "power";
1404         capa->status = "off";
1405
1406         action->listOfCapability.push_back(capa);
1407         allBulbON->listOfAction.push_back(action);
1408     }
1409     if (g_resource)
1410     {
1411         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1412         Wait();
1413     }
1414
1415     if (g_resource)
1416     {
1417         result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", 0, &onPost);
1418         Wait();
1419         EXPECT_TRUE(result == OC_STACK_INVALID_PARAM);
1420         result = 0;
1421     }
1422
1423     delete allBulbON;
1424 }
1425
1426 //Execute actionset with invalid Delay
1427 TEST_F(ThingsManagerTest, testExcecuteActionSetWithInvalidDelay)
1428 {
1429     string actionsetDesc;
1430     ActionSet *allBulbON = new ActionSet();
1431     allBulbON->actionsetName = "AllBulbOnDelay";
1432
1433     mocks.ExpectCallFunc(onPut).
1434     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1435             const int /*eCode*/) {   Proceed();});
1436
1437     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1438     {
1439         Action *action = new Action();
1440         action->target = (*iter);
1441
1442         Capability *capa = new Capability();
1443         capa->capability = "power";
1444         capa->status = "off";
1445
1446         action->listOfCapability.push_back(capa);
1447         allBulbON->listOfAction.push_back(action);
1448     }
1449     if (g_resource)
1450     {
1451         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1452         Wait();
1453     }
1454
1455     if (g_resource)
1456     {
1457         result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", -10, &onPost);
1458         Wait();
1459         EXPECT_TRUE(result == OC_STACK_INVALID_PARAM);
1460         result = 0;
1461     }
1462
1463     delete allBulbON;
1464 }
1465
1466 //Execute actionset with delay on NULL Resource
1467 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelayWithResourceNull)
1468 {
1469     string actionsetDesc;
1470     ActionSet *allBulbON = new ActionSet();
1471     allBulbON->actionsetName = "AllBulbOnDelay";
1472     allBulbON->setDelay(5);
1473
1474     mocks.ExpectCallFunc(onPut).
1475     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1476             const int /*eCode*/) {   Proceed();});
1477
1478     for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1479     {
1480         Action *action = new Action();
1481         action->target = (*iter);
1482
1483         Capability *capa = new Capability();
1484         capa->capability = "power";
1485         capa->status = "off";
1486
1487         action->listOfCapability.push_back(capa);
1488         allBulbON->listOfAction.push_back(action);
1489     }
1490     if (g_resource)
1491     {
1492         result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1493         Wait();
1494     }
1495     result = groupMgr->executeActionSet(NULL, "AllBulbOnDelay", &onPost);
1496     EXPECT_TRUE(result == OC_STACK_ERROR);
1497     result = 0;
1498
1499     delete allBulbON;
1500 }
1501
1502 //Cancel ActionSet
1503 TEST_F(ThingsManagerTest, testCancelActionSet)
1504 {
1505     mocks.ExpectCallFunc(onPost).
1506     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1507             const int /*eCode*/) {   Proceed();});
1508
1509     if (g_resource)
1510     {
1511         result = groupMgr->cancelActionSet(g_resource, "AllBulbOff", &onPost);
1512         Wait();
1513         EXPECT_TRUE(result == OC_STACK_OK);
1514         result = 0;
1515     }
1516 }
1517
1518 //Cancel ActionSet on NULL Resource
1519 TEST_F(ThingsManagerTest, testCancelActionSetResourceNull)
1520 {
1521     result = groupMgr->cancelActionSet(NULL, "AllBulbOff", &onPost);
1522     Wait();
1523     EXPECT_TRUE(result == OC_STACK_ERROR);
1524     result = 0;
1525 }
1526
1527 //Delete ActionSet
1528 TEST_F(ThingsManagerTest, testDeleteActionSet)
1529 {
1530     mocks.ExpectCallFunc(onPut).
1531     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1532             const int /*eCode*/) {   Proceed();});
1533
1534     if (g_resource)
1535     {
1536         result = groupMgr->deleteActionSet(g_resource, "AllBulbOff", &onPut);
1537         Wait();
1538         EXPECT_TRUE(result == OC_STACK_OK);
1539         result = 0;
1540     }
1541 }
1542
1543 //Delete ActionSet on NULL Resource
1544 TEST_F(ThingsManagerTest, testDeleteActionSetResourceNull)
1545 {
1546     result = groupMgr->deleteActionSet(NULL, "AllBulbOff", &onPut);
1547     Wait();
1548     EXPECT_TRUE(result == OC_STACK_ERROR);
1549     result = 0;
1550 }
1551
1552 //Get ActionSet
1553 TEST_F(ThingsManagerTest, testGetActionSet)
1554 {
1555     mocks.ExpectCallFunc(onPost).
1556     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1557             const int /*eCode*/) {   Proceed();});
1558
1559     if (g_resource)
1560     {
1561         result = groupMgr->getActionSet(g_resource, "AllBulbOn", &onPost);
1562         Wait();
1563         EXPECT_TRUE(result == OC_STACK_OK);
1564         result = 0;
1565     }
1566 }
1567
1568 //Get ActionSet on NULL Resource
1569 TEST_F(ThingsManagerTest, testGetActionSetResourceNull)
1570 {
1571     result = groupMgr->getActionSet(NULL, "AllBulbOn", &onPost);
1572     Wait();
1573     EXPECT_TRUE(result == OC_STACK_ERROR);
1574     result = 0;
1575 }
1576
1577 //Get Configurations
1578 TEST_F(ThingsManagerTest, testGetConfigurations)
1579 {
1580     ConfigurationName name = "all";
1581
1582     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1583     std::vector< ConfigurationName > configurations;
1584
1585     configurations.push_back(name);
1586
1587     mocks.ExpectCallFunc(onGet).
1588     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1589             const int /*eCode*/) {   Proceed();});
1590
1591     vector<string> types;
1592     types.push_back("oic.wk.con");
1593
1594     result = groupMgr->findCandidateResources(types, &foundResources);
1595
1596     std::mutex blocker;
1597     std::unique_lock < std::mutex > lock(blocker);
1598     cv2.wait(lock);
1599
1600     if (result == OC_STACK_OK)
1601     {
1602         result = g_thingsConf->getConfigurations(configurationResource, configurations, &onGet);
1603         Wait();
1604         EXPECT_TRUE(result == OC_STACK_OK);
1605         result = 0;
1606     }
1607 }
1608
1609 //Get Configurations with empty Configuration
1610 TEST_F(ThingsManagerTest, testGetConfigurationsEmptyConfiguration)
1611 {
1612     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1613     std::vector< ConfigurationName > configurations;
1614
1615     vector<string> types;
1616     types.push_back("oic.wk.con");
1617
1618     result = groupMgr->findCandidateResources(types, &foundResources);
1619
1620     std::mutex blocker;
1621     std::unique_lock < std::mutex > lock(blocker);
1622     cv2.wait(lock);
1623
1624     if (result == OC_STACK_OK)
1625     {
1626         result = g_thingsConf->getConfigurations(configurationResource, configurations, &onGet);
1627         Wait();
1628         EXPECT_TRUE(result == OC_STACK_ERROR);
1629         result = 0;
1630     }
1631 }
1632
1633 //Get Configurations on NULL Resource
1634 TEST_F(ThingsManagerTest, testGetConfigurationsResourceNull)
1635 {
1636     ConfigurationName name = "all";
1637     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1638     std::vector< ConfigurationName > configurations;
1639
1640     configurations.push_back(name);
1641
1642     result = g_thingsConf->getConfigurations(NULL, configurations, &onGet);
1643     Wait();
1644     EXPECT_TRUE(result == OC_STACK_ERROR);
1645     result = 0;
1646 }
1647
1648 //Get all supported Configurations
1649 TEST_F(ThingsManagerTest, testGetallSupportedCOnfigurations)
1650 {
1651     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1652     string retVal = g_thingsConf->getListOfSupportedConfigurationUnits();
1653     EXPECT_FALSE(retVal.size() == 0);
1654 }
1655
1656 //DoBootstrap
1657 TEST_F(ThingsManagerTest, testDoBootstrap)
1658 {
1659     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1660
1661     mocks.ExpectCallFunc(onGetBootstrapInformation).
1662     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1663             const int /*eCode*/) {   Proceed();});
1664     result = g_thingsConf->doBootstrap(&onGetBootstrapInformation);
1665     Wait();
1666     EXPECT_TRUE(result == OC_STACK_OK);
1667     result = 0;
1668 }
1669
1670 //DoBootstrap with NULL callback
1671 TEST_F(ThingsManagerTest, testDoBootstrapCallBackNull)
1672 {
1673     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1674
1675     result = g_thingsConf->doBootstrap(NULL);
1676     Wait();
1677     EXPECT_TRUE(result == OC_STACK_ERROR);
1678     result = 0;
1679 }
1680
1681 //Update Configuration
1682 TEST_F(ThingsManagerTest, testUpdateConfiguration)
1683 {
1684     ConfigurationName name = "r";
1685     ConfigurationValue value = "INDIA";
1686
1687     std::map< ConfigurationName, ConfigurationValue > configurations;
1688     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1689     configurations.insert(std::make_pair(name, value));
1690
1691     mocks.ExpectCallFunc(onUpdate).
1692     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1693             const int /*eCode*/) {   Proceed();});
1694
1695     vector<string> types;
1696     types.push_back("oic.wk.con");
1697     result = groupMgr->findCandidateResources(types, &foundResources);
1698
1699     std::mutex blocker2;
1700     std::unique_lock < std::mutex > lock2(blocker2);
1701     cv2.wait(lock2);
1702
1703     if (result == OC_STACK_OK)
1704     {
1705         result = g_thingsConf->updateConfigurations(configurationResource, configurations,
1706                                                     &onUpdate);
1707         Wait();
1708         EXPECT_TRUE(result == OC_STACK_OK);
1709         result = 0;
1710     }
1711 }
1712
1713 //Update Configuration with Empty Configuration
1714 TEST_F(ThingsManagerTest, testUpdateConfigurationEmptyConfiguration)
1715 {
1716     std::map< ConfigurationName, ConfigurationValue > configurations;
1717     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1718
1719     vector<string> types;
1720     types.push_back("oic.wk.con");
1721     result = groupMgr->findCandidateResources(types, &foundResources);
1722
1723     std::mutex blocker2;
1724     std::unique_lock < std::mutex > lock2(blocker2);
1725     cv2.wait(lock2);
1726
1727     if (result == OC_STACK_OK)
1728     {
1729         result = g_thingsConf->updateConfigurations(configurationResource, configurations,
1730                                                     &onUpdate);
1731         Wait();
1732         EXPECT_TRUE(result == OC_STACK_ERROR);
1733         result = 0;
1734     }
1735 }
1736
1737 //Update Configuration on NULL Resource
1738 TEST_F(ThingsManagerTest, testUpdateConfigurationResourceNull)
1739 {
1740     ConfigurationName name = "r";
1741     ConfigurationValue value = "INDIA";
1742
1743     std::map< ConfigurationName, ConfigurationValue > configurations;
1744     ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1745
1746     configurations.insert(std::make_pair(name, value));
1747
1748     result = g_thingsConf->updateConfigurations(NULL, configurations, &onUpdate);
1749     Wait();
1750     EXPECT_TRUE(result == OC_STACK_ERROR);
1751     result = 0;
1752 }
1753
1754 //Reboot
1755 TEST_F(ThingsManagerTest, testReboot)
1756 {
1757     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1758
1759     mocks.ExpectCallFunc(onReboot).
1760     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1761             const int /*eCode*/) {   Proceed();});
1762
1763     vector<string> types;
1764     types.push_back("oic.wk.mnt");
1765     result = groupMgr->findCandidateResources(types, &foundResources);
1766
1767     std::mutex blocker;
1768     std::unique_lock < std::mutex > lock(blocker);
1769     cv2.wait(lock);
1770
1771     if (result == OC_STACK_OK)
1772     {
1773         result = g_thingsMnt->reboot(configurationResource, &onReboot);
1774         Wait();
1775         EXPECT_TRUE(result == OC_STACK_OK);
1776         result = 0;
1777     }
1778 }
1779
1780 //Reboot on NULL Resource
1781 TEST_F(ThingsManagerTest, testRebootResourceNull)
1782 {
1783     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1784
1785     result = g_thingsMnt->reboot(NULL, &onReboot);
1786     Wait();
1787     EXPECT_TRUE(result == OC_STACK_ERROR);
1788     result = 0;
1789 }
1790
1791 //Factory Reset
1792 TEST_F(ThingsManagerTest, testFactoryReset)
1793 {
1794     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1795
1796     mocks.ExpectCallFunc(onFactoryReset).
1797     Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1798             const int /*eCode*/) {   Proceed();});
1799
1800     vector<string> types;
1801     types.push_back("oic.wk.mnt");
1802     result = groupMgr->findCandidateResources(types, &foundResources);
1803
1804     std::mutex blocker;
1805     std::unique_lock < std::mutex > lock(blocker);
1806     cv2.wait(lock);
1807
1808     if (result == OC_STACK_OK)
1809     {
1810         result = g_thingsMnt->factoryReset(configurationResource, &onFactoryReset);
1811         Wait();
1812         EXPECT_TRUE(result == OC_STACK_OK);
1813         result = 0;
1814     }
1815 }
1816
1817 //Factory Reset on NULL Resource
1818 TEST_F(ThingsManagerTest, testFactoryResetResourceNull)
1819 {
1820     ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1821
1822     result = g_thingsMnt->factoryReset(NULL, &onFactoryReset);
1823     Wait();
1824     EXPECT_TRUE(result == OC_STACK_ERROR);
1825     result = 0;
1826 }
1827