Merge test folder of test branch
[iotivity.git] / test / src / tc / es / gtest / src / btc / mediator / ESRichCommonTest.cpp
1 //******************************************************************
2 //
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
4 //
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 //      http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
20
21 #include <gtest/gtest.h>
22 #include "CommonUtil.h"
23 #include "CommonTestUtil.h"
24 #include <atomic>
25 #include <functional>
26 #include <condition_variable>
27 #include <mutex>
28 #include <chrono>
29 #include <exception>
30 #include "easysetup.h"
31 #include <escommon.h>
32 #include "ESEnrolleeCommon.h"
33 #include <iostream>
34 #include "ESMediatorHelper.h"
35 #include "OCRepresentation.h"
36
37
38 #define WIFI_AUTHTYPE NONE_AUTH
39 #define WIFI_ENCTYPE NONE_ENC
40
41 using namespace std;
42 using namespace OC;
43 using namespace OIC::Service;
44
45 class ESRichCommonTest_btc: public ::testing::Test
46 {
47 public:
48     
49 protected:
50
51     virtual void SetUp()
52     {
53         CommonTestUtil::runCommonTCSetUpPart();
54     }
55
56     virtual void TearDown()
57     {
58         CommonTestUtil::runCommonTCTearDownPart();
59     }
60
61 };
62
63 /**
64  * @since 2016-08-18
65  * @objective Test 'getProvStatus' API with positive basic way
66  * @target Void getProvStatus();
67  * @test_data    None
68  * @pre_condition None
69  * @procedure Perform getProvStatus()
70  * @post_condition None
71  * @expected successfully called api
72  **/
73 TEST_F(ESRichCommonTest_btc, GetProvStatus_SRC_P)
74 {
75     try
76     {
77         const OCRepresentation mDevConfRep;
78
79         // std::shared_ptr< GetEnrolleeStatus > status;
80         EnrolleeStatus enrolleeStatus(mDevConfRep);
81         ASSERT_EQ(enrolleeStatus.getProvStatus(), ES_STATE_INIT);
82     }
83     catch (exception& e)
84     {
85         SET_FAILURE("Exception occurred in get ProvStatus: " + std::string(e.what()));
86     }
87 }
88
89 /**
90  * @since 2016-08-18
91  * @objective Test 'getLastErrCode' API with positive basic way
92  * @target Void getLastErrCode();
93  * @test_data    None
94  * @pre_condition None
95  * @procedure Perform getLastErrCode()
96  * @post_condition None
97  * @expected successfully called api
98  **/
99 TEST_F(ESRichCommonTest_btc, GetLastErrorCode_SRC_P)
100 {
101     try
102     {
103         const OCRepresentation mDevConfRep;
104
105         EnrolleeStatus enrolleeStatus(mDevConfRep);
106         ASSERT_EQ(enrolleeStatus.getLastErrCode(), ES_ERRCODE_NO_ERROR);
107     }
108
109     catch (exception& e)
110     {
111         SET_FAILURE("Exception occurred in get LastErrCode: " + std::string(e.what()));
112     }
113 }
114
115 /**
116  * @since 2016-08-18
117  * @objective Test 'setCloudProp' API with positive basic way
118  * @target Void setCloudProp();
119  * @test_data    None
120  * @pre_condition None
121  * @procedure Perform setCloudProp()
122  * @post_condition None
123  * @expected successfully called api
124  **/
125 TEST_F(ESRichCommonTest_btc, SetCloudProp_SRC_P)
126 {
127     try
128     {
129         const OCRepresentation mDevConfRep;
130         CloudProp cloudProp(mDevConfRep);
131         cloudProp.setCloudProp(AUTH_CODE, AUTH_PROVIDER, CI_SERVER);
132     }
133
134     catch (exception& e)
135     {
136         SET_FAILURE("Exception occurred in setCloudProp: " + std::string(e.what()));
137     }
138 }
139
140 /**
141  * @since 2016-08-18
142  * @objective Test 'setCloudProp' API in negative way with empty value
143  * @target Void setCloudProp();
144  * @test_data    None
145  * @pre_condition None
146  * @procedure Perform setCloudProp()
147  * @post_condition None
148  * @expected successfully called api
149  **/
150 TEST_F(ESRichCommonTest_btc, SetCloudProp_ESV_N)
151 {
152     try
153     {
154         const OCRepresentation mDevConfRep;
155         CloudProp cloudProp(mDevConfRep);
156         cloudProp.setCloudProp(EMPTY_STRING, EMPTY_STRING, EMPTY_STRING);
157     }
158
159     catch (exception& e)
160     {
161         SET_FAILURE("Exception occurred in setCloudProp: " + std::string(e.what()));
162     }
163 }
164
165 /**
166  * @since 2016-08-18
167  * @objective Test 'setCloudProp' API in negative way with null value
168  * @target Void setCloudProp();
169  * @test_data    None
170  * @pre_condition None
171  * @procedure Perform setCloudProp()
172  * @post_condition None
173  * @expected successfully called api
174  **/
175 TEST_F(ESRichCommonTest_btc, SetCloudProp_NV_N)
176 {
177     try
178     {
179         const OCRepresentation mDevConfRep;
180         CloudProp cloudProp(mDevConfRep);
181         cloudProp.setCloudProp(NULL_VALUE, NULL_VALUE, NULL_VALUE);
182     }
183     catch (exception& e)
184     {
185         ASSERT_EQ(std::string(e.what()), "basic_string::_M_construct null not valid")<<"Exception occurred in provisionProperties but not null type";
186     }
187 }
188
189 /**
190  * @since 2016-08-18
191  * @objective Test 'setCloudID' API with positive basic way
192  * @target Void setCloudID();
193  * @test_data    None
194  * @pre_condition None
195  * @procedure Perform setCloudID()
196  * @post_condition None
197  * @expected successfully called api
198  **/
199 TEST_F(ESRichCommonTest_btc, setCloudID_SRC_P)
200 {
201     try
202     {
203         const OCRepresentation mDevConfRep;
204         CloudProp cloudProp(mDevConfRep);
205         cloudProp.setCloudID(CLOUD_ID);
206     }
207     catch (exception& e)
208     {
209         SET_FAILURE("Exception occurred in set CloudId: " + std::string(e.what()));
210     }
211 }
212
213 /**
214  * @since 2017-10-24
215  * @objective Test 'getCredID' API with positive basic way
216  * @target std::string getCredID() const;
217  * @test_data    None
218  * @pre_condition None
219  * @procedure Perform getCredID()
220  * @post_condition None
221  * @expected successfully called api
222  **/
223 TEST_F(ESRichCommonTest_btc, GetCredID_SRC_P)
224 {
225     try
226     {
227         const OCRepresentation mDevConfRep;
228         CloudProp cloudProp(mDevConfRep);
229         cloudProp.setCredID(CLOUD_ID);
230         ASSERT_EQ(cloudProp.getCredID(), CLOUD_ID);
231     }
232     catch (exception& e)
233     {
234         SET_FAILURE("Exception occurred in get CredID: " + std::string(e.what()));
235     }
236 }
237
238 /**
239  * @since 2017-10-24
240  * @objective Test 'getCredID' API in negative way(without set; trying to get Cred)
241  * @target std::string getCredID() const;
242  * @test_data    None
243  * @pre_condition None
244  * @procedure Perform getCredID()
245  * @post_condition None
246  * @expected successfully called api & should return empty string
247  **/
248 TEST_F(ESRichCommonTest_btc, GetCredID_DSCC_N)
249 {
250     try
251     {
252         const OCRepresentation mDevConfRep;
253         CloudProp cloudProp(mDevConfRep);
254         ASSERT_NE(cloudProp.getCredID(), EMPTY_STRING);
255     }
256     catch (exception& e)
257     {
258         SET_FAILURE("Exception occurred in get Ssid: " + std::string(e.what()));
259     }
260 }
261 /**
262  * @since 2016-08-18
263  * @objective Test 'setCloudID' API in negative way with empty value
264  * @target Void setCloudID();
265  * @test_data    None
266  * @pre_condition None
267  * @procedure Perform setCloudID()
268  * @post_condition None
269  * @expected successfully called api
270  **/
271 TEST_F(ESRichCommonTest_btc, setCloudID_ESV_P)
272 {
273     try
274     {
275         const OCRepresentation mDevConfRep;
276         CloudProp cloudProp(mDevConfRep);
277         cloudProp.setCloudID(EMPTY_STRING);
278     }
279     catch (exception& e)
280     {
281         SET_FAILURE("Exception occurred in set CloudId: " + std::string(e.what()));
282     }
283 }
284
285 /**
286  * @since 2016-08-18
287  * @objective Test 'setCloudID' API in negative way with NULL value
288  * @target Void setCloudID();
289  * @test_data    None
290  * @pre_condition None
291  * @procedure Perform setCloudID()
292  * @post_condition None
293  * @expected successfully called api
294  **/
295 TEST_F(ESRichCommonTest_btc, setCloudID_NV_P)
296 {
297     try
298     {
299         const OCRepresentation mDevConfRep;
300         CloudProp cloudProp(mDevConfRep);
301         cloudProp.setCloudID(NULL_VALUE);
302     }
303     catch (exception& e)
304     {
305         ASSERT_EQ(std::string(e.what()), "basic_string::_M_construct null not valid")<<"Exception occurred in provisionProperties but not null type";
306 //        SET_FAILURE("Exception occurred in set CloudId: " + std::string(e.what()));
307     }
308 }
309
310 /**
311  * @since 2016-08-18
312  * @objective Test 'getAuthCode' API with positive basic way
313  * @target std::string getAuthCode() const;
314  * @test_data    None
315  * @pre_condition None
316  * @procedure Perform getAuthCode()
317  * @post_condition None
318  * @expected successfully called api
319  **/
320 TEST_F(ESRichCommonTest_btc, GetAuthCode_SRC_P)
321 {
322     try
323     {
324         const OCRepresentation mDevConfRep;
325         CloudProp cloudProp(mDevConfRep);
326         cloudProp.setCloudProp(AUTH_CODE, AUTH_PROVIDER, CI_SERVER);
327         ASSERT_EQ(cloudProp.getAuthCode(), AUTH_CODE);
328     }
329
330     catch (exception& e)
331     {
332         SET_FAILURE("Exception occurred in get AuthCode: " + std::string(e.what()));
333     }
334 }
335
336 /**
337  * @since 2016-08-18
338  * @objective Test 'getAuthProvider' API with positive basic way
339  * @target std::string getAuthProvider() const;
340  * @test_data    None
341  * @pre_condition None
342  * @procedure Perform getAuthProvider()
343  * @post_condition None
344  * @expected successfully called api
345  **/
346 TEST_F(ESRichCommonTest_btc, GetAuthProvider_SRC_P)
347 {
348     try
349     {
350         const OCRepresentation mDevConfRep;
351         CloudProp cloudProp(mDevConfRep);
352         cloudProp.setCloudProp(AUTH_CODE, AUTH_PROVIDER, CI_SERVER);
353         ASSERT_EQ(cloudProp.getAuthProvider(), AUTH_PROVIDER);
354     }
355     catch (exception& e)
356     {
357         SET_FAILURE("Exception occurred in get AuthProvider: " + std::string(e.what()));
358     }
359 }
360
361 /**
362  * @since 2016-08-18
363  * @objective Test 'getCiServer' API with positive basic way
364  * @target std::string getCiServer() const;
365  * @test_data    None
366  * @pre_condition None
367  * @procedure Perform getCiServer()
368  * @post_condition None
369  * @expected successfully called api
370  **/
371 TEST_F(ESRichCommonTest_btc, GetCiServer_SRC_P)
372 {
373     try
374     {
375         const OCRepresentation mDevConfRep;
376         CloudProp cloudProp(mDevConfRep);
377         cloudProp.setCloudProp(AUTH_CODE, AUTH_PROVIDER, CI_SERVER);
378         ASSERT_EQ(cloudProp.getCiServer(), CI_SERVER);
379     }
380     catch (exception& e)
381     {
382         SET_FAILURE("Exception occurred in get CiServer: " + std::string(e.what()));
383     }
384 }
385
386 /**
387  * @since 2016-08-18
388  * @objective Test 'getCloudID' API with positive basic way
389  * @target std::string getCloudID() const;
390  * @test_data    None
391  * @pre_condition None
392  * @procedure Perform getCloudID()
393  * @post_condition None
394  * @expected successfully called api
395  **/
396 TEST_F(ESRichCommonTest_btc, GetCloudID_SRC_P)
397 {
398     try
399     {
400         const OCRepresentation mDevConfRep;
401         CloudProp cloudProp(mDevConfRep);
402         cloudProp.setCloudID(CLOUD_ID);
403         ASSERT_EQ(cloudProp.getCloudID(), CLOUD_ID);
404     }
405     catch (exception& e)
406     {
407         SET_FAILURE("Exception occurred in get CloudID: " + std::string(e.what()));
408     }
409 }
410
411 /**
412  * @since 2018-02-07
413  * @objective Test 'setCloudPropWithAccessToken' API with positive basic way
414  * @target Void setCloudPropWithAccessToken();
415  * @test_data    None
416  * @pre_condition None
417  * @procedure Perform setCloudPropWithAccessToken()
418  * @post_condition None
419  * @expected successfully called api
420  **/
421 TEST_F(ESRichCommonTest_btc, SetCloudPropWithAccessToken_SRC_P)
422 {
423     try
424     {
425         const OCRepresentation mDevConfRep;
426         CloudProp cloudProp(mDevConfRep);
427         cloudProp.setCloudPropWithAccessToken(AUTH_ACCESSTOKEN, OAUTH_TOKENTYPE_BEARER, AUTH_PROVIDER, CI_SERVER);
428     }
429
430     catch (exception& e)
431     {
432         SET_FAILURE("Exception occurred in SetCloudPropWithAccessToken: " + std::string(e.what()));
433     }
434 }
435
436 /**
437  * @since 2018-02-07
438  * @objective Test 'setCloudPropWithAccessToken' API in negative way with empty value
439  * @target Void setCloudPropWithAccessToken();
440  * @test_data    None
441  * @pre_condition None
442  * @procedure Perform setCloudPropWithAccessToken()
443  * @post_condition None
444  * @expected successfully called api
445  **/
446 TEST_F(ESRichCommonTest_btc, SetCloudPropWithAccessToken_ESV_P)
447 {
448     try
449     {
450         const OCRepresentation mDevConfRep;
451         CloudProp cloudProp(mDevConfRep);
452         cloudProp.setCloudPropWithAccessToken(EMPTY_STRING, OAUTH_TOKENTYPE_BEARER, EMPTY_STRING, EMPTY_STRING);
453     }
454
455     catch (exception& e)
456     {
457         SET_FAILURE("Exception occurred in SetCloudPropWithAccessToken: " + std::string(e.what()));
458     }
459 }
460
461 /**
462  * @since 2018-02-07
463  * @objective Test 'getAccessToken' API with positive basic way
464  * @target std::string getAccessToken() const;
465  * @test_data    None
466  * @pre_condition None
467  * @procedure Perform getAccessToken()
468  * @post_condition None
469  * @expected successfully called api
470  **/
471  TEST_F(ESRichCommonTest_btc, GetAccessToken_SRC_P)
472 {
473     try
474     {
475         const OCRepresentation mDevConfRep;
476         CloudProp cloudProp(mDevConfRep);
477         cloudProp.setCloudPropWithAccessToken(AUTH_ACCESSTOKEN, OAUTH_TOKENTYPE_BEARER, AUTH_PROVIDER, CI_SERVER);
478         ASSERT_EQ(cloudProp.getAccessToken(), AUTH_ACCESSTOKEN);
479     }
480
481     catch (exception& e)
482     {
483         SET_FAILURE("Exception occurred in SetCloudPropWithAccessToken: " + std::string(e.what()));
484     }
485 }
486
487 /**
488  * @since 2018-02-07
489  * @objective Test 'getAccessTokenType' API with positive basic way
490  * @target std::string getAccessTokenType() const;
491  * @test_data    None
492  * @pre_condition None
493  * @procedure Perform getAccessTokenType()
494  * @post_condition None
495  * @expected successfully called api
496  **/
497  TEST_F(ESRichCommonTest_btc, GetAccessTokenType_SRC_P)
498 {
499     try
500     {
501         const OCRepresentation mDevConfRep;
502         CloudProp cloudProp(mDevConfRep);
503         cloudProp.setCloudPropWithAccessToken(AUTH_ACCESSTOKEN, OAUTH_TOKENTYPE_BEARER, AUTH_PROVIDER, CI_SERVER);
504         ASSERT_EQ(cloudProp.getAccessTokenType(), OAUTH_TOKENTYPE_BEARER);
505     }
506
507     catch (exception& e)
508     {
509         SET_FAILURE("Exception occurred in SetCloudPropWithAccessToken: " + std::string(e.what()));
510     }
511 }
512
513 /**
514  * @since 2016-08-18
515  * @objective Test 'setWiFiProp' API with positive basic way
516  * @target void setWiFiProp() const;
517  * @test_data    None
518  * @pre_condition None
519  * @procedure Perform setWiFiProp()
520  * @post_condition None
521  * @expected successfully called api
522  **/
523 TEST_F(ESRichCommonTest_btc, SetWiFiProp_SRC_P)
524 {
525     try
526     {
527         const OCRepresentation mDevConfRep;
528         DeviceProp deviceProp(mDevConfRep);
529         deviceProp.setWiFiProp(SSID, PASSWORD, WIFI_AUTHTYPE, WIFI_ENCTYPE);
530     }
531     catch (exception& e)
532     {
533         SET_FAILURE("Exception occurred in set WiFiProp: " + std::string(e.what()));
534     }
535 }
536
537 /**
538  * @since 2016-08-18
539  * @objective Test 'setWiFiProp' API in negative way with empty value
540  * @target void setWiFiProp() const;
541  * @test_data    None
542  * @pre_condition None
543  * @procedure Perform setWiFiProp()
544  * @post_condition None
545  * @expected successfully called api
546  **/
547 TEST_F(ESRichCommonTest_btc, SetWiFiProp_ESV_N)
548 {
549     try
550     {
551         const OCRepresentation mDevConfRep;
552         DeviceProp deviceProp(mDevConfRep);
553         deviceProp.setWiFiProp(EMPTY_STRING, EMPTY_STRING, WIFI_AUTHTYPE, WIFI_ENCTYPE);
554     }
555     catch (exception& e)
556     {
557         SET_FAILURE("Exception occurred in set WiFiProp: " + std::string(e.what()));
558     }
559 }
560
561 /**
562  * @since 2016-08-18
563  * @objective Test 'setWiFiProp' API in negative way with null value
564  * @target void setWiFiProp() const;
565  * @test_data    None
566  * @pre_condition None
567  * @procedure Perform setWiFiProp()
568  * @post_condition None
569  * @expected successfully called api
570  **/
571 TEST_F(ESRichCommonTest_btc, SetWiFiProp_NV_N)
572 {
573     try
574     {
575         const OCRepresentation mDevConfRep;
576         DeviceProp deviceProp(mDevConfRep);
577         deviceProp.setWiFiProp(NULL_VALUE, NULL_VALUE, WIFI_AUTHTYPE, WIFI_ENCTYPE);
578     }
579     catch (exception& e)
580     {
581         ASSERT_EQ(std::string(e.what()), "basic_string::_M_construct null not valid")<<"Exception occurred in provisionProperties but not null type";
582     }
583 }
584
585 /**
586  * @since 2016-08-19
587  * @objective Test 'getSsid' API with positive basic way
588  * @target std::string getSsid() const;
589  * @test_data    None
590  * @pre_condition None
591  * @procedure Perform getSsid()
592  * @post_condition None
593  * @expected successfully called api
594  **/
595 TEST_F(ESRichCommonTest_btc, GetSsid_SRC_P)
596 {
597     try
598     {
599         const OCRepresentation mDevConfRep;
600         DeviceProp deviceProp(mDevConfRep);
601         deviceProp.setWiFiProp(SSID, PASSWORD, WIFI_AUTHTYPE, WIFI_ENCTYPE);
602         ASSERT_EQ(deviceProp.getSsid(), SSID);
603     }
604     catch (exception& e)
605     {
606         SET_FAILURE("Exception occurred in get Ssid: " + std::string(e.what()));
607     }
608 }
609
610 /**
611  * @since 2016-08-19
612  * @objective Test 'getSsid' API in negative way(without set; trying to get SSID)
613  * @target std::string getSsid() const;
614  * @test_data    None
615  * @pre_condition None
616  * @procedure Perform getSsid()
617  * @post_condition None
618  * @expected successfully called api & should return empty string
619  **/
620 TEST_F(ESRichCommonTest_btc, GetSsid_DSCC_N)
621 {
622     try
623     {
624         const OCRepresentation mDevConfRep;
625         DeviceProp deviceProp(mDevConfRep);
626         ASSERT_EQ(deviceProp.getSsid(), EMPTY_STRING);
627     }
628     catch (exception& e)
629     {
630         SET_FAILURE("Exception occurred in get Ssid: " + std::string(e.what()));
631     }
632 }
633
634 /**
635  * @since 2016-08-19
636  * @objective Test 'getPassword' API with positive basic way
637  * @target std::string getPassword() const;
638  * @test_data    None
639  * @pre_condition None
640  * @procedure Perform getPassword()
641  * @post_condition None
642  * @expected successfully called api
643  **/
644 TEST_F(ESRichCommonTest_btc, GetPassword_SRC_P)
645 {
646     try
647     {
648         const OCRepresentation mDevConfRep;
649         DeviceProp deviceProp(mDevConfRep);
650         deviceProp.setWiFiProp(SSID, PASSWORD, WIFI_AUTHTYPE, WIFI_ENCTYPE);
651         ASSERT_EQ(deviceProp.getPassword(), PASSWORD);
652     }
653     catch (exception& e)
654     {
655         SET_FAILURE("Exception occurred in get Password: " + std::string(e.what()));
656     }
657 }
658
659 /**
660  * @since 2016-08-19
661  * @objective Test 'getPassword' API in negative way(without set; trying to get Password)
662  * @target std::string getPassword() const;
663  * @test_data    None
664  * @pre_condition None
665  * @procedure Perform getPassword()
666  * @post_condition None
667  * @expected successfully called api & should return empty string
668  **/
669 TEST_F(ESRichCommonTest_btc, GetPassword_DSCC_N)
670 {
671     try
672     {
673         const OCRepresentation mDevConfRep;
674         DeviceProp deviceProp(mDevConfRep);
675         ASSERT_EQ(deviceProp.getPassword(), EMPTY_STRING);
676     }
677     catch (exception& e)
678     {
679         SET_FAILURE("Exception occurred in get Password: " + std::string(e.what()));
680     }
681 }
682
683 /**
684  * @since 2016-08-19
685  * @objective Test 'getAuthType' API with positive basic way
686  * @target WIFI_AUTHTYPE getAuthType() const;
687  * @test_data    None
688  * @pre_condition None
689  * @procedure Perform getAuthType()
690  * @post_condition None
691  * @expected successfully called api
692  **/
693 TEST_F(ESRichCommonTest_btc, GetAuthType_SRC_P)
694 {
695     try
696     {
697         const OCRepresentation mDevConfRep;
698         DeviceProp deviceProp(mDevConfRep);
699         deviceProp.setWiFiProp(SSID, PASSWORD, WIFI_AUTHTYPE, WIFI_ENCTYPE);
700         ASSERT_EQ(deviceProp.getAuthType(), WIFI_AUTHTYPE);
701     }
702     catch (exception& e)
703     {
704         SET_FAILURE("Exception occurred in get AuthType: " + std::string(e.what()));
705     }
706 }
707
708 /**
709  * @since 2016-08-19
710  * @objective Test 'getEncType' API with positive basic way
711  * @target WIFI_ENCTYPE getEncType() const;
712  * @test_data    None
713  * @pre_condition None
714  * @procedure Perform getEncType()
715  * @post_condition None
716  * @expected successfully called api
717  **/
718 TEST_F(ESRichCommonTest_btc, getEncType_SRC_P)
719 {
720     try
721     {
722         const OCRepresentation mDevConfRep;
723         DeviceProp deviceProp(mDevConfRep);
724         ASSERT_EQ(deviceProp.getEncType(), WIFI_ENCTYPE);
725     }
726     catch (exception& e)
727     {
728         SET_FAILURE("Exception occurred in get EncType: " + std::string(e.what()));
729     }
730 }
731
732 /**
733  * @since 2016-08-19
734  * @objective Test 'getDeviceName' API in negative way(without set; trying to get name)
735  * @target std::string getDeviceName() const;
736  * @test_data    None
737  * @pre_condition None
738  * @procedure Perform getDeviceName()
739  * @post_condition None
740  * @expected successfully called api & should return empty string
741  **/
742 TEST_F(ESRichCommonTest_btc, GetDeviceName_SRC_P)
743 {
744     try
745     {
746         const OCRepresentation mDevConfRep;
747         EnrolleeConf enrolleeConf(mDevConfRep);
748         ASSERT_EQ(enrolleeConf.getDeviceName(), EMPTY_STRING);
749     }
750     catch (exception& e)
751     {
752         SET_FAILURE("Exception occurred in get DeviceName: " + std::string(e.what()));
753     }
754 }
755
756 /**
757  * @since 2016-08-19
758  * @objective Test 'getWiFiFreq' API in positive way
759  * @target WIFI_FREQ getWiFiFreq() const;
760  * @test_data    None
761  * @pre_condition None
762  * @procedure Perform getWiFiFreq()
763  * @post_condition None
764  * @expected successfully called api
765  **/
766 TEST_F(ESRichCommonTest_btc, GetWiFiFreq_SRC_P)
767 {
768     try
769     {
770         const OCRepresentation mDevConfRep;
771         EnrolleeConf enrolleeConf(mDevConfRep);
772         ASSERT_EQ(enrolleeConf.getWiFiFreq(), WIFI_FREQ_NONE);
773     }
774     catch (exception& e)
775     {
776         SET_FAILURE("Exception occurred in get WiFiFreq: " + std::string(e.what()));
777     }
778 }