Merge test folder of test branch
[iotivity.git] / test / src / tc / es / gtest / src / stc / enrollee / ESEnrolleeTest.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 /**
22  * @file
23  *
24  * This file contains the implementation for EasySetup Enrollee device
25  */
26 #include "ESEnrolleeHelper.h"
27 #include <gtest/gtest.h>
28 #include "CommonUtil.h"
29 #include <atomic>
30 #include <functional>
31 #include <mutex>
32 #include <condition_variable>
33 #include <chrono>
34 #include "easysetup.h"
35 #include <escommon.h>
36 #include "ESEnrolleeCommon.h"
37 #include <iostream>
38 #ifdef HAVE_PTHREAD_H
39 #include <pthread.h>
40 #endif
41 using namespace std;
42
43 class ESEnrolleeTest_stc: public ::testing::Test
44 {
45 public:
46     ESProvisioningCallbacks m_callBacks;
47     ESEnrolleeHelper m_esEnrolleeHelper;
48
49 protected:
50
51     virtual void SetUp()
52     {
53         OCStackResult r = OC_STACK_ERROR;
54         CommonTestUtil::runCommonTCSetUpPart();
55         m_callBacks.WiFiConfProvCb = &m_esEnrolleeHelper.wiFiProvCbInApp;
56         m_callBacks.CoapCloudConfProvCb = &m_esEnrolleeHelper.cloudDataProvCbInApp;
57
58     }
59     virtual void TearDown()
60     {
61         CommonTestUtil::runCommonTCTearDownPart();
62     }
63 };
64
65 /**
66  * @since 2016-08-19
67  * @objective Test 'ESInitEnrollee' invoke callback for wifi resource
68  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
69  * @test_data 1. isSecured false
70  *            2. resourceMask ES_WIFICONF_RESOURCE
71  *            3. callbacks
72  * @pre_condition None
73  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and wifi prov callback is ivoked in non-secured mode
74  * @post_condition None
75  * @expected ES_OK is returned
76  **/
77 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
78 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskESWIFIRESOURCENonSecuredSuccessCallBack_SRC_P)
79 {
80
81     ESResult m_result;
82     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE);
83
84     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
85     {
86         SET_FAILURE("OCStack init error!!\n");
87         return;
88     }
89
90
91     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callBacks);
92
93     if (m_result != ES_OK)
94     {
95         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
96         return;
97     }
98
99      m_esEnrolleeHelper.waitForResponse();
100
101     if (!ESEnrolleeHelper::isCallbackInvoked)
102     {
103         SET_FAILURE("Failed to invoke callback. result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
104     }
105 }
106 #endif
107
108 /**
109  * @since 2016-08-23
110  * @objective Test 'ESInitEnrollee' invoke callback for wifi resource
111  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioninm_callBacks callbacks);
112  * @test_data 1. isSecured true
113  *            2. resourceMask ES_WIFICONF_RESOURCE
114  *            3. callbacks
115  * @pre_condition None
116  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and wifi prov callback is ivoked in secured mode
117  * @post_condition None
118  * @expected ES_OK is returned
119  **/
120 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
121 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskESWIFIRESOURCESecuredSuccessCallBack_SRC_P)
122 {
123     ESResult m_result;
124     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE);
125
126     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
127     {
128         SET_FAILURE("OCStack init error!!\n");
129         return;
130     }
131     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callBacks);
132     m_esEnrolleeHelper.waitForResponse();
133     if (m_result != ES_OK)
134     {
135         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
136         return;
137     }
138     
139     if (!ESEnrolleeHelper::isCallbackInvoked)
140     {
141         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
142     }
143 }
144 #endif
145
146 /**
147  * @since 2016-08-19
148  * @objective Test 'ESInitEnrollee' invoke callback for cloud resource
149  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
150  * @test_data 1. isSecured false
151  *            2. resourceMask ES_COAPCLOUDCONF_RESOURCE
152  *            3. callbacks
153  * @pre_condition None
154  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and CloudDataProv Cb is ivoked in non-secured mode
155  * @post_condition None close the apps
156  * @expected ES_OK is returned
157  **/
158
159 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
160 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskESCLOUDRESOURCENonSecuredSuccessCallBack_SRC_P)
161 {
162     ESResult m_result;
163     ESResourceMask resourcemMask = (ESResourceMask)(ES_COAPCLOUDCONF_RESOURCE);
164
165     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
166     {
167         SET_FAILURE("OCStack init error!!\n");
168         return;
169     }
170     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callBacks);
171     m_esEnrolleeHelper.waitForResponse();
172     if (m_result != ES_OK)
173     {
174         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
175         return;
176     }
177
178     if (!ESEnrolleeHelper::isCallbackInvoked)
179     {
180         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
181     }
182 }
183 #endif
184
185 /**
186  * @since 2016-08-23
187  * @objective Test 'ESInitEnrollee' invoke callback for cloud resource
188  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
189  * @test_data 1. isSecured true
190  *            2. resourceMask ES_COAPCLOUDCONF_RESOURCE
191  *            3. callbacks
192  * @pre_condition None
193  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and CloudDataProv Cb is ivoked in secured mode
194  * @post_condition None close the apps
195  * @expected ES_OK is returned
196  **/
197
198 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
199 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskESCLOUDRESOURCESecuredSuccessCallBack_SRC_P)
200 {
201     ESResult m_result;
202     ESResourceMask resourcemMask = (ESResourceMask)(ES_COAPCLOUDCONF_RESOURCE);
203
204     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
205     {
206         SET_FAILURE("OCStack init error!!\n");
207         return;
208     }
209     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callBacks);
210     m_esEnrolleeHelper.waitForResponse();
211     if (m_result != ES_OK)
212     {
213         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
214         return;
215     }
216
217     if (!ESEnrolleeHelper::isCallbackInvoked)
218     {
219         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
220     }
221 }
222 #endif
223
224 /**
225  * @since 2016-08-19
226  * @objective Test 'ESInitEnrollee' Invoke devconf collback
227  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
228  * @test_data 1. isSecured false
229  *            2. resourceMask ES_DEVCONF_RESOURCE
230  *            3. callbacks
231  * @pre_condition None
232  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and devconf Cb is ivoked in non-secured mode
233  * @post_condition None
234  * @expected ES_OK is returned
235  **/
236 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
237 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskESDEVCONFRESOURCENonSecuredSuccessCallback_SRC_P)
238 {
239     ESResult m_result;
240     ESResourceMask resourcemMask = (ESResourceMask)(ES_DEVCONF_RESOURCE);
241
242     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
243     {
244         SET_FAILURE("OCStack init error!!\n");
245         return;
246     }
247     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callBacks);
248     m_esEnrolleeHelper.waitForResponse();
249     if (m_result != ES_OK)
250     {
251         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
252         return;
253     }
254
255     if (!ESEnrolleeHelper::isCallbackInvoked)
256     {
257         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
258     }
259 }
260 #endif
261
262 /**
263  * @since 2016-08-23
264  * @objective Test 'ESInitEnrollee' Invoke devconf collback
265  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
266  * @test_data 1. isSecured true
267  *            2. resourceMask ES_DEVCONF_RESOURCE
268  *            3. callbacks
269  * @pre_condition None
270  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and devconf Cb is ivoked in secured mode
271  * @post_condition None
272  * @expected ES_OK is returned
273  **/
274 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
275 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskESDEVCONFRESOURCESecuredSuccessCallback_SRC_P)
276 {
277     ESResult m_result;
278     ESResourceMask resourcemMask = (ESResourceMask)(ES_DEVCONF_RESOURCE);
279
280     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
281     {
282         SET_FAILURE("OCStack init error!!\n");
283         return;
284     }
285     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callBacks);
286     m_esEnrolleeHelper.waitForResponse();
287     if (m_result != ES_OK)
288     {
289         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
290         return;
291     }
292
293     if (!ESEnrolleeHelper::isCallbackInvoked)
294     {
295         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
296     }
297 }
298 #endif
299
300 /**
301  * @since 2016-08-19
302  * @objective Test 'ESInitEnrollee' invoke all callback
303  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
304  * @test_data 1. isSecured false
305  *            2. resourceMask ALL
306  *            3. callbacks
307  * @pre_condition None
308  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and invoke all cb in non-secured mode
309  * @post_condition None
310  * @expected ES_OK is returned
311  **/
312 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
313 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskAllNonSecuredSuccesscallback_SRC_P)
314 {
315     ESResult m_result;
316     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
317
318     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
319     {
320         SET_FAILURE("OCStack init error!!\n");
321         return;
322     }
323     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callBacks);
324     m_esEnrolleeHelper.waitForResponse();
325     if (m_result != ES_OK)
326     {
327         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
328         return;
329     }
330
331     if (!ESEnrolleeHelper::isCallbackInvoked)
332     {
333         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
334     }
335 }
336 #endif
337
338 /**
339  * @since 2016-08-19
340  * @objective Test 'ESInitEnrollee' invoke all cb with secure mode
341  * @target ESResult ESInitEnrollee(bool isSecured, ESResourceMask resourceMask, ESProvisioningCallbacks callbacks);
342  * @test_data 1. isSecured true
343  *            2. resourceMask ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE
344  *            3. callbacks
345  * @pre_condition None
346  * @procedure Perform ESInitEnrollee and check if ES_OK is returned and invoke all cb in secured mode
347  * @post_condition None
348  * @expected ES_OK is returned
349  **/
350
351 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
352 TEST_F(ESEnrolleeTest_stc, ESInitEnrolleeResourceMaskAllSecuredSuccessCallBack_SRC_P)
353 {
354     ESResult m_result;
355     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
356
357     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
358     {
359         SET_FAILURE("OCStack init error!!\n");
360         return;
361     }
362     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callBacks);
363     m_esEnrolleeHelper.waitForResponse();
364     if (m_result != ES_OK)
365     {
366         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
367         return;
368     }
369
370     if (!ESEnrolleeHelper::isCallbackInvoked)
371     {
372         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
373     }
374 }
375 #endif
376
377 /**
378  * @since 2016-08-11
379  * @objective Test 'ESSetDeviceProperty' works properly
380  * @target ESResult ESSetDeviceProperty(ESDeviceProperty *deviceProperty)
381  * @test_data 1. isSecured true
382  *            2. resourceMask
383  *            3. Callback
384  * @pre_condition None
385  * @procedure Perform ESSetDeviceProperty and check if ES_OK is returned
386  * @post_condition None
387  * @expected ES_OK is returned
388  **/
389 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
390 TEST_F(ESEnrolleeTest_stc, ESSetDevicePropertySetDevicePropertyWithSuccessSecured_SRC_P)
391 {
392     ESResult m_result;
393     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
394
395     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
396     {
397         SET_FAILURE("OCStack init error!!\n");
398         return;
399     }
400     m_result = ESInitEnrollee(s_secured, resourcemMask, m_callBacks);
401     m_result = m_esEnrolleeHelper.setDeviceProperty();
402     if (m_result != ES_OK)
403     {
404         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
405     }
406
407 }
408 #endif
409
410 /**
411  * @since 2016-08-11
412  * @objective Test 'ESSetDeviceProperty' works properly
413  * @target ESResult ESSetDeviceProperty(ESDeviceProperty *deviceProperty)
414  * @test_data 1. isSecured false
415  *            2. resourceMask
416  *            3. Callback
417  * @pre_condition None
418  * @procedure Perform ESSetDeviceProperty and check if ES_OK is returned
419  * @post_condition None
420  * @expected ES_OK is returned
421  **/
422 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
423 TEST_F(ESEnrolleeTest_stc, ESSetDevicePropertySetDevicePropertyWithSuccessNonSecured_SRC_P)
424 {
425     ESResult m_result;
426     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
427
428     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
429     {
430         SET_FAILURE("OCStack init error!!\n");
431         return;
432     }
433     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callBacks);
434     m_result = m_esEnrolleeHelper.setDeviceProperty();
435     if (m_result != ES_OK)
436     {
437         SET_FAILURE("Failed to find resources. result is: " + std::to_string(m_result));
438     }
439 }
440 #endif
441
442 /**
443  * @since 2016-08-23
444  * @objective Test 'ESTerminateEnrollee()' terminate Provisioning and Network resources successfully
445  * @target ESResult ESTerminateEnrollee()
446  * @test_data 1. isSecured false
447  *            2. resourceMask
448  *            3. Callback
449  * @pre_condition None
450  * @procedure Perform ESTerminateEnrollee and check if ES_OK is returned, also checked all provisioning
451  * and network resource terminate properly
452  * @post_condition None
453  * @expected ES_OK is returned
454  **/
455 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
456 TEST_F(ESEnrolleeTest_stc, ESTerminateEnrolleeWorkProperly_SRC_N)
457 {
458     ESResult m_result;
459     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE | ES_COAPCLOUDCONF_RESOURCE | ES_DEVCONF_RESOURCE);
460
461     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
462     {
463         SET_FAILURE("OCStack init error!!\n");
464         return;
465     }
466     m_result = ESInitEnrollee(s_nonSecured, resourcemMask, m_callBacks);
467     m_result = ESTerminateEnrollee();
468     //m_esEnrolleeHelper.waitForResponse();
469
470     if (m_result != ES_OK)
471     {
472         SET_FAILURE("Failed to find resources. m_result is: " + std::to_string(m_result));
473         return;
474     }
475
476     if (ESEnrolleeHelper::isCallbackInvoked)
477     {
478         SET_FAILURE("Failed to invoke callback. m_result is: " + std::to_string(ESEnrolleeHelper::isCallbackInvoked));
479     }
480
481 }
482 #endif