1 //******************************************************************
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "UnitTestHelper.h"
22 #include "MaintenanceCollection.h"
23 #include "ConfigurationCollection.h"
24 #include "FactorySetCollection.h"
27 #include "ActionSet.h"
28 #include "GroupManager.h"
29 #include "ThingsConfiguration.h"
30 #include "ThingsMaintenance.h"
32 #include "OCPlatform.h"
38 #include <condition_variable>
40 #define SUCCESS_RESPONSE 0
41 constexpr int DEFAULT_WAITING_TIME_IN_MILLIS = 3000;
46 namespace PH = std::placeholders;
49 bool isSlowResponse = false;
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";
57 OCResourceHandle resourceHandle;
58 OCResourceHandle foundResourceHandle;
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;
67 GroupManager *groupMgr = new GroupManager();
68 ConfigurationResource *myConfigurationResource;
69 MaintenanceResource *myMaintenanceResource;
70 FactorySetResource *myFactorySetResource;
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;
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);
83 typedef std::function< void(OCRepresentation &) > putFunc;
84 typedef std::function< OCRepresentation(void) > getFunc;
86 void *ChangeLightRepresentation(void *param);
87 void *handleSlowResponse(void *param, std::shared_ptr< OCResourceRequest > pRequest);
89 /****** Light Resource [Required to gtestcases of GroupManager APIs] ******/
96 std::string m_lightUri;
97 OCResourceHandle m_resourceHandle;
98 OCRepresentation m_lightRep;
102 m_power("on"), m_lightUri("/a/light"), m_resourceHandle(0)
104 m_lightRep.setUri(m_lightUri);
105 m_lightRep.setValue("power", m_power);
108 void createResource()
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);
115 OCStackResult result = OCPlatform::registerResource(m_resourceHandle, resourceURI,
116 resourceTypeName, resourceInterface, cb, OC_DISCOVERABLE | OC_OBSERVABLE);
118 if (OC_STACK_OK != result)
120 printf("\nLightResource : OC_STACK_OK != result...");
126 std::condition_variable cv;
127 std::unique_lock < std::mutex > lock(blocker);
132 OCResourceHandle getHandle()
134 return m_resourceHandle;
137 void put(OCRepresentation &rep)
142 if (rep.getValue < std::string > ("power", test))
144 cout << "\t\t\t\t" << "power: " << test << endl;
148 cout << "\t\t\t\t" << "power not found in the representation" << endl;
153 cout << e.what() << endl;
157 OCRepresentation post(OCRepresentation &rep)
163 OCRepresentation get()
165 m_lightRep.setValue("power", m_power);
170 void addType(const std::string &type) const
172 OCStackResult result = OCPlatform::bindTypeToResource(m_resourceHandle, type);
173 if (OC_STACK_OK != result)
175 cout << "Binding TypeName to Resource was unsuccessful\n";
179 void addInterface(const std::string &interface) const
181 OCStackResult result = OCPlatform::bindInterfaceToResource(m_resourceHandle, interface);
182 if (OC_STACK_OK != result)
184 cout << "Binding TypeName to Resource was unsuccessful\n";
189 OCEntityHandlerResult entityHandler(std::shared_ptr< OCResourceRequest > request)
191 cout << "\tIn Server CPP entity handler:\n";
192 OCEntityHandlerResult ehResult = OC_EH_ERROR;
195 std::string requestType = request->getRequestType();
196 int requestFlag = request->getRequestHandlerFlag();
198 if (requestFlag & RequestHandlerFlag::RequestFlag)
200 cout << "\t\trequestFlag : Request\n";
201 auto pResponse = std::make_shared< OC::OCResourceResponse >();
202 pResponse->setRequestHandle(request->getRequestHandle());
203 pResponse->setResourceHandle(request->getResourceHandle());
205 if (requestType == "GET")
207 cout << "\t\t\trequestType : GET\n";
210 static int startedThread = 0;
213 std::thread t(handleSlowResponse, (void *) this, request);
217 ehResult = OC_EH_SLOW;
221 pResponse->setErrorCode(200);
222 pResponse->setResponseResult(OC_EH_OK);
223 pResponse->setResourceRepresentation(get());
224 if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
230 else if (requestType == "PUT")
232 cout << "\t\t\trequestType : PUT\n";
233 OCRepresentation rep = request->getResourceRepresentation();
235 pResponse->setErrorCode(200);
236 pResponse->setResponseResult(OC_EH_OK);
237 pResponse->setResourceRepresentation(rep);
238 if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
243 else if (requestType == "POST")
245 cout << "\t\t\trequestType : POST\n";
247 OCRepresentation rep = request->getResourceRepresentation();
248 OCRepresentation rep_post = post(rep);
250 pResponse->setResourceRepresentation(rep_post);
251 pResponse->setErrorCode(200);
252 if (rep_post.hasAttribute("createduri"))
254 pResponse->setResponseResult(OC_EH_RESOURCE_CREATED);
255 pResponse->setNewResourceUri(
256 rep_post.getValue < std::string > ("createduri"));
259 if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
264 else if (requestType == "DELETE")
271 std::cout << "Request invalid" << std::endl;
277 void *handleSlowResponse(void *param, std::shared_ptr< OCResourceRequest > pRequest)
279 LightResource *lightPtr = (LightResource *) param;
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);
289 isSlowResponse = false;
290 OCPlatform::sendResponse(pResponse);
294 /****** Configuration Resource ******/
296 void ConfigurationResource::createResources(ResourceEntityHandler callback)
298 using namespace OC::OCPlatform;
300 if (callback == NULL)
302 std::cout << "callback should be binded\t";
306 OCStackResult result = registerResource(m_configurationHandle, m_configurationUri,
307 m_configurationTypes[0], m_configurationInterfaces[0], callback,
308 OC_DISCOVERABLE | OC_OBSERVABLE);
310 if (OC_STACK_OK != result)
312 std::cout << "Resource creation (configuration) was unsuccessful\n";
318 std::condition_variable cv;
319 std::unique_lock < std::mutex > lock(blocker);
324 void ConfigurationResource::setConfigurationRepresentation(OCRepresentation &rep)
327 if (rep.getValue("n", value))
329 m_deviceName = value;
330 std::cout << "\t\t\t\t" << "m_deviceName: " << m_deviceName << std::endl;
333 if (rep.getValue("loc", value))
336 std::cout << "\t\t\t\t" << "m_location: " << m_location << std::endl;
339 if (rep.getValue("locn", value))
341 m_locationName = value;
342 std::cout << "\t\t\t\t" << "m_locationName: " << m_locationName << std::endl;
345 if (rep.getValue("c", value))
348 std::cout << "\t\t\t\t" << "m_currency: " << m_currency << std::endl;
351 if (rep.getValue("r", value))
354 std::cout << "\t\t\t\t" << "m_region: " << m_region << std::endl;
358 OCRepresentation ConfigurationResource::getConfigurationRepresentation()
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);
366 return m_configurationRep;
369 std::string ConfigurationResource::getUri()
371 return m_configurationUri;
374 void ConfigurationResource::factoryReset()
376 m_deviceName = defaultDeviceName;
377 m_location = defaultLocation;
378 m_locationName = defaultLocationName;
379 m_currency = defaultCurrency;
380 m_region = defaultRegion;
383 /****** FactorySet Resource ******/
385 FactorySetResource::FactorySetResource()
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);
394 FactorySetResource::~FactorySetResource()
398 void FactorySetResource::createResources(ResourceEntityHandler callback)
400 using namespace OC::OCPlatform;
402 if (callback == NULL)
404 std::cout << "callback should be binded\t";
408 OCStackResult result = registerResource(m_configurationHandle, m_configurationUri,
409 m_configurationTypes[0], m_configurationInterfaces[0], callback,
410 OC_DISCOVERABLE | OC_OBSERVABLE);
412 if (OC_STACK_OK != result)
414 std::cout << "Resource creation (configuration) was unsuccessful\n";
421 std::condition_variable cv;
422 std::unique_lock < std::mutex > lock(blocker);
427 void FactorySetResource::setFactorySetRepresentation(OCRepresentation &rep)
431 if (rep.getValue("n", value))
433 m_deviceName = value;
434 std::cout << "\t\t\t\t" << "m_deviceName: " << m_deviceName << std::endl;
437 if (rep.getValue("loc", value))
440 std::cout << "\t\t\t\t" << "m_location: " << m_location << std::endl;
443 if (rep.getValue("locn", value))
445 m_locationName = value;
446 std::cout << "\t\t\t\t" << "m_locationName: " << m_locationName << std::endl;
449 if (rep.getValue("c", value))
452 std::cout << "\t\t\t\t" << "m_currency: " << m_currency << std::endl;
455 if (rep.getValue("r", value))
458 std::cout << "\t\t\t\t" << "m_region: " << m_region << std::endl;
462 OCRepresentation FactorySetResource::getFactorySetRepresentation()
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);
470 return m_configurationRep;
473 std::string FactorySetResource::getUri()
475 return m_configurationUri;
478 /****** Maintenance Resource ********/
480 void MaintenanceResource::createResources(ResourceEntityHandler callback)
482 using namespace OC::OCPlatform;
484 if (callback == NULL)
486 std::cout << "callback should be binded\t";
490 OCStackResult result = registerResource(m_maintenanceHandle, m_maintenanceUri,
491 m_maintenanceTypes[0], m_maintenanceInterfaces[0], callback,
492 OC_DISCOVERABLE | OC_OBSERVABLE);
494 if (OC_STACK_OK != result)
496 std::cout << "Resource creation (maintenance) was unsuccessful\n";
500 std::function< void(int second) >(
501 std::bind(&MaintenanceResource::maintenanceMonitor, this,
502 std::placeholders::_1)), 10);
506 std::condition_variable cv;
507 std::unique_lock < std::mutex > lock(blocker);
510 std::cout << "maintenance Resource is Created!\n";
513 void MaintenanceResource::setMaintenanceRepresentation(OCRepresentation &rep)
517 if (rep.getValue("fr", value))
519 m_factoryReset = value;
520 std::cout << "\t\t\t\t" << "m_factoryReset: " << m_factoryReset << std::endl;
523 if (rep.getValue("rb", value))
526 std::cout << "\t\t\t\t" << "m_reboot: " << m_reboot << std::endl;
529 if (rep.getValue("ssc", value))
531 m_startStatCollection = value;
532 std::cout << "\t\t\t\t" << "m_startStatCollection: " << m_startStatCollection << std::endl;
536 OCRepresentation MaintenanceResource::getMaintenanceRepresentation()
538 m_maintenanceRep.setValue("fr", m_factoryReset);
539 m_maintenanceRep.setValue("rb", m_reboot);
540 m_maintenanceRep.setValue("ssc", m_startStatCollection);
542 return m_maintenanceRep;
545 std::string MaintenanceResource::getUri()
547 return m_maintenanceUri;
550 void MaintenanceResource::maintenanceMonitor(int second)
556 if (m_reboot == "true")
559 std::cout << "Reboot will be soon..." << std::endl;
560 m_reboot = defaultReboot;
561 res = system("/usr/bin/sudo /etc/init.d/reboot");
563 std::cout << "return: " << res << std::endl;
566 else if (m_factoryReset == "true")
568 std::cout << "Factory Reset will be soon..." << std::endl;
569 m_factoryReset = defaultFactoryReset;
575 getFunc getGetFunction(std::string uri)
579 if (uri == myConfigurationResource->getUri())
581 res = std::bind(&ConfigurationResource::getConfigurationRepresentation,
582 myConfigurationResource);
584 else if (uri == myMaintenanceResource->getUri())
586 res = std::bind(&MaintenanceResource::getMaintenanceRepresentation, myMaintenanceResource);
591 putFunc getPutFunction(std::string uri)
595 if (uri == myConfigurationResource->getUri())
597 res = std::bind(&ConfigurationResource::setConfigurationRepresentation,
598 myConfigurationResource, std::placeholders::_1);
600 else if (uri == myMaintenanceResource->getUri())
602 res = std::bind(&MaintenanceResource::setMaintenanceRepresentation, myMaintenanceResource,
603 std::placeholders::_1);
608 bool prepareResponseForResource(std::shared_ptr< OCResourceRequest > request)
610 std::cout << "\tIn Server CPP prepareResponseForResource:\n";
614 std::string requestType = request->getRequestType();
615 int requestFlag = request->getRequestHandlerFlag();
617 if (requestFlag == RequestHandlerFlag::RequestFlag)
619 std::cout << "\t\trequestFlag : Request\n";
620 if (requestType == "GET")
622 std::cout << "\t\t\trequestType : GET\n";
625 else if (requestType == "PUT")
627 std::cout << "\t\t\trequestType : PUT\n";
629 OCRepresentation rep = request->getResourceRepresentation();
631 putFunction = getPutFunction(request->getResourceUri());
635 else if (requestType == "POST")
638 else if (requestType == "DELETE")
642 else if (requestFlag == RequestHandlerFlag::ObserverFlag)
644 std::cout << "\t\trequestFlag : Observer\n";
649 std::cout << "Request invalid" << std::endl;
655 OCStackResult sendResponseForResource(std::shared_ptr< OCResourceRequest > pRequest)
657 auto pResponse = std::make_shared< OC::OCResourceResponse >();
658 QueryParamsMap queryParamsMap = pRequest->getQueryParameters();
660 pResponse->setRequestHandle(pRequest->getRequestHandle());
661 pResponse->setResourceHandle(pRequest->getResourceHandle());
664 getFunction = getGetFunction(pRequest->getResourceUri());
666 OCRepresentation rep;
669 auto findRes = queryParamsMap.find("if");
671 if (findRes != queryParamsMap.end())
673 pResponse->setResourceRepresentation(rep, findRes->second);
677 pResponse->setResourceRepresentation(rep, DEFAULT_INTERFACE);
680 pResponse->setErrorCode(200);
681 pResponse->setResponseResult(OC_EH_OK);
683 return OCPlatform::sendResponse(pResponse);
686 OCEntityHandlerResult entityHandlerForResource(std::shared_ptr< OCResourceRequest > request)
688 std::cout << "\tIn Server CPP (entityHandlerForResource) entity handler:\n";
689 OCEntityHandlerResult ehResult = OC_EH_ERROR;
691 QueryParamsMap test = request->getQueryParameters();
693 if (prepareResponseForResource(request))
695 if (OC_STACK_OK == sendResponseForResource(request))
701 std::cout << "sendResponse failed." << std::endl;
706 std::cout << "PrepareResponse failed." << std::endl;
711 /****** BootStrap Resource [Required for doBootstrap API of ThingsConfiguration class] ******/
713 class BootstrapResource
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;
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;
733 void createResources()
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);
740 if (OC_STACK_OK != result)
742 cout << "Resource creation (room) was unsuccessful\n";
747 std::condition_variable cv;
748 std::unique_lock < std::mutex > lock(blocker);
752 void setBootstrapRepresentation(OCRepresentation& /*rep*/)
756 OCRepresentation getBootstrapRepresentation()
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);
764 return m_bootstrapRep;
768 BootstrapResource myBootstrapResource;
770 bool prepareResponse(std::shared_ptr< OCResourceRequest > request)
772 cout << "\tIn Server CPP prepareResponse:\n";
776 std::string requestType = request->getRequestType();
777 int requestFlag = request->getRequestHandlerFlag();
779 if (requestFlag == RequestHandlerFlag::RequestFlag)
781 cout << "\t\trequestFlag : Request\n";
782 if (requestType == "GET")
784 cout << "\t\t\trequestType : GET\n";
787 else if (requestType == "PUT")
789 cout << "\t\t\trequestType : PUT\n";
791 OCRepresentation rep = request->getResourceRepresentation();
792 myBootstrapResource.setBootstrapRepresentation(rep);
795 else if (requestType == "POST")
798 else if (requestType == "DELETE")
802 else if (requestFlag == RequestHandlerFlag::ObserverFlag)
804 cout << "\t\trequestFlag : Observer\n";
809 std::cout << "Request invalid" << std::endl;
815 OCStackResult sendResponse(std::shared_ptr< OCResourceRequest > pRequest)
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);
824 return OCPlatform::sendResponse(pResponse);
827 OCEntityHandlerResult entityHandlerBootstrap(std::shared_ptr< OCResourceRequest > request)
829 cout << "\tIn Server CPP (entityHandlerBootstrap) entity handler:\n";
830 OCEntityHandlerResult ehResult = OC_EH_ERROR;
832 if (prepareResponse(request))
834 if (OC_STACK_OK == sendResponse(request))
840 std::cout << "sendResponse failed." << std::endl;
845 std::cout << "PrepareResponse failed." << std::endl;
850 /****** gtest class ******/
852 class ThingsManagerTest: public TestWithMock
860 void Wait(int waitingTime = DEFAULT_WAITING_TIME_IN_MILLIS)
862 std::unique_lock < std::mutex > lock
864 cond.wait_for(lock, std::chrono::milliseconds
871 TestWithMock::SetUp();
876 TestWithMock::TearDown();
880 std::condition_variable cond;
885 void onUpdate(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
890 void onGetBootstrapInformation(const HeaderOptions& /*headerOptions*/,
891 const OCRepresentation& /*rep*/, const int /*eCode*/)
895 void onReboot(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
900 void onFactoryReset(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
905 void onGet(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
910 void onPut(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
915 void onPost(const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
920 void foundResources(std::vector< std::shared_ptr< OC::OCResource > > listOfResource)
922 for (auto rsrc = listOfResource.begin(); rsrc != listOfResource.end(); ++rsrc)
924 std::string resourceURI = (*rsrc)->uri();
925 std::string hostAddress = (*rsrc)->host();
927 if (resourceURI == "/a/light")
929 result = OCPlatform::registerResource(foundResourceHandle, (*rsrc));
930 if (result == OC_STACK_OK)
932 OCPlatform::bindResource(resourceHandle, foundResourceHandle);
933 resourceHandleVector.push_back(foundResourceHandle);
937 cout << "\tresource Error!" << endl;
939 lights.push_back((hostAddress + resourceURI));
945 configurationResource = (*rsrc);
951 void foundGroupResource(std::shared_ptr< OCResource > resource)
953 std::string resourceURI;
954 resourceURI = resource->uri();
955 if (resourceURI == "/core/a/collection")
957 g_resource = resource;
961 g_room_resource = resource;
966 //This test case is to create the lightserver , BootstrapServer & configuration sever
967 TEST_F(ThingsManagerTest, testCreateResources)
970 { OC::ServiceType::InProc, OC::ModeType::Both, "0.0.0.0", 0, OC::QualityOfService::LowQos};
971 OCPlatform::Configure(cfg);
973 LightResource myLight;
974 std::thread t1(&LightResource::createResource, &myLight);
977 std::unique_lock < std::mutex > lock1(blocker1);
980 std::thread t2(&BootstrapResource::createResources, &myBootstrapResource);
983 std::unique_lock < std::mutex > lock2(blocker2);
986 myConfigurationResource = new ConfigurationResource();
987 std::thread t3(&ConfigurationResource::createResources, myConfigurationResource,
988 &entityHandlerForResource);
992 std::unique_lock < std::mutex > lock3(blocker3);
995 myMaintenanceResource = new MaintenanceResource();
996 std::thread t4(&MaintenanceResource::createResources, myMaintenanceResource,
997 &entityHandlerForResource);
1000 std::mutex blocker4;
1001 std::unique_lock < std::mutex > lock4(blocker4);
1004 myFactorySetResource = new FactorySetResource();
1005 std::thread t5(&FactorySetResource::createResources, myFactorySetResource,
1006 &entityHandlerForResource);
1009 std::mutex blocker5;
1010 std::unique_lock < std::mutex > lock5(blocker5);
1013 myMaintenanceResource->factoryReset = std::function < void()
1014 > (std::bind(&ConfigurationResource::factoryReset,
1015 myConfigurationResource));
1018 //Check findCandidateResources
1019 TEST_F(ThingsManagerTest, testFindCandidateResources)
1022 string resourceURI = "/core/a/collection";
1023 string resourceTypeName = "a.collection";
1024 string resourceInterface = BATCH_INTERFACE;
1026 OCStackResult res = OCPlatform::registerResource(resourceHandle, resourceURI,
1027 resourceTypeName, resourceInterface, NULL, OC_DISCOVERABLE);
1029 if ( res != OC_STACK_OK )
1031 cout << "Resource registeration failed." << endl;
1034 OCPlatform::bindInterfaceToResource(resourceHandle, GROUP_INTERFACE);
1035 OCPlatform::bindInterfaceToResource(resourceHandle, DEFAULT_INTERFACE);
1037 std::string query = OC_RSRVD_WELL_KNOWN_URI;
1038 query.append("?rt=");
1039 query.append(resourceTypeName);
1041 OCPlatform::findResource("", query, CT_DEFAULT, &foundGroupResource);
1043 std::mutex blocker1;
1044 std::unique_lock < std::mutex > lock1(blocker1);
1047 GroupManager *instance = new GroupManager();
1048 vector<string> types;
1049 types.push_back("core.light");
1051 result = instance->findCandidateResources(types, &foundResources);
1053 std::mutex blocker2;
1054 std::unique_lock < std::mutex > lock2(blocker2);
1058 //Find Candidate Resource when no resources are specified
1059 TEST_F(ThingsManagerTest, testFindCandidateResourcesEmptyResourceType)
1061 GroupManager *instance = new GroupManager();
1062 vector<string> types;
1063 result = instance->findCandidateResources(types, &foundResources);
1064 EXPECT_TRUE(result == OC_STACK_ERROR);
1068 //Find Candidate Resource when Callback is null
1069 TEST_F(ThingsManagerTest, testFindCandidateResourcesNullCallback)
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);
1079 //test bind resource to group
1080 TEST_F(ThingsManagerTest, testBindResourceToGroup)
1082 GroupManager *instance = new GroupManager();
1083 OCResourceHandle rHandle = NULL;
1085 string resourceURI = "/core/room-large";
1086 string resourceTypeName = "core.room-large";
1087 string resourceInterface = BATCH_INTERFACE;
1089 OCStackResult res = OCPlatform::registerResource(rHandle, resourceURI,
1090 resourceTypeName, resourceInterface, NULL, OC_DISCOVERABLE);
1092 if ( res != OC_STACK_OK )
1094 cout << "Resource registeration failed." << endl;
1097 OCPlatform::bindInterfaceToResource(rHandle, GROUP_INTERFACE);
1098 OCPlatform::bindInterfaceToResource(rHandle, DEFAULT_INTERFACE);
1100 std::string query = OC_RSRVD_WELL_KNOWN_URI;
1101 query.append("?rt=");
1102 query.append(resourceTypeName);
1104 OCPlatform::findResource("", query, CT_DEFAULT, &foundGroupResource);
1106 std::mutex blocker1;
1107 std::unique_lock < std::mutex > lock1(blocker1);
1110 result = instance->bindResourceToGroup (resourceHandle, g_room_resource, rHandle);
1112 EXPECT_TRUE(result == OC_STACK_OK);
1117 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOff)
1119 string actionsetDesc;
1120 ActionSet *allBulbOff = new ActionSet();
1121 allBulbOff->actionsetName = "AllBulbOff";
1123 mocks.ExpectCallFunc(onPut).
1124 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1125 const int /*eCode*/) { Proceed();});
1127 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1129 Action *action = new Action();
1130 action->target = (*iter);
1132 Capability *capa = new Capability();
1133 capa->capability = "power";
1134 capa->status = "off";
1136 action->listOfCapability.push_back(capa);
1137 allBulbOff->listOfAction.push_back(action);
1141 result = groupMgr->addActionSet(g_resource, allBulbOff, &onPut);
1143 EXPECT_TRUE(result == OC_STACK_OK);
1149 //Add actionset with NULL resource
1150 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOffResourceNull)
1152 string actionsetDesc;
1153 ActionSet *allBulbOff = new ActionSet();
1154 allBulbOff->actionsetName = "AllBulbOff";
1156 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1158 Action *action = new Action();
1159 action->target = (*iter);
1161 Capability *capa = new Capability();
1162 capa->capability = "power";
1163 capa->status = "off";
1165 action->listOfCapability.push_back(capa);
1166 allBulbOff->listOfAction.push_back(action);
1169 result = groupMgr->addActionSet(NULL, allBulbOff, &onPut);
1171 EXPECT_TRUE(result == OC_STACK_ERROR);
1177 //Add actionset with NULL ActionSet
1178 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOffActionsetNull)
1182 result = groupMgr->addActionSet(g_resource, NULL, &onPut);
1184 EXPECT_TRUE(result == OC_STACK_ERROR);
1190 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOn)
1192 string actionsetDesc;
1193 ActionSet *allBulbON = new ActionSet();
1194 allBulbON->actionsetName = "AllBulbOn";
1196 mocks.ExpectCallFunc(onPut).
1197 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1198 const int /*eCode*/) { Proceed();});
1200 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1202 Action *action = new Action();
1203 action->target = (*iter);
1205 Capability *capa = new Capability();
1206 capa->capability = "power";
1207 capa->status = "on";
1209 action->listOfCapability.push_back(capa);
1210 allBulbON->listOfAction.push_back(action);
1214 result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1216 EXPECT_TRUE(result == OC_STACK_OK);
1222 //Add actionset with NULL Resource
1223 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOnResourceNull)
1225 string actionsetDesc;
1226 ActionSet *allBulbON = new ActionSet();
1227 allBulbON->actionsetName = "AllBulbOn";
1229 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1231 Action *action = new Action();
1232 action->target = (*iter);
1234 Capability *capa = new Capability();
1235 capa->capability = "power";
1236 capa->status = "on";
1238 action->listOfCapability.push_back(capa);
1239 allBulbON->listOfAction.push_back(action);
1242 result = groupMgr->addActionSet(NULL, allBulbON, onPut);
1244 EXPECT_TRUE(result == OC_STACK_ERROR);
1250 //Add actionset with NULL ActionSet
1251 TEST_F(ThingsManagerTest, testAddActionSetAllBulbOnActionSetNull)
1255 result = groupMgr->addActionSet(g_resource, NULL, onPut);
1257 EXPECT_TRUE(result == OC_STACK_ERROR);
1263 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOn)
1265 string actionsetDesc;
1266 ActionSet *allBulbON = new ActionSet();
1267 allBulbON->actionsetName = "AllBulbOn1";
1269 mocks.ExpectCallFunc(onPut).
1270 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1271 const int /*eCode*/) { Proceed();});
1273 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1275 Action *action = new Action();
1276 action->target = (*iter);
1278 Capability *capa = new Capability();
1279 capa->capability = "power";
1280 capa->status = "on";
1282 action->listOfCapability.push_back(capa);
1283 allBulbON->listOfAction.push_back(action);
1287 result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1289 EXPECT_TRUE(result == OC_STACK_OK);
1293 mocks.ExpectCallFunc(onPost).
1294 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1295 const int /*eCode*/) { Proceed();});
1299 result = groupMgr->executeActionSet(g_resource, "AllBulbOn", &onPost);
1301 EXPECT_TRUE(result == OC_STACK_OK);
1307 //Execute actionset with NULL Resource
1308 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOnResourceNull)
1310 result = groupMgr->executeActionSet(NULL, "AllBulbOn", &onPost);
1312 EXPECT_TRUE(result == OC_STACK_ERROR);
1317 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOff)
1319 mocks.ExpectCallFunc(onPost).
1320 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1321 const int /*eCode*/) { Proceed();});
1325 result = groupMgr->executeActionSet(g_resource, "AllBulbOff", &onPost);
1327 EXPECT_TRUE(result == OC_STACK_OK);
1332 //Execute actionset with NULL resource
1333 TEST_F(ThingsManagerTest, testExecuteActionSetAllBulbOffResourceNull)
1335 result = groupMgr->executeActionSet(NULL, "AllBulbOff", &onPost);
1337 EXPECT_TRUE(result == OC_STACK_ERROR);
1341 //Execute actionset with Delay
1342 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelay)
1344 string actionsetDesc;
1345 ActionSet *allBulbON = new ActionSet();
1346 allBulbON->actionsetName = "AllBulbOnDelay";
1347 allBulbON->setDelay(1);
1349 mocks.ExpectCallFunc(onPut).
1350 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1351 const int /*eCode*/) { Proceed();});
1353 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1355 Action *action = new Action();
1356 action->target = (*iter);
1358 Capability *capa = new Capability();
1359 capa->capability = "power";
1360 capa->status = "off";
1362 action->listOfCapability.push_back(capa);
1363 allBulbON->listOfAction.push_back(action);
1367 result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1371 mocks.ExpectCallFunc(onPost).
1372 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1373 const int /*eCode*/) { Proceed();});
1377 result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", &onPost);
1379 EXPECT_TRUE(result == OC_STACK_OK);
1386 //Execute actionset with Delay = 0
1387 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelayEqulasZero)
1389 string actionsetDesc;
1390 ActionSet *allBulbON = new ActionSet();
1391 allBulbON->actionsetName = "AllBulbOnDelay";
1393 mocks.ExpectCallFunc(onPut).
1394 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1395 const int /*eCode*/) { Proceed();});
1397 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1399 Action *action = new Action();
1400 action->target = (*iter);
1402 Capability *capa = new Capability();
1403 capa->capability = "power";
1404 capa->status = "off";
1406 action->listOfCapability.push_back(capa);
1407 allBulbON->listOfAction.push_back(action);
1411 result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1417 result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", 0, &onPost);
1419 EXPECT_TRUE(result == OC_STACK_INVALID_PARAM);
1426 //Execute actionset with invalid Delay
1427 TEST_F(ThingsManagerTest, testExcecuteActionSetWithInvalidDelay)
1429 string actionsetDesc;
1430 ActionSet *allBulbON = new ActionSet();
1431 allBulbON->actionsetName = "AllBulbOnDelay";
1433 mocks.ExpectCallFunc(onPut).
1434 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1435 const int /*eCode*/) { Proceed();});
1437 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1439 Action *action = new Action();
1440 action->target = (*iter);
1442 Capability *capa = new Capability();
1443 capa->capability = "power";
1444 capa->status = "off";
1446 action->listOfCapability.push_back(capa);
1447 allBulbON->listOfAction.push_back(action);
1451 result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1457 result = groupMgr->executeActionSet(g_resource, "AllBulbOnDelay", -10, &onPost);
1459 EXPECT_TRUE(result == OC_STACK_INVALID_PARAM);
1466 //Execute actionset with delay on NULL Resource
1467 TEST_F(ThingsManagerTest, testExcecuteActionSetWithDelayWithResourceNull)
1469 string actionsetDesc;
1470 ActionSet *allBulbON = new ActionSet();
1471 allBulbON->actionsetName = "AllBulbOnDelay";
1472 allBulbON->setDelay(5);
1474 mocks.ExpectCallFunc(onPut).
1475 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1476 const int /*eCode*/) { Proceed();});
1478 for (auto iter = lights.begin(); iter != lights.end(); ++iter)
1480 Action *action = new Action();
1481 action->target = (*iter);
1483 Capability *capa = new Capability();
1484 capa->capability = "power";
1485 capa->status = "off";
1487 action->listOfCapability.push_back(capa);
1488 allBulbON->listOfAction.push_back(action);
1492 result = groupMgr->addActionSet(g_resource, allBulbON, onPut);
1495 result = groupMgr->executeActionSet(NULL, "AllBulbOnDelay", &onPost);
1496 EXPECT_TRUE(result == OC_STACK_ERROR);
1503 TEST_F(ThingsManagerTest, testCancelActionSet)
1505 mocks.ExpectCallFunc(onPost).
1506 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1507 const int /*eCode*/) { Proceed();});
1511 result = groupMgr->cancelActionSet(g_resource, "AllBulbOff", &onPost);
1513 EXPECT_TRUE(result == OC_STACK_OK);
1518 //Cancel ActionSet on NULL Resource
1519 TEST_F(ThingsManagerTest, testCancelActionSetResourceNull)
1521 result = groupMgr->cancelActionSet(NULL, "AllBulbOff", &onPost);
1523 EXPECT_TRUE(result == OC_STACK_ERROR);
1528 TEST_F(ThingsManagerTest, testDeleteActionSet)
1530 mocks.ExpectCallFunc(onPut).
1531 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1532 const int /*eCode*/) { Proceed();});
1536 result = groupMgr->deleteActionSet(g_resource, "AllBulbOff", &onPut);
1538 EXPECT_TRUE(result == OC_STACK_OK);
1543 //Delete ActionSet on NULL Resource
1544 TEST_F(ThingsManagerTest, testDeleteActionSetResourceNull)
1546 result = groupMgr->deleteActionSet(NULL, "AllBulbOff", &onPut);
1548 EXPECT_TRUE(result == OC_STACK_ERROR);
1553 TEST_F(ThingsManagerTest, testGetActionSet)
1555 mocks.ExpectCallFunc(onPost).
1556 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1557 const int /*eCode*/) { Proceed();});
1561 result = groupMgr->getActionSet(g_resource, "AllBulbOn", &onPost);
1563 EXPECT_TRUE(result == OC_STACK_OK);
1568 //Get ActionSet on NULL Resource
1569 TEST_F(ThingsManagerTest, testGetActionSetResourceNull)
1571 result = groupMgr->getActionSet(NULL, "AllBulbOn", &onPost);
1573 EXPECT_TRUE(result == OC_STACK_ERROR);
1577 //Get Configurations
1578 TEST_F(ThingsManagerTest, testGetConfigurations)
1580 ConfigurationName name = "all";
1582 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1583 std::vector< ConfigurationName > configurations;
1585 configurations.push_back(name);
1587 mocks.ExpectCallFunc(onGet).
1588 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1589 const int /*eCode*/) { Proceed();});
1591 vector<string> types;
1592 types.push_back("oic.wk.con");
1594 result = groupMgr->findCandidateResources(types, &foundResources);
1597 std::unique_lock < std::mutex > lock(blocker);
1600 if (result == OC_STACK_OK)
1602 result = g_thingsConf->getConfigurations(configurationResource, configurations, &onGet);
1604 EXPECT_TRUE(result == OC_STACK_OK);
1609 //Get Configurations with empty Configuration
1610 TEST_F(ThingsManagerTest, testGetConfigurationsEmptyConfiguration)
1612 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1613 std::vector< ConfigurationName > configurations;
1615 vector<string> types;
1616 types.push_back("oic.wk.con");
1618 result = groupMgr->findCandidateResources(types, &foundResources);
1621 std::unique_lock < std::mutex > lock(blocker);
1624 if (result == OC_STACK_OK)
1626 result = g_thingsConf->getConfigurations(configurationResource, configurations, &onGet);
1628 EXPECT_TRUE(result == OC_STACK_ERROR);
1633 //Get Configurations on NULL Resource
1634 TEST_F(ThingsManagerTest, testGetConfigurationsResourceNull)
1636 ConfigurationName name = "all";
1637 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1638 std::vector< ConfigurationName > configurations;
1640 configurations.push_back(name);
1642 result = g_thingsConf->getConfigurations(NULL, configurations, &onGet);
1644 EXPECT_TRUE(result == OC_STACK_ERROR);
1648 //Get all supported Configurations
1649 TEST_F(ThingsManagerTest, testGetallSupportedCOnfigurations)
1651 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1652 string retVal = g_thingsConf->getListOfSupportedConfigurationUnits();
1653 EXPECT_FALSE(retVal.size() == 0);
1657 TEST_F(ThingsManagerTest, testDoBootstrap)
1659 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1661 mocks.ExpectCallFunc(onGetBootstrapInformation).
1662 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1663 const int /*eCode*/) { Proceed();});
1664 result = g_thingsConf->doBootstrap(&onGetBootstrapInformation);
1666 EXPECT_TRUE(result == OC_STACK_OK);
1670 //DoBootstrap with NULL callback
1671 TEST_F(ThingsManagerTest, testDoBootstrapCallBackNull)
1673 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1675 result = g_thingsConf->doBootstrap(NULL);
1677 EXPECT_TRUE(result == OC_STACK_ERROR);
1681 //Update Configuration
1682 TEST_F(ThingsManagerTest, testUpdateConfiguration)
1684 ConfigurationName name = "r";
1685 ConfigurationValue value = "INDIA";
1687 std::map< ConfigurationName, ConfigurationValue > configurations;
1688 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1689 configurations.insert(std::make_pair(name, value));
1691 mocks.ExpectCallFunc(onUpdate).
1692 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1693 const int /*eCode*/) { Proceed();});
1695 vector<string> types;
1696 types.push_back("oic.wk.con");
1697 result = groupMgr->findCandidateResources(types, &foundResources);
1699 std::mutex blocker2;
1700 std::unique_lock < std::mutex > lock2(blocker2);
1703 if (result == OC_STACK_OK)
1705 result = g_thingsConf->updateConfigurations(configurationResource, configurations,
1708 EXPECT_TRUE(result == OC_STACK_OK);
1713 //Update Configuration with Empty Configuration
1714 TEST_F(ThingsManagerTest, testUpdateConfigurationEmptyConfiguration)
1716 std::map< ConfigurationName, ConfigurationValue > configurations;
1717 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1719 vector<string> types;
1720 types.push_back("oic.wk.con");
1721 result = groupMgr->findCandidateResources(types, &foundResources);
1723 std::mutex blocker2;
1724 std::unique_lock < std::mutex > lock2(blocker2);
1727 if (result == OC_STACK_OK)
1729 result = g_thingsConf->updateConfigurations(configurationResource, configurations,
1732 EXPECT_TRUE(result == OC_STACK_ERROR);
1737 //Update Configuration on NULL Resource
1738 TEST_F(ThingsManagerTest, testUpdateConfigurationResourceNull)
1740 ConfigurationName name = "r";
1741 ConfigurationValue value = "INDIA";
1743 std::map< ConfigurationName, ConfigurationValue > configurations;
1744 ThingsConfiguration *g_thingsConf = ThingsConfiguration::getInstance();
1746 configurations.insert(std::make_pair(name, value));
1748 result = g_thingsConf->updateConfigurations(NULL, configurations, &onUpdate);
1750 EXPECT_TRUE(result == OC_STACK_ERROR);
1755 TEST_F(ThingsManagerTest, testReboot)
1757 ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1759 mocks.ExpectCallFunc(onReboot).
1760 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1761 const int /*eCode*/) { Proceed();});
1763 vector<string> types;
1764 types.push_back("oic.wk.mnt");
1765 result = groupMgr->findCandidateResources(types, &foundResources);
1768 std::unique_lock < std::mutex > lock(blocker);
1771 if (result == OC_STACK_OK)
1773 result = g_thingsMnt->reboot(configurationResource, &onReboot);
1775 EXPECT_TRUE(result == OC_STACK_OK);
1780 //Reboot on NULL Resource
1781 TEST_F(ThingsManagerTest, testRebootResourceNull)
1783 ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1785 result = g_thingsMnt->reboot(NULL, &onReboot);
1787 EXPECT_TRUE(result == OC_STACK_ERROR);
1792 TEST_F(ThingsManagerTest, testFactoryReset)
1794 ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1796 mocks.ExpectCallFunc(onFactoryReset).
1797 Do([this](const HeaderOptions& /*headerOptions*/, const OCRepresentation& /*rep*/,
1798 const int /*eCode*/) { Proceed();});
1800 vector<string> types;
1801 types.push_back("oic.wk.mnt");
1802 result = groupMgr->findCandidateResources(types, &foundResources);
1805 std::unique_lock < std::mutex > lock(blocker);
1808 if (result == OC_STACK_OK)
1810 result = g_thingsMnt->factoryReset(configurationResource, &onFactoryReset);
1812 EXPECT_TRUE(result == OC_STACK_OK);
1817 //Factory Reset on NULL Resource
1818 TEST_F(ThingsManagerTest, testFactoryResetResourceNull)
1820 ThingsMaintenance *g_thingsMnt = ThingsMaintenance::getInstance();
1822 result = g_thingsMnt->factoryReset(NULL, &onFactoryReset);
1824 EXPECT_TRUE(result == OC_STACK_ERROR);