Merge test folder of test branch
[iotivity.git] / test / src / tc / es / gtest / src / btc / enrollee / ESEnrolleeTest.cpp
1 //******************************************************************
2 //
3 // Copyright 2016 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 "ESEnrolleeHelper.h"
22 #include <gtest/gtest.h>
23 #include "CommonUtil.h"
24 #include <atomic>
25 #include <functional>
26 #include <condition_variable>
27 #include <mutex>
28 #include <chrono>
29 #include "easysetup.h"
30 #include <escommon.h>
31 #include "ESEnrolleeCommon.h"
32 #include <iostream>
33 using namespace std;
34
35
36 class ESEnrolleeTest_btc: public ::testing::Test
37 {
38 public:
39     ESProvisioningCallbacks m_callbacks;
40     ESEnrolleeHelper esEnrolleeHelper;
41 protected:
42     virtual void SetUp()
43     {
44         CommonTestUtil::runCommonTCSetUpPart();
45         m_callbacks.WiFiConfProvCb = &ESEnrolleeHelper::wiFiProvCbInApp;
46         m_callbacks.CoapCloudConfProvCb = &ESEnrolleeHelper::cloudDataProvCbInApp;
47     }
48     virtual void TearDown()
49     {
50         OCStop();
51         CommonTestUtil::runCommonTCTearDownPart();
52     }
53 };
54
55 /**
56  * @since 2016-08-09
57  * @objective Test 'ESInitEnrollee' function with positive basic way
58  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
59  * @test_data 1. isSecured false
60  *            2. resourceMask ES_WIFICONF_RESOURCE
61  *            3. callbacks
62  * @pre_condition None
63  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in non-secured mode
64  * @post_condition None
65  * @expected ES_OK
66  **/
67 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
68 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskESWIFIRESOURCENonSecured_SRC_P)
69 {
70     ESResult m_result = ES_ERROR;
71     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE);
72
73     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
74     {
75         SET_FAILURE("OCStack init error!!\n");
76         return;
77     }
78     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
79
80     if (m_result != ES_OK)
81     {
82         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
83     }
84 }
85 #endif
86
87 /**
88  * @since 2016-08-09
89  * @objective Test 'ESInitEnrollee' function with positive basic way
90  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
91  * @test_data 1. isSecured true
92  *            2. resourceMask ES_WIFICONF_RESOURCE
93  *            3. callbacks
94  * @pre_condition None
95  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in secured mode
96  * @post_condition None
97  * @expected ES_OK
98  **/
99 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
100 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskESWIFIRESOURCESecured_SRC_P)
101 {
102     ESResult m_result = ES_ERROR;
103     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE);
104
105     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
106     {
107         SET_FAILURE("OCStack init error!!\n");
108         return;
109     }
110     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
111
112     if (m_result != ES_OK)
113     {
114         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
115     }
116 }
117 #endif
118
119 /**
120  * @since 2016-08-09
121  * @objective Test 'ESInitEnrollee' function with positive basic way
122  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
123  * @test_data 1. isSecured false
124  *            2. resourceMask ES_COAPCLOUDCONF_RESOURCE
125  *            3. callbacks
126  * @pre_condition None
127  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in non-secured mode
128  * @post_condition None close the apps
129  * @expected ES_OK
130  **/
131 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
132 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskESCLOUDRESOURCENonSecured_SRC_P)
133 {
134     ESResult m_result = ES_ERROR;
135     ESResourceMask resourcemMask = (ESResourceMask)(ES_COAPCLOUDCONF_RESOURCE);
136
137     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
138     {
139         SET_FAILURE("OCStack init error!!\n");
140         return;
141     }
142     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
143
144     if (m_result != ES_OK)
145     {
146         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
147     }
148 }
149 #endif
150
151 /**
152  * @since 2016-08-09
153  * @objective Test 'ESInitEnrollee' function with positive basic way
154  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
155  * @test_data 1. isSecured true
156  *            2. resourceMask ES_COAPCLOUDCONF_RESOURCE
157  *            3. callbacks
158  * @pre_condition None
159  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in secured mode
160  * @post_condition None close the apps
161  * @expected ES_OK
162  **/
163 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
164 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskESCLOUDRESOURCESecured_SRC_P)
165 {
166     ESResult m_result = ES_ERROR;
167     ESResourceMask resourcemMask = (ESResourceMask)(ES_COAPCLOUDCONF_RESOURCE);
168
169     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
170     {
171         SET_FAILURE("OCStack init error!!\n");
172         return;
173     }
174     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
175
176     if (m_result != ES_OK)
177     {
178         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
179     }
180 }
181 #endif
182
183 /**
184  * @since 2016-08-09
185  * @objective Test 'ESInitEnrollee' function with positive basic way
186  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
187  * @test_data 1. isSecured false
188  *            2. resourceMask ES_DEVCONF_RESOURCE
189  *            3. callbacks
190  * @pre_condition None
191  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in nonsecured mode
192  * @post_condition None
193  * @expected ES_OK
194  **/
195 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
196 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskESDEVCONFRESOURCENonSecured_SRC_P)
197 {
198     ESResult m_result = ES_ERROR;
199     ESResourceMask resourcemMask = (ESResourceMask)(ES_DEVCONF_RESOURCE);
200
201     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
202     {
203         SET_FAILURE("OCStack init error!!\n");
204         return;
205     }
206     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
207
208     if (m_result != ES_OK)
209     {
210         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
211     }
212 }
213 #endif
214
215 /**
216  * @since 2016-08-09
217  * @objective Test 'ESInitEnrollee' function with positive basic way
218  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
219  * @test_data 1. isSecured true
220  *            2. resourceMask ES_DEVCONF_RESOURCE
221  *            3. callbacks
222  * @pre_condition None
223  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in secured mode
224  * @post_condition None
225  * @expected ES_OK
226  **/
227 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
228 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskESDEVCONFRESOURCESecured_SRC_P)
229 {
230     ESResult m_result = ES_ERROR;
231     ESResourceMask resourcemMask = (ESResourceMask)(ES_DEVCONF_RESOURCE);
232
233     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
234     {
235         SET_FAILURE("OCStack init error!!\n");
236         return;
237     }
238     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
239
240     if (m_result != ES_OK)
241     {
242         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
243     }
244 }
245 #endif
246
247 /**
248  * @since 2016-08-09
249  * @objective Test 'ESInitEnrollee' function with positive basic way
250  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
251  * @test_data 1. isSecured false
252  *            2. resourceMask ALL
253  *            3. callbacks
254  * @pre_condition None
255  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in non-secured mode
256  * @post_condition None
257  * @expected ES_OK
258  **/
259 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
260 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskAllNonSecured_SRC_P)
261 {
262     ESResult m_result = ES_ERROR;
263     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
264
265     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
266     {
267         SET_FAILURE("OCStack init error!!\n");
268         return;
269     }
270     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
271
272     if (m_result != ES_OK)
273     {
274         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
275     }
276 }
277 #endif
278
279 /**
280  * @since 2016-08-09
281  * @objective Test 'ESInitEnrollee' function with positive basic way
282  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
283  * @test_data 1. isSecured true
284  *            2. resourceMask ALL
285  *            3. callbacks
286  * @pre_condition None
287  * @procedure Perform ESInitEnrollee and check if ES_OK is returned in secured mode
288  * @post_condition None
289  * @expected ES_OK
290  **/
291 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
292 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeResourceMaskAllSecured_SRC_P)
293 {
294     ESResult m_result = ES_ERROR;
295     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
296
297     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
298     {
299         SET_FAILURE("OCStack init error!!\n");
300         return;
301     }
302     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
303
304     if (m_result != ES_OK)
305     {
306         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
307     }
308 }
309 #endif
310
311 /**
312  * @since 2016-08-11
313  * @objective Test 'ESInitEnrollee' function with positive basic way
314  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
315  * @test_data 1. isSecured false
316  *            2. resourceMask ES_WIFICONF_RESOURCE
317  *            3. callbacks
318  * @pre_condition None
319  * @procedure Perform ESInitEnrollee and check if ES_OK is returned
320  * @post_condition None
321  * @expected ES_OK
322  **/
323 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
324 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeWorkWithAllCallback_SRC_P)
325 {
326     ESResult m_result = ES_ERROR;
327     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
328
329     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
330     {
331         SET_FAILURE("OCStack init error!!\n");
332         return;
333     }
334     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
335     if (m_result != ES_OK)
336     {
337         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
338     }
339 }
340 #endif
341
342 /**
343  * @since 2016-08-11
344  * @objective Test 'ESInitEnrollee' throughs error with null callback
345  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
346  * @test_data 1. isSecured true
347  *            2. resourceMask ES_WIFICONF_RESOURCE
348  *            3. WiFiProvcb Null
349  * @pre_condition None
350  * @procedure Perform ESInitEnrollee and check if ES_ERRORis returned
351  * @post_condition None
352  * @expected successfully called api and no error
353  **/
354 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
355 TEST_F(ESEnrolleeTest_btc, ESInitEnrollee_WiFiProvCb_Null_NV_N)
356 {
357     ESResult m_result = ES_OK;
358     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
359     m_callbacks.WiFiConfProvCb = NULL;
360
361     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
362     {
363         SET_FAILURE("OCStack init error!!\n");
364         return;
365     }
366     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
367
368     if (m_result != ES_ERROR)
369     {
370         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
371     }
372 }
373 #endif
374
375 /**
376  * @since 2016-08-11
377  * @objective Test 'ESInitEnrollee' throughs error with null callback
378  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
379  * @test_data 1. isSecured false
380  *            2. resourceMask ES_WIFICONF_RESOURCE
381  *            3. DevConfProvCbInApp Null
382  * @pre_condition None
383  * @procedure Perform ESInitEnrollee and check if ES_ERROR is returned
384  * @post_condition None
385  * @expected No error
386  **/
387 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
388 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeDevConfProvCbInApp_Null_NV_N)
389 {
390     ESResult m_result = ES_OK;
391     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
392     m_callbacks.DevConfProvCb = NULL;
393
394     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
395     {
396         SET_FAILURE("OCStack init error!!\n");
397         return;
398     }
399     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
400     if (m_result != ES_ERROR)
401     {
402         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
403     }
404 }
405 #endif
406
407 /**
408  * @since 2016-08-11
409  * @objective Test 'ESInitEnrollee' throughs error with null callback
410  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
411  * @test_data 1. isSecured true
412  *            2. resourceMask ES_WIFICONF_RESOURCE
413  *            3. CloudDataProvCbInApp Null
414  * @pre_condition None
415  * @procedure Perform ESInitEnrollee and check if ES_ERRORis returned
416  * @post_condition None
417  * @expected successfully call api and no error
418  **/
419 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
420 TEST_F(ESEnrolleeTest_btc, ESInitEnrolleeCloudDataProvCbInApp_Null_NV_N)
421 {
422     ESResult m_result = ES_OK;
423     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
424     m_callbacks.CoapCloudConfProvCb = NULL;
425
426     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
427     {
428         SET_FAILURE("OCStack init error!!\n");
429         return;
430     }
431     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
432
433     if (m_result != ES_ERROR)
434     {
435         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
436     }
437 }
438 #endif
439
440 /**
441  * @since 2016-08-11
442  * @objective Test 'ESSetDeviceProperty' works properly
443  * @target ESResult ESSetDeviceProperty(ESDeviceProperty *deviceProperty)
444  * @test_data 1. isSecured false
445  *            2. resourceMask
446  *            3. Callback
447  * @pre_condition None
448  * @procedure Perform ESSetDeviceProperty and check if ES_OK is returned in non-secured mode
449  * @post_condition None
450  * @expected ES_OK
451  **/
452 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
453 TEST_F(ESEnrolleeTest_btc, ESSetDevicePropertySetDevicePropertyNonSecured_SRC_P)
454 {
455     ESResult m_result = ES_ERROR;
456     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE); // | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
457
458     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
459     {
460         SET_FAILURE("OCStack init error!!\n");
461         return;
462     }
463     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
464     m_result = esEnrolleeHelper.setDeviceProperty();
465
466     if (m_result != ES_OK)
467     {
468         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
469     }
470 }
471 #endif
472
473 /**
474  * @since 2016-08-11
475  * @objective Test 'ESSetDeviceProperty' works properly
476  * @target ESResult ESSetDeviceProperty(ESDeviceProperty *deviceProperty)
477  * @test_data 1. isSecured true
478  *            2. resourceMask
479  *            3. Callback
480  * @pre_condition None
481  * @procedure Perform ESSetDeviceProperty and check if ES_OK is returned in secured mode
482  * @post_condition None
483  * @expected ES_OK
484  **/
485 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
486 TEST_F(ESEnrolleeTest_btc, ESSetDevicePropertySetDevicePropertySecured_SRC_P)
487 {
488     ESResult m_result = ES_ERROR;
489     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE); // | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
490
491     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
492     {
493         SET_FAILURE("OCStack init error!!\n");
494         return;
495     }
496     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
497     m_result = esEnrolleeHelper.setDeviceProperty();
498
499     if (m_result != ES_OK)
500     {
501         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
502     }
503 }
504 #endif
505
506 /**
507  * @since 2016-08-11
508  * @objective Test 'ESSetState' works properly
509  * @target ESResult ESResult ESSetState(ESEnrolleeState esState)
510  * @test_data 1. isSecured false
511  *            2. resourceMask
512  *            3. Callback
513  * @pre_condition None
514  * @procedure Perform ESSetState and check if ES_OK is returned in non-secured mode
515  * @post_condition None
516  * @expected ES_OK
517  **/
518 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
519 TEST_F(ESEnrolleeTest_btc, ESSetStateSetStateNonSecured_SRC_P)
520 {
521     ESResult m_result = ES_ERROR;
522     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
523
524     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
525     {
526         SET_FAILURE("OCStack init error!!\n");
527         return;
528     }
529     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
530     m_result = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
531
532     if (m_result != ES_OK)
533     {
534         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
535     }
536 }
537 #endif
538
539 /**
540  * @since 2016-08-11
541  * @objective Test 'ESSetState' works properly
542  * @target ESResult ESResult ESSetState(ESEnrolleeState esState)
543  * @test_data 1. isSecured true
544  *            2. resourceMask
545  *            3. Callback
546  * @pre_condition None
547  * @procedure Perform ESSetState and check if ES_OK is returned in secured mode
548  * @post_condition None
549  * @expected ES_OK
550  **/
551 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
552 TEST_F(ESEnrolleeTest_btc, ESSetStateSetStateSecured_SRC_P)
553 {
554     ESResult m_result = ES_ERROR;
555     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
556
557     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
558     {
559         SET_FAILURE("OCStack init error!!\n");
560         return;
561     }
562     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callbacks);
563     m_result = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
564
565     if (m_result != ES_OK)
566     {
567         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
568     }
569 }
570 #endif
571 /**
572  * @since 2016-08-11
573  * @objective Test 'ESSetErrorCode' works properly
574  * @target ESResult ESSetErrorCode(ESErrorCode esErrCode)
575  * @test_data 1. isSecured false
576  *            2. resourceMask
577  *            3. Callback
578  * @pre_condition None
579  * @procedure Perform ESSetErrorCode and check if ES_OK is returned
580  * @post_condition None
581  * @expected ES_OK
582  **/
583 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
584 TEST_F(ESEnrolleeTest_btc, ESSetErrorCodeSetErrorCodeWithSuccess_SRC_P)
585 {
586     ESResult m_result = ES_ERROR;
587     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
588
589     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
590     {
591         SET_FAILURE("OCStack init error!!\n");
592         return;
593     }
594     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
595     m_result = ESSetErrorCode(ES_ERRCODE_PW_WRONG);
596
597     if (m_result != ES_OK)
598     {
599         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
600     }
601 }
602 #endif
603
604 /**
605  * @since 2016-08-11
606  * @objective Test 'ESSetErrorCode' works properly
607  * @target ESResult ESSetErrorCode(ESErrorCode esErrCode)
608  * @test_data 1. isSecured false
609  *            2. resourceMask
610  *            3. Callback
611  * @pre_condition None
612  * @procedure Perform ESSetErrorCode and check if ES_OK is returned
613  * @post_condition None
614  * @expected ES_OK
615  **/
616 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
617 TEST_F(ESEnrolleeTest_btc, ESSetErrorCodeSetErrorCodeUnknownWithSuccess_SRC_P)
618 {
619     ESResult m_result = ES_ERROR;
620     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
621
622     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
623     {
624         SET_FAILURE("OCStack init error!!\n");
625         return;
626     }
627     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
628     m_result = ESSetErrorCode(ES_ERRCODE_UNKNOWN);
629
630     if (m_result != ES_OK)
631     {
632         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
633     }
634 }
635 #endif
636
637 /**
638  * @since 2016-08-11
639  * @objective Test 'ESSetErrorCode' return error with invalid input
640  * @target ESResult ESSetErrorCode(ESErrorCode esErrCode)
641  * @test_data 1. isSecured false
642  *            2. resourceMask
643  *            3. Callback
644  * @pre_condition None
645  * @procedure Perform ESSetErrorCode and check if ES_ERROR is returned
646  * @post_condition None
647  * @expected API called without error
648  **/
649 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
650 TEST_F(ESEnrolleeTest_btc, ESSetErrorCodeSetErrorEmptyCode_USV_N)
651 {
652     ESResult m_result = ES_OK;
653     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
654
655     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
656     {
657         SET_FAILURE("OCStack init error!!\n");
658         return;
659     }
660     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
661     m_result = ESSetErrorCode((ESErrorCode)1213100);
662
663     if (m_result != ES_ERROR)
664     {
665         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
666     }
667 }
668 #endif
669
670 /**
671  * @since 2016-08-11
672  * @objective Test 'ESTerminateEnrollee()' works properly
673  * @target ESResult ESTerminateEnrollee()
674  * @test_data
675  * @pre_condition None
676  * @procedure Perform ESTerminateEnrollee and check if ES_OK is returned
677  * @post_condition None
678  * @expected ES_OK
679  **/
680 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
681 TEST_F(ESEnrolleeTest_btc, ESTerminateEnrolleeSuccess_SRC_P)
682 {
683     ESResult m_result = ES_ERROR;
684     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
685     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
686     {
687         SET_FAILURE("OCStack init error!!\n");
688         return;
689     }
690     ESInitEnrollee(s_nonSecured, resourcemMask, m_callbacks);
691     m_result = ESTerminateEnrollee();
692
693     if (m_result != ES_OK)
694     {
695         SET_FAILURE("Failed to find resources. s_result is: " + std::to_string(m_result));
696     }
697 }
698 #endif
699