Merge test folder of test branch
[iotivity.git] / test / src / tc / chp / gtest / src / btc / CHPServerTest.cpp
1 //******************************************************************
2 //
3 // Copyright 2017 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 #include "CHPHelper.h"
23
24
25 class CHPServerTest_btc: public  ::testing::Test
26 {
27
28     protected:
29         CHPHelper *m_pchpHelper;
30         CHPServerTest_btc()
31         {
32             m_pchpHelper = nullptr;
33         }
34
35         virtual void SetUp()
36         {
37             m_pchpHelper = CHPHelper::getInstance();
38             CommonTestUtil::runCommonTCSetUpPart();
39
40         }
41         virtual void TearDown()
42         {
43             CommonTestUtil::runCommonTCTearDownPart();
44         }
45
46 };
47
48 /**
49  * @since           2017-03-27
50  * @see             OCStackResult CHPInitialize(bool secure)
51  * @objective       Test CHPInitialize function without calling ocinit non secure build & Non Secure argument
52  * @target          OCStackResult CHPInitialize(bool secure)
53  * @test_data       1. CHPInitialize with non secure argument
54  * @pre_condition   none
55  * @procedure       Call CHPInitialize with 0 as argument
56  * @post_condition  none
57  * @expected        expected no crash & OC_STACK_INVALID_PARAM
58  */
59 #if defined(__LINUX__)
60 TEST_F(CHPServerTest_btc, CHPInitializeNonSecurewithoutOCInit_ECRC_N)
61 {
62     EXPECT_EQ(OC_STACK_INVALID_PARAM, m_pchpHelper->initializeCHPNonSecure());
63 }
64 #endif
65
66 /**
67  * @since           2017-03-27
68  * @see             OCStackResult CHPInitialize(bool secure);
69  * @objective       Test CHPInitialize function without calling ocinit non secure build & Secure argument
70  * @target          OCStackResult CHPInitialize(bool secure)
71  * @test_data       1. CHPInitialize with secure argument
72  * @pre_condition   none
73  * @procedure       Call CHPInitialize with 1 as argument
74  * @post_condition  none
75  * @expected        expected no crash and OC_STACK_INVALID_PARAM
76  */
77 #if defined(__LINUX__)
78 TEST_F(CHPServerTest_btc, CHPInitializeSecurewithoutOCInit_ECRC_N)
79 {
80     EXPECT_EQ(OC_STACK_INVALID_PARAM, m_pchpHelper->initializeCHPSecure());
81 }
82 #endif
83
84 /**
85  * @since           2016-03-27
86  * @see             OCStackResult CHPTerminate();
87  * @objective       Test CHPTerminate function without CHPInitialize
88  * @target          OCStackResult CHPTerminate();
89  * @test_data       none
90  * @pre_condition   none
91  * @procedure       Call CHPTerminate
92  * @post_condition  none
93  * @expected        CHPTerminate not crash and will return OC_STACK_OK
94  */
95 #if defined(__LINUX__)
96 TEST_F(CHPServerTest_btc, CHPTerminate_ECRC_N)
97 {
98     EXPECT_EQ(OC_STACK_OK,(m_pchpHelper->terminateCHP()));
99 }
100 #endif
101
102 /**
103  * @since           2017-03-27
104  * @see             OCStackResult OCInit(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags);
105  * @see             OCStackResult CHPInitialize(bool secure)
106  * @see             OCStackResult CHPTerminate()
107  * @objective       Test CHPInitialize function with non secure build & Non Secure argument
108  * @target          OCStackResult CHPInitialize(bool secure)
109  * @test_data       1. CHPInitialize with non secure argument
110  * @pre_condition   1. Call OCInit(NULL, 0, OC_SERVER)
111  * @procedure       Call CHPInitialize with 0 as argument
112  * @post_condition  Call CHPTerminate
113  * @expected        CHPInitialize will succeed and will return OC_STACK_OK
114  */
115 #if defined(__LINUX__)
116 TEST_F(CHPServerTest_btc, CHPInitializeNonSecure_SRC_P)
117 {
118     m_pchpHelper->initializeOC();
119     EXPECT_EQ(OC_STACK_OK, m_pchpHelper->initializeCHPNonSecure());
120     CommonUtil::waitInSecond(CHP_SLEEPTIME_MAX);
121     m_pchpHelper->terminateCHP();
122 }
123 #endif
124
125 /**
126  * @since           2017-03-27
127  * @see             OCStackResult OCInit(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags);
128  * @see             OCStackResult CHPInitialize(bool secure)
129  * @see             OCStackResult CHPTerminate()
130  * @objective       Test CHPInitialize function with non secure build & Secure argument
131  * @target          OCStackResult CHPInitialize(bool secure)
132  * @test_data       1. CHPInitialize with secure argument
133  * @pre_condition   1. Call OCInit(NULL, 0, OC_SERVER)
134  * @procedure       Call CHPInitialize with 1 as argument
135  * @post_condition  Call CHPTerminate
136  * @expected        CHPInitialize will succeed and will return OC_STACK_OK
137  */
138 #if defined(__LINUX__)
139 TEST_F(CHPServerTest_btc, CHPInitializedSecure_SRC_N)
140 {
141     m_pchpHelper->initializeOC();
142     EXPECT_EQ(OC_STACK_OK, m_pchpHelper->initializeCHPSecure());
143     CommonUtil::waitInSecond(CHP_SLEEPTIME_MAX);
144     m_pchpHelper->terminateCHP();
145 }
146 #endif
147
148 /**
149  * @since           2017-03-27
150  * @see             OCStackResult OCInit(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags);
151  * @see             OCStackResult CHPInitialize(bool secure)
152  * @see             OCStackResult CHPTerminate()
153  * @objective       Test CHPTerminate function with non secure build & Non Secure Initialization
154  * @target          OCStackResult CHPTerminate()
155  * @test_data       none
156  * @pre_condition   1. Call OCInit(NULL, 0, OC_SERVER)
157  *                  2. CHPInitialize with non secure argument
158  * @procedure       Call CHPTerminate
159  * @post_condition  none
160  * @expected        CHPTerminate will succeed and will return OC_STACK_OK
161  */
162 #if defined(__LINUX__)
163 TEST_F(CHPServerTest_btc, CHPTerminateNonSecure_SRC_P)
164 {
165     m_pchpHelper->initializeOC();
166     m_pchpHelper->initializeCHPNonSecure();
167     CommonUtil::waitInSecond(CHP_SLEEPTIME_MAX);
168     EXPECT_EQ(OC_STACK_OK, m_pchpHelper->terminateCHP());
169 }
170 #endif
171
172 /**
173  * @since           2017-03-27
174  * @see             OCStackResult OCInit(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags);
175  * @see             OCStackResult CHPInitialize(bool secure)
176  * @see             OCStackResult CHPTerminate()
177  * @objective       Test CHPTerminate function with non secure build & Secure Initialization
178  * @target          OCStackResult CHPTerminate()
179  * @test_data       none
180  * @pre_condition   1. Call OCInit(NULL, 0, OC_SERVER)
181  *                  2. CHPInitialize with secure argument
182  * @procedure       Call CHPTerminate
183  * @post_condition  none
184  * @expected        CHPTerminate will succeed and will return OC_STACK_OK
185  */
186 #if defined(__LINUX__)
187 TEST_F(CHPServerTest_btc, CHPTerminateSecure_SRC_P)
188 {
189     m_pchpHelper->initializeOC();
190     m_pchpHelper->initializeCHPSecure();
191     CommonUtil::waitInSecond(CHP_SLEEPTIME_MAX);
192     EXPECT_EQ(OC_STACK_OK, m_pchpHelper->terminateCHP());
193 }
194 #endif
195
196 /**
197  * @since           2017-03-27
198  * @see             bool CHPIsInitialized()
199  * @objective       Test CHPIsInitialized function with out Initialization
200  * @target          bool CHPIsInitialized()
201  * @test_data       none
202  * @pre_condition   none
203  * @procedure       Call bool CHPIsInitialized()
204  * @post_condition  none
205  * @expected        CHPIsInitialized() will return false
206  */
207 #if defined(__LINUX__)
208 TEST_F(CHPServerTest_btc, CHPIsInitialized_SRC_N)
209 {
210     EXPECT_EQ(false, m_pchpHelper->isInitializedCHP());
211 }
212 #endif
213
214 /**
215  * @since           2017-03-27
216  * @see             OCStackResult OCInit(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags);
217  * @see             bool CHPIsInitialized()
218  * @see             OCStackResult CHPInitialize(bool secure)
219  * @see             OCStackResult CHPTerminate()
220  * @objective       Test CHPIsInitialized function with secure build & Secure Initialization
221  * @target          bool CHPInitialize()
222  * @test_data       none
223  * @pre_condition   1. Call OCInit(NULL, 0, OC_SERVER)
224  *                  2. CHPInitialize with secure argument
225  * @procedure       Call CHPIsInitialized
226  * @post_condition  Call CHPTerminate
227  * @expected        CHPIsInitialized will succeed and will return true
228  */
229 #if defined(__LINUX__)
230 TEST_F(CHPServerTest_btc, CHPIsInitializedSecure_SRC_P)
231 {
232     m_pchpHelper->initializeOC();
233     m_pchpHelper->initializeCHPSecure();
234     CommonUtil::waitInSecond(CHP_SLEEPTIME_MAX);
235     EXPECT_EQ(true, m_pchpHelper->isInitializedCHP());
236     m_pchpHelper->terminateCHP();
237 }
238 #endif
239
240 /**
241  * @since           2017-03-27
242  * @see             OCStackResult OCInit(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags);
243  * @see             bool CHPIsInitialized()
244  * @see             OCStackResult CHPInitialize(bool secure)
245  * @see             OCStackResult CHPTerminate()
246  * @objective       Test CHPIsInitialized function with secure build & Non Secure Initialization
247  * @target          bool CHPInitialize()
248  * @test_data       none
249  * @pre_condition   1. Call OCInit(NULL, 0, OC_SERVER)
250  *                  2. CHPInitialize with non secure argument
251  * @procedure       Call CHPIsInitialized
252  * @post_condition  Call CHPTerminate
253  * @expected        CHPIsInitialized will succeed and will return true
254  */
255 #if defined(__LINUX__)
256 TEST_F(CHPServerTest_btc, CHPIsInitializedNonSecure_SRC_P)
257 {
258     m_pchpHelper->initializeOC();
259     m_pchpHelper->initializeCHPNonSecure();
260     CommonUtil::waitInSecond(CHP_SLEEPTIME_MAX);
261     EXPECT_EQ(true, m_pchpHelper->isInitializedCHP());
262     m_pchpHelper->terminateCHP();
263 }
264 #endif