Merge test folder of test branch
[iotivity.git] / test / src / tc / pm / gtest / cpp / src / btc / PMCppCertTest.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  *      LICENSE-2.0" target="_blank">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 "PMCppCertHelper.h"
23 #include "CommonTestUtil.h"
24
25 class PMCppCertTest_btc: public ::testing::Test
26 {
27 protected:
28     PMCppHelper m_PMCppHelper;
29     PMCppCertHelper m_PMCppCertHelper;
30     DeviceList_t m_UnownedDevList, m_OwnedDevList;
31     OicSecAcl_t *m_acl1, *m_acl2;
32
33     virtual void SetUp()
34     {
35         CommonTestUtil::runCommonTCSetUpPart();
36         CommonUtil::killApp(KILL_SERVERS);
37         CommonUtil::waitInSecond(DELAY_MEDIUM);
38         PMCppUtilityHelper::removeAllResFile();
39         CommonUtil::copyFile(JUSTWORKS_SERVER_CBOR_O1_UNOWNED_BACKUP, JUSTWORKS_SERVER_CBOR_O1);
40         CommonUtil::copyFile(JUSTWORKS_SERVER_CBOR_O2_UNOWNED_BACKUP, JUSTWORKS_SERVER_CBOR_O2);
41         CommonUtil::copyFile(RANDOMPIN_SERVER_CBOR_01_UNOWNED_BACKUP, RANDOMPIN_SERVER_CBOR_01);
42         CommonUtil::copyFile(MV_JUSTWORKS_CBOR_01_UNOWNED_BACKUP, MV_JUSTWORKS_CBOR_01);
43         CommonUtil::copyFile(CLIENT_CBOR_01_UNOWNED_BACKUP, CLIENT_CBOR_01);
44         CommonUtil::copyFile(ROOT_CERT_UNOWNED_BACKUP, ROOT_CERT);
45         CommonUtil::waitInSecond(DELAY_LONG);
46         m_UnownedDevList.clear();
47         m_OwnedDevList.clear();
48         m_acl1 = NULL;
49         m_acl2 = NULL;
50
51         if(!m_PMCppCertHelper.provisionInit())
52         {
53             SET_FAILURE(m_PMCppHelper.getFailureMessage());
54             return;
55         }
56     }
57
58     virtual void TearDown()
59     {
60         CommonTestUtil::runCommonTCTearDownPart();
61         CommonUtil::killApp(KILL_SERVERS);
62     }
63 };
64
65 /**
66  * @since           2016-02-28
67  * @see             static OCStackResult provisionInit(const std::string& dbPath)
68  * @see             static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
69  * @objective       test saveTrustCertChain positively
70  * @target          static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
71  * @test_data       Regular data for saveTrustCertChain
72  * @pre_condition   start two justworks simulators
73  * @procedure       1. call provisionInit
74  *                  2. call registerTrustCertChangeNotifier
75  *                  3. call saveTrustCertChain
76  * @post_condition  None
77  * @expected        saveTrustCertChain will return OC_STACK_OK
78  */
79 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
80 TEST_F(PMCppCertTest_btc, SaveTrustCertChain_SRC_RV_P)
81 {
82     if (!m_PMCppCertHelper.registerTrustCertChangeNotifier(PMCppCertHelper::certChainCB, OC_STACK_OK))
83     {
84         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
85     }
86
87     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
88
89     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
90                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_OK))
91     {
92         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
93     }
94 }
95 #endif
96
97 /**
98  * @since           2017-02-28
99  * @see             static OCStackResult provisionInit(const std::string& dbPath)
100  * @objective       test saveTrustCertChain negatively with credId as NULL
101  * @target          static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
102  * @test_data       credId as NULL
103  * @pre_condition   None
104  * @procedure       1. call provisionInit
105  *                  2. call saveTrustCertChain
106  * @post_condition  None
107  * @expected        saveTrustCertChain will return OC_STACK_INVALID_PARAM
108  */
109 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
110 TEST_F(PMCppCertTest_btc, SaveTrustCertChainCredId_NV_N)
111 {
112     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
113
114     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
115                     OIC_ENCODING_PEM, NULL, OC_STACK_INVALID_PARAM))
116     {
117         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
118     }
119 }
120 #endif
121
122 /**
123  * @since           2017-02-28
124  * @see             static OCStackResult provisionInit(const std::string& dbPath)
125  * @objective       test saveTrustCertChain negatively with chainSize as -1
126  * @target          static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
127  * @test_data       chainSize as -1
128  * @pre_condition   None
129  * @procedure       1. call provisionInit
130  *                  2. call saveTrustCertChain
131  * @post_condition  None
132  * @expected        saveTrustCertChain will return OC_STACK_NO_MEMORY
133  */
134 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
135 TEST_F(PMCppCertTest_btc, SaveTrustCertChainCertChainLen_LOBV_N)
136 {
137     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
138
139     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, -1,
140                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_NO_MEMORY))
141     {
142         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
143     }
144 }
145 #endif
146
147 /**
148  * @since           2017-02-28
149  * @see             static OCStackResult provisionInit(const std::string& dbPath)
150  * @objective       test saveTrustCertChain negatively with trustCertChain as NULL
151  * @target          static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
152  * @test_data       trustCertChain as NULL
153  * @pre_condition   None
154  * @procedure       1. call provisionInit
155  *                  2. call saveTrustCertChain
156  * @post_condition  None
157  * @expected        saveTrustCertChain will return OC_STACK_INVALID_PARAM
158  */
159 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
160 TEST_F(PMCppCertTest_btc, SaveTrustCertChainCertChain_NV_N)
161 {
162     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
163
164     if (!m_PMCppCertHelper.saveTrustCertChain(NULL, PMCppCertHelper::s_trustCertChainArray.len,
165                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_INVALID_PARAM))
166     {
167         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
168     }
169 }
170 #endif
171
172 /**
173  * @since           2017-02-28
174  * @see             static OCStackResult provisionInit(const std::string& dbPath)
175  * @see             static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
176  * @objective       test readTrustCertChain positively
177  * @target          static OCStackResult readTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize);
178  * @test_data       trustCertChain as NULL
179  * @pre_condition   None
180  * @procedure       1. call provisionInit
181  *                  2. call saveTrustCertChain
182  *                  3. call readTrustCertChain
183  * @post_condition  None
184  * @expected        readTrustCertChain will return OC_STACK_OK
185  */
186 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
187 TEST_F(PMCppCertTest_btc, ReadTrustCertChain_SRC_RV_P)
188 {
189     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
190
191     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
192                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_OK))
193     {
194         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
195     }
196
197     ByteArray_t trustCertChainArray =
198     {   0, 0};
199
200     if (!m_PMCppCertHelper.readTrustCertChain(PMCppCertHelper::s_credId, &trustCertChainArray.data,
201                     &trustCertChainArray.len, OC_STACK_OK))
202     {
203         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
204     }
205 }
206 #endif
207
208 /**
209  * @since           2017-02-28
210  * @see             static OCStackResult provisionInit(const std::string& dbPath)
211  * @see             static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
212  * @objective       test readTrustCertChain negatively as credId as -1
213  * @target          static OCStackResult readTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize);
214  * @test_data       credId as -1
215  * @pre_condition   None
216  * @procedure       1. call provisionInit
217  *                  2. call saveTrustCertChain
218  *                  3. call readTrustCertChain
219  * @post_condition  None
220  * @expected        readTrustCertChain will return OC_STACK_ERROR
221  */
222 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
223 TEST_F(PMCppCertTest_btc, ReadTrustCertChainCredId_LOBV_N)
224 {
225     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
226
227     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
228                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_OK))
229     {
230         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
231     }
232
233     ByteArray_t trustCertChainArray =
234     {   0, 0};
235
236     if (!m_PMCppCertHelper.readTrustCertChain(-1, &trustCertChainArray.data,
237                     &trustCertChainArray.len, OC_STACK_ERROR))
238     {
239         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
240     }
241 }
242 #endif
243
244 /**
245  * @since           2017-02-28
246  * @see             static OCStackResult provisionInit(const std::string& dbPath)
247  * @see             static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
248  * @objective       test readTrustCertChain negatively with trustCertChain as NULL
249  * @target          static OCStackResult readTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize);
250  * @test_data       trustCertChain as NULL
251  * @pre_condition   None
252  * @procedure       1. call provisionInit
253  *                  2. call saveTrustCertChain
254  *                  3. call readTrustCertChain
255  * @post_condition  None
256  * @expected        readTrustCertChain will return OC_STACK_INVALID_PARAM
257  */
258 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
259 TEST_F(PMCppCertTest_btc, ReadTrustCertChainChainArray_NV_N)
260 {
261     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
262
263     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
264                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_OK))
265     {
266         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
267     }
268
269     ByteArray_t trustCertChainArray =
270     {   0, 0};
271
272     if (!m_PMCppCertHelper.readTrustCertChain(PMCppCertHelper::s_credId, NULL,
273                     &trustCertChainArray.len, OC_STACK_INVALID_PARAM))
274     {
275         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
276     }
277 }
278 #endif
279
280 /**
281  * @since           2017-02-28
282  * @see             static OCStackResult provisionInit(const std::string& dbPath)
283  * @see             static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
284  * @objective       test readTrustCertChain negatively with chainSize as NULL
285  * @target          static OCStackResult readTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize);
286  * @test_data       chainSize as NULL
287  * @pre_condition   None
288  * @procedure       1. call provisionInit
289  *                  2. call saveTrustCertChain
290  *                  3. call readTrustCertChain
291  * @post_condition  None
292  * @expected        readTrustCertChain will return OC_STACK_INVALID_PARAM
293  */
294 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
295 TEST_F(PMCppCertTest_btc, ReadTrustCertChainChainLen_NV_N)
296 {
297     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
298
299     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
300                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_OK))
301     {
302         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
303     }
304
305     ByteArray_t trustCertChainArray =
306     {   0, 0};
307
308     if (!m_PMCppCertHelper.readTrustCertChain(PMCppCertHelper::s_credId, &trustCertChainArray.data,
309                     NULL, OC_STACK_INVALID_PARAM))
310     {
311         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
312     }
313 }
314 #endif
315
316 /**
317  * @since           2016-02-28
318  * @see             static OCStackResult provisionInit(const std::string& dbPath)
319  * @objective       test registerTrustCertChangeNotifier positively
320  * @target          static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
321  * @test_data       Regular data for registerTrustCertChangeNotifier
322  * @pre_condition   None
323  * @procedure       1. call provisionInit
324  *                  2. call registerTrustCertChangeNotifier
325  * @post_condition  None
326  * @expected        registerTrustCertChangeNotifier will return OC_STACK_OK
327  */
328 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
329 TEST_F(PMCppCertTest_btc, RegisterTrustCertChangeNotifier_SRC_RV_P)
330 {
331     if (!m_PMCppCertHelper.registerTrustCertChangeNotifier(PMCppCertHelper::certChainCB, OC_STACK_OK))
332     {
333         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
334     }
335
336     PMCppUtilityHelper::readFile(ROOT_CERT_FILE, (OCByteString *) &PMCppCertHelper::s_trustCertChainArray);
337
338     if (!m_PMCppCertHelper.saveTrustCertChain(PMCppCertHelper::s_trustCertChainArray.data, PMCppCertHelper::s_trustCertChainArray.len,
339                     OIC_ENCODING_PEM, &PMCppCertHelper::s_credId, OC_STACK_OK))
340     {
341         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
342     }
343 }
344 #endif
345
346 /**
347  * @since           2016-02-28
348  * @see             static OCStackResult provisionInit(const std::string& dbPath)
349  * @objective       test registerTrustCertChangeNotifier negatively calling it multiple time
350  * @target          static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
351  * @test_data       Regular data for registerTrustCertChangeNotifier
352  * @pre_condition   None
353  * @procedure       1. call provisionInit
354  *                  2. call registerTrustCertChangeNotifier
355  *                  3. call registerTrustCertChangeNotifier
356  * @post_condition  None
357  * @expected        registerTrustCertChangeNotifier will return OC_STACK_ERROR
358  */
359 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
360 TEST_F(PMCppCertTest_btc, RegisterTrustCertChangeNotifierMultipleTime_EG_N)
361 {
362     if (!m_PMCppCertHelper.registerTrustCertChangeNotifier(PMCppCertHelper::certChainCB, OC_STACK_OK))
363     {
364         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
365     }
366
367     if (!m_PMCppCertHelper.registerTrustCertChangeNotifier(PMCppCertHelper::certChainCB, OC_STACK_ERROR))
368     {
369         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
370     }
371 }
372 #endif
373
374 /**
375  * @since           2016-02-28
376  * @see             static OCStackResult provisionInit(const std::string& dbPath)
377  * @objective       test registerTrustCertChangeNotifier negatively with CertChainCallBack as NULL
378  * @target          static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
379  * @test_data       CertChainCallBack as NULL
380  * @pre_condition   None
381  * @procedure       1. call provisionInit
382  *                  2. call registerTrustCertChangeNotifier
383  * @post_condition  None
384  * @expected        registerTrustCertChangeNotifier will return OC_STACK_INVALID_CALLBACK
385  */
386 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
387 TEST_F(PMCppCertTest_btc, RegisterTrustCertChangeNotifierCb_NV_N)
388 {
389     if (!m_PMCppCertHelper.registerTrustCertChangeNotifier(NULL, OC_STACK_INVALID_CALLBACK))
390     {
391         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
392     }
393 }
394 #endif
395
396 /**
397  * @since           2016-02-28
398  * @see             static OCStackResult provisionInit(const std::string& dbPath)
399  * @see             static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
400  * @objective       test removeTrustCertChangeNotifier positively
401  * @target          static OCStackResult removeTrustCertChangeNotifier
402  * @test_data       None
403  * @pre_condition   None
404  * @procedure       1. call provisionInit
405  *                  2. call registerTrustCertChangeNotifier
406  *                  3. call removeTrustCertChangeNotifier
407  * @post_condition  None
408  * @expected        removeTrustCertChangeNotifier will return OC_STACK_OK
409  */
410 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
411 TEST_F(PMCppCertTest_btc, RemoveTrustCertChangeNotifier_SRC_P)
412 {
413     if (!m_PMCppCertHelper.registerTrustCertChangeNotifier(PMCppCertHelper::certChainCB, OC_STACK_OK))
414     {
415         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
416     }
417
418     if (!m_PMCppCertHelper.removeTrustCertChangeNotifier())
419     {
420         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
421     }
422 }
423 #endif
424
425 /**
426  * @since           2016-02-28
427  * @see             static OCStackResult provisionInit(const std::string& dbPath)
428  * @see             static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
429  * @objective       test removeTrustCertChangeNotifier positively without registering CertChainCallBack
430  * @target          static OCStackResult removeTrustCertChangeNotifier
431  * @test_data       None
432  * @pre_condition   None
433  * @procedure       1. call provisionInit
434  *                  2. call registerTrustCertChangeNotifier
435  *                  3. call removeTrustCertChangeNotifier
436  * @post_condition  None
437  * @expected        removeTrustCertChangeNotifier will return OC_STACK_OK
438  */
439 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
440 TEST_F(PMCppCertTest_btc, RemoveTrustCertChangeNotifier_RV_P)
441 {
442     if (!m_PMCppCertHelper.removeTrustCertChangeNotifier())
443     {
444         SET_FAILURE(m_PMCppCertHelper.getFailureMessage());
445     }
446 }
447 #endif