1 //******************************************************************
3 // Copyright 2016 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 <gtest/gtest.h>
22 #include <HippoMocks/hippomocks.h>
25 #include <condition_variable>
29 #include "ESMediatorSimulator.h"
30 #include "easysetup.h"
33 #include "samsung/sc_easysetup.h"
39 std::atomic_bool g_isStartedStack(false);
41 std::chrono::milliseconds g_waitForResponse(1000);
43 std::condition_variable responseCon;
44 std::mutex mutexForCondition;
46 ESMediatorSimulator g_mediatorSimul;
49 class TestWithMock: public testing::Test
55 virtual ~TestWithMock() noexcept(noexcept(std::declval<Test>().~Test()))
59 virtual void TearDown()
73 class EasysetupEnrolleeTest : public TestWithMock
76 EasysetupEnrolleeTest() = default;
77 ~EasysetupEnrolleeTest() = default;
79 static void discoveredResource(std::shared_ptr<OC::OCResource>)
81 std::cout << __func__ << std::endl;
84 static void onGetStatus(std::shared_ptr< GetEnrolleeStatus >)
86 std::cout << __func__ << std::endl;
89 static void onGetConfiguration(std::shared_ptr< GetConfigurationStatus >)
91 std::cout << __func__ << std::endl;
94 static void onGetWifiRsrc(const OCRepresentation& )
96 std::cout << __func__ << std::endl;
99 static void onGetCloudRsrc(const OCRepresentation& )
101 std::cout << __func__ << std::endl;
104 static void onGetDeviceConf(const OCRepresentation& )
106 std::cout << __func__ << std::endl;
109 static void onPutRequest(const OCRepresentation& )
111 std::cout << __func__ << std::endl;
114 static void deviceProvisioningStatusCallback(std::shared_ptr< DevicePropProvisioningStatus >)
116 std::cout << __func__ << std::endl;
119 static void cloudProvisioningStatusCallback(std::shared_ptr< CloudPropProvisioningStatus >)
121 std::cout << __func__ << std::endl;
124 static void WiFiConfProvCbInApp(ESWiFiConfData *)
126 std::cout << __func__ << std::endl;
129 static void DevConfProvCbInApp(ESDevConfData *)
131 std::cout << __func__ << std::endl;
134 static void CoapCloudConfCbInApp(ESCoapCloudConfData *)
136 std::cout << __func__ << std::endl;
139 ESResult startEnrollee()
141 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
142 ES_COAPCLOUDCONF_RESOURCE |
143 ES_DEVCONF_RESOURCE);
144 ESProvisioningCallbacks callbacks;
145 callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
146 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
147 callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
149 return ESInitEnrollee(false, resourcemMask, callbacks);
152 ESResult startEnrolleeWithInvalidRsrcMask()
154 ESProvisioningCallbacks callbacks;
155 callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
156 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
157 callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
159 return ESInitEnrollee(false, (ESResourceMask)0, callbacks);
162 ESResult setDeviceProperty()
164 ESDeviceProperty deviceProperty = {
165 {{WIFI_11G, WiFi_EOF}, WIFI_5G}, {"Test Device"}
168 return ESSetDeviceProperty(&deviceProperty);
171 ESResult setCallabckForUserDataNULL()
173 return ESSetCallbackForUserdata(NULL, NULL);
180 TestWithMock::SetUp();
182 if (g_isStartedStack == false)
184 if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
186 printf("OCStack init error!!\n");
190 g_isStartedStack = true;
196 TestWithMock::TearDown();
201 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeSuccess)
203 ESResult ret = startEnrollee();
204 EXPECT_EQ(ret, ES_OK);
205 ESTerminateEnrollee();
208 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedInvalidRsrcMask)
210 ESResult ret = startEnrolleeWithInvalidRsrcMask();
211 EXPECT_EQ(ret, ES_ERROR);
212 ESTerminateEnrollee();
215 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
217 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
218 ES_COAPCLOUDCONF_RESOURCE |
219 ES_DEVCONF_RESOURCE);
220 ESProvisioningCallbacks callbacks;
221 callbacks.WiFiConfProvCb = NULL;
222 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
223 callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
225 ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
226 EXPECT_EQ(ret, ES_ERROR);
227 ESTerminateEnrollee();
230 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
232 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
233 ES_COAPCLOUDCONF_RESOURCE |
234 ES_DEVCONF_RESOURCE);
235 ESProvisioningCallbacks callbacks;
236 callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
237 callbacks.DevConfProvCb = NULL;
238 callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
240 ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
241 EXPECT_EQ(ret, ES_ERROR);
242 ESTerminateEnrollee();
245 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByCloudCbIsNull)
247 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
248 ES_COAPCLOUDCONF_RESOURCE |
249 ES_DEVCONF_RESOURCE);
250 ESProvisioningCallbacks callbacks;
251 callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
252 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
253 callbacks.CoapCloudConfProvCb = NULL;
255 ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
256 EXPECT_EQ(ret, ES_ERROR);
257 ESTerminateEnrollee();
260 TEST_F(EasysetupEnrolleeTest, FindProvisioningResourceAtEnrolleeWithSuccess)
262 mocks.ExpectCallFunc(discoveredResource).Do(
263 [](std::shared_ptr<OC::OCResource> resource)
267 std::cout<<"DISCOVERED Resource:"<<std::endl;
268 // Get the resource host address
269 std::string uri = resource->uri();
270 std::cout << "\tURI of the resource: " << uri << std::endl;
271 } catch (OCException &e)
273 std::cout << e.reason() << std::endl;
278 ESResult ret = startEnrollee();
280 g_mediatorSimul.discoverRemoteEnrollee(discoveredResource);
282 std::unique_lock< std::mutex > lock{ mutexForCondition };
283 responseCon.wait_for(lock, g_waitForResponse);
285 EXPECT_EQ(ret, ES_OK);
287 ESTerminateEnrollee();
290 TEST_F(EasysetupEnrolleeTest, SetDevicePropertyWithSuccess)
292 ESResult ret = startEnrollee();
293 ret = setDeviceProperty();
294 EXPECT_EQ(ret, ES_OK);
295 ESTerminateEnrollee();
298 TEST_F(EasysetupEnrolleeTest, SetProvStatusWithSuccess)
300 ESResult ret = startEnrollee();
301 ret = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
302 EXPECT_EQ(ret, ES_OK);
303 ESTerminateEnrollee();
306 TEST_F(EasysetupEnrolleeTest, SetErrorCodeWithSuccess)
308 ESResult ret = startEnrollee();
309 ret = ESSetErrorCode(ES_ERRCODE_PW_WRONG);
310 EXPECT_EQ(ret, ES_OK);
311 ESTerminateEnrollee();
314 TEST_F(EasysetupEnrolleeTest, DevicePropertyIsWellConstructedInResponsePayload)
316 bool isWellConstructed = false;
317 mocks.ExpectCallFunc(onGetConfiguration).Do(
318 [& isWellConstructed](std::shared_ptr< GetConfigurationStatus > status)
320 if(status->getESResult() == ES_OK)
322 EnrolleeConf conf = status->getEnrolleeConf();
323 if(conf.getWiFiModes().at(0) == WIFI_11G &&
324 conf.getWiFiFreq() == WIFI_5G &&
325 !strcmp(conf.getDeviceName().c_str(), "Test Device"))
327 isWellConstructed = true;
331 ESResult ret = startEnrollee();
332 ret = setDeviceProperty();
334 g_mediatorSimul.getConfiguration(onGetConfiguration);
336 std::unique_lock< std::mutex > lock{ mutexForCondition };
337 responseCon.wait_for(lock, g_waitForResponse);
339 EXPECT_EQ(ret, ES_OK);
341 ESTerminateEnrollee();
344 TEST_F(EasysetupEnrolleeTest, ProvisioningPropertiesIsWellConstructedInResponsePayload)
346 bool isWellConstructed = false;
347 mocks.ExpectCallFunc(onGetStatus).Do(
348 [& isWellConstructed](std::shared_ptr< GetEnrolleeStatus > status)
350 if(status->getESResult() == ES_OK)
352 EnrolleeStatus enrolleeStatus = status->getEnrolleeStatus();
355 if(enrolleeStatus.getProvStatus() == ES_STATE_CONNECTED_TO_ENROLLER &&
356 enrolleeStatus.getLastErrCode() == ES_ERRCODE_NO_INTERNETCONNECTION)
358 isWellConstructed = true;
362 ESResult ret = startEnrollee();
363 ret = setDeviceProperty();
364 ret = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
365 ret = ESSetErrorCode(ES_ERRCODE_NO_INTERNETCONNECTION);
367 g_mediatorSimul.getStatus(onGetStatus);
369 std::unique_lock< std::mutex > lock{ mutexForCondition };
370 responseCon.wait_for(lock, g_waitForResponse);
372 EXPECT_EQ(ret, ES_OK);
374 ESTerminateEnrollee();
377 TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
379 int cntForReceivedCallbackWithSuccess = 0;
381 mocks.OnCallFunc(deviceProvisioningStatusCallback).Do(
382 [& cntForReceivedCallbackWithSuccess](std::shared_ptr< DevicePropProvisioningStatus > status)
384 if(status->getESResult() == ES_OK)
385 cntForReceivedCallbackWithSuccess++;
388 mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
389 [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
391 if(!strcmp(data->ssid, "Iotivity_SSID") &&
392 !strcmp(data->pwd, "Iotivity_PWD") &&
393 data->authtype == WPA2_PSK &&
394 data->enctype == TKIP_AES)
396 cntForReceivedCallbackWithSuccess++;
402 g_mediatorSimul.provisionDeviceProperties(deviceProvisioningStatusCallback);
404 std::unique_lock< std::mutex > lock{ mutexForCondition };
405 responseCon.wait_for(lock, g_waitForResponse);
407 EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
409 ESTerminateEnrollee();
412 TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
414 int cntForReceivedCallbackWithSuccess = 0;
416 mocks.OnCallFunc(cloudProvisioningStatusCallback).Do(
417 [& cntForReceivedCallbackWithSuccess](std::shared_ptr< CloudPropProvisioningStatus > status)
419 if(status->getESResult() == ES_OK)
421 cntForReceivedCallbackWithSuccess++;
425 mocks.OnCallFunc(CoapCloudConfCbInApp).Do(
426 [& cntForReceivedCallbackWithSuccess](ESCoapCloudConfData *data)
428 if(!strcmp(data->authCode, "authCode") &&
429 !strcmp(data->authProvider, "authProvider") &&
430 !strcmp(data->ciServer, "ciServer"))
432 cntForReceivedCallbackWithSuccess++;
438 g_mediatorSimul.provisionCloudProperties(cloudProvisioningStatusCallback);
440 std::unique_lock< std::mutex > lock{ mutexForCondition };
441 responseCon.wait_for(lock, g_waitForResponse);
443 EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
445 ESTerminateEnrollee();
448 TEST_F(EasysetupEnrolleeTest, GetWifiRsrcTest)
450 bool isRepFlag = false;
451 mocks.ExpectCallFunc(onGetWifiRsrc).Do(
452 [& isRepFlag](const OCRepresentation& /*rep*/)
458 ESResult ret = startEnrollee();
459 g_mediatorSimul.getWifiRsrc(onGetWifiRsrc);
461 std::unique_lock< std::mutex > lock{ mutexForCondition };
462 responseCon.wait_for(lock, g_waitForResponse);
464 EXPECT_EQ(ret, ES_OK);
466 ESTerminateEnrollee();
469 TEST_F(EasysetupEnrolleeTest, GetCloudRsrcTest)
471 bool isRepFlag = false;
472 mocks.ExpectCallFunc(onGetCloudRsrc).Do(
473 [& isRepFlag](const OCRepresentation& /*rep*/)
478 ESResult ret = startEnrollee();
479 g_mediatorSimul.getCloudRsrc(onGetCloudRsrc);
481 std::unique_lock< std::mutex > lock{ mutexForCondition };
482 responseCon.wait_for(lock, g_waitForResponse);
484 EXPECT_EQ(ret, ES_OK);
486 ESTerminateEnrollee();
489 TEST_F(EasysetupEnrolleeTest, GetDevConfTest)
491 bool isRepFlag = false;
492 mocks.ExpectCallFunc(onGetDeviceConf).Do(
493 [& isRepFlag](const OCRepresentation& /*rep*/)
498 ESResult ret = startEnrollee();
499 ret = setDeviceProperty();
501 g_mediatorSimul.getDevConfiguration(onGetDeviceConf);
503 std::unique_lock< std::mutex > lock{ mutexForCondition };
504 responseCon.wait_for(lock, g_waitForResponse);
506 EXPECT_EQ(ret, ES_OK);
508 ESTerminateEnrollee();
511 TEST_F(EasysetupEnrolleeTest, PutRequestTest)
513 bool isRepFlag = false;
514 mocks.ExpectCallFunc(onPutRequest).Do(
515 [& isRepFlag](const OCRepresentation& /*rep*/)
520 ESResult ret = startEnrollee();
522 g_mediatorSimul.putProvRsrc(onPutRequest);
524 std::unique_lock< std::mutex > lock{ mutexForCondition };
525 responseCon.wait_for(lock, g_waitForResponse);
527 EXPECT_EQ(ret, ES_OK);
529 ESTerminateEnrollee();
532 TEST_F(EasysetupEnrolleeTest, ESSetCallabckForUserDataFailed)
534 ESResult ret = setCallabckForUserDataNULL();
535 EXPECT_EQ(ret, ES_ERROR);
536 ESTerminateEnrollee();
539 TEST_F(EasysetupEnrolleeTest, ESSC_SetSCProperties)
541 ESResult ret = startEnrollee();
542 EXPECT_EQ(ret, ES_OK);
543 SCProperties properties;
544 strncpy(properties.candidateAPInfo[0].ssid, "x_5GHz", MAXLEN_STRING);
545 strncpy(properties.candidateAPInfo[0].passphrase, "12345678",MAXLEN_STRING);
546 properties.candidateAPInfo[0].channel = 149;
547 strncpy(properties.candidateAPInfo[0].bssid, "aa:bb:cc:dd:ee:01", MAXLEN_STRING);
548 strncpy(properties.candidateAPInfo[1].ssid, "5GHz", MAXLEN_STRING);
549 strncpy(properties.candidateAPInfo[1].passphrase, "12345678",MAXLEN_STRING);
550 properties.candidateAPInfo[1].channel = 161;
551 strncpy(properties.candidateAPInfo[1].bssid, "aa:bb:cc:dd:ee:02", MAXLEN_STRING);
552 properties.numCandidateAP=2;
554 ret = SetSCProperties(&properties);
555 EXPECT_EQ(ret, ES_OK);
556 ESTerminateEnrollee();
559 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSCProperties)
561 ESResult ret = startEnrollee();
562 EXPECT_EQ(ret, ES_OK);
564 ret = SetSCProperties(NULL);
565 EXPECT_EQ(ret, ES_ERROR);
566 ESTerminateEnrollee();
569 TEST_F(EasysetupEnrolleeTest, ESSC_SetTncInfo)
571 ESResult ret = startEnrollee();
572 EXPECT_EQ(ret, ES_OK);
575 strncpy(info.header, "h1", MAXLEN_STRING);
576 strncpy(info.version, "v1",MAXLEN_STRING);
578 ret = SetSCTncInfo(&info);
579 EXPECT_EQ(ret, ES_OK);
580 ESTerminateEnrollee();
583 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLTncInfo)
585 ESResult ret = startEnrollee();
586 EXPECT_EQ(ret, ES_OK);
588 ret = SetSCTncInfo(NULL);
589 EXPECT_EQ(ret, ES_ERROR);
590 ESTerminateEnrollee();
593 TEST_F(EasysetupEnrolleeTest, ESSC_SetTncStatus)
595 ESResult ret = startEnrollee();
596 EXPECT_EQ(ret, ES_OK);
598 ret = SetSCTncStatus(1);
599 EXPECT_EQ(ret, ES_OK);
600 ESTerminateEnrollee();
603 TEST_F(EasysetupEnrolleeTest, ESSC_SetSCNetConnectionState)
605 ESResult ret = startEnrollee();
606 EXPECT_EQ(ret, ES_OK);
608 ret = SetSCNetConnectionState(NET_STATE_INIT);
609 EXPECT_EQ(ret, ES_OK);
610 ESTerminateEnrollee();
613 TEST_F(EasysetupEnrolleeTest, ESSC_SetRegisterSetDevice)
615 ESResult ret = startEnrollee();
616 EXPECT_EQ(ret, ES_OK);
618 ret = SetRegisterSetDevice("fridge");
619 EXPECT_EQ(ret, ES_OK);
620 ESTerminateEnrollee();
623 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLRegisterSetDevice)
625 ESResult ret = startEnrollee();
626 EXPECT_EQ(ret, ES_OK);
628 ret = SetRegisterSetDevice(NULL);
629 EXPECT_EQ(ret, ES_ERROR);
630 ESTerminateEnrollee();
633 TEST_F(EasysetupEnrolleeTest, ESSC_SetNetworkProvInfo)
635 ESResult ret = startEnrollee();
636 EXPECT_EQ(ret, ES_OK);
638 ret = SetNetworkProvInfo("netInfo");
639 EXPECT_EQ(ret, ES_OK);
640 ESTerminateEnrollee();
643 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSetNetworkProvInfo)
645 ESResult ret = startEnrollee();
646 EXPECT_EQ(ret, ES_OK);
648 ret = SetNetworkProvInfo(NULL);
649 EXPECT_EQ(ret, ES_ERROR);
650 ESTerminateEnrollee();
653 TEST_F(EasysetupEnrolleeTest, ESSC_SetSCPnPPin)
655 ESResult ret = startEnrollee();
656 EXPECT_EQ(ret, ES_OK);
658 ret = SetSCPnPPin("123456");
659 EXPECT_EQ(ret, ES_OK);
660 ESTerminateEnrollee();
663 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSCPnPPin)
665 ESResult ret = startEnrollee();
666 EXPECT_EQ(ret, ES_OK);
668 ret = SetSCPnPPin(NULL);
669 EXPECT_EQ(ret, ES_ERROR);
670 ESTerminateEnrollee();
673 TEST_F(EasysetupEnrolleeTest, ESSC_SetESVersionInfo)
675 ESResult ret = startEnrollee();
676 EXPECT_EQ(ret, ES_OK);
678 ret = SetESVersionInfo("1.0");
679 EXPECT_EQ(ret, ES_OK);
680 ESTerminateEnrollee();
683 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLESVersionInfo)
685 ESResult ret = startEnrollee();
686 EXPECT_EQ(ret, ES_OK);
688 ret = SetESVersionInfo(NULL);
689 EXPECT_EQ(ret, ES_ERROR);
690 ESTerminateEnrollee();
693 TEST_F(EasysetupEnrolleeTest, ESSC_SetSSOList)
695 ESResult ret = startEnrollee();
696 EXPECT_EQ(ret, ES_OK);
698 ret = SetSSOList("xyz");
699 EXPECT_EQ(ret, ES_OK);
700 ESTerminateEnrollee();
703 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSSOList)
705 ESResult ret = startEnrollee();
706 EXPECT_EQ(ret, ES_OK);
708 ret = SetSSOList(NULL);
709 EXPECT_EQ(ret, ES_ERROR);
710 ESTerminateEnrollee();
713 TEST_F(EasysetupEnrolleeTest, ReadWriteUserCallback)
715 int cntForReceivedCallbackWithSuccess = 0;
717 mocks.OnCallFunc(deviceProvisioningStatusCallback).Do(
718 [& cntForReceivedCallbackWithSuccess](std::shared_ptr< DevicePropProvisioningStatus > status)
720 if(status->getESResult() == ES_OK)
721 cntForReceivedCallbackWithSuccess++;
724 mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
725 [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
727 if(!strcmp(data->ssid, "Iotivity_SSID") &&
728 !strcmp(data->pwd, "Iotivity_PWD") &&
729 data->authtype == WPA2_PSK &&
730 data->enctype == TKIP_AES)
732 cntForReceivedCallbackWithSuccess++;
738 EXPECT_EQ(ESSetCallbackForUserdata(&ReadUserdataCb, &WriteUserdataCb), ES_OK);
740 g_mediatorSimul.provisionDeviceProperties(deviceProvisioningStatusCallback);
742 std::unique_lock< std::mutex > lock{ mutexForCondition };
743 responseCon.wait_for(lock, g_waitForResponse);
745 EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
747 ESTerminateEnrollee();