Merge test folder of test branch
[iotivity.git] / test / src / tc / pm / gtest / csdk / src / btc / PMCsdkCertTest.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 "PMCsdkHelper.h"
22 #include "PMCsdkCertHelper.h"
23 #include "PMCsdkUtilityHelper.h"
24
25 class PMCsdkCertTest_btc: public ::testing::Test
26 {
27 protected:
28
29     OCProvisionDev_t *m_UnownList;
30     OicSecAcl_t *m_Acl, *m_Acl1, *m_Acl2;
31     PMCsdkHelper m_PMHelper;
32     PMCsdkCertHelper m_PMCertHelper;
33
34     char* g_caKeyPem; /* Test CA private key */
35     char* g_caCertPem; /* Test CA certificate */
36     uint16_t g_caCredId = 0; /* ID of CA's OCF identity cert */
37
38     virtual void SetUp()
39     {
40         CommonTestUtil::runCommonTCSetUpPart();
41         CommonUtil::killApp(KILL_SERVERS);
42         CommonUtil::waitInSecond(DELAY_MEDIUM);
43         PMCsdkUtilityHelper::removeAllResFile();
44         CommonUtil::waitInSecond(DELAY_LONG);
45         CommonUtil::copyFile(ROOT_CERT_UNOWNED_BACKUP, ROOT_CERT);
46         CommonUtil::copyFile(JUSTWORKS_SERVER_CBOR_O1_UNOWNED_BACKUP, JUSTWORKS_SERVER_CBOR_O1);
47         CommonUtil::copyFile(CLIENT_CBOR_01_UNOWNED_BACKUP, CLIENT_CBOR_01);
48         CommonUtil::launchApp(JUSTWORKS_SERVER1);
49         CommonUtil::waitInSecond(DELAY_LONG);
50         m_UnownList = NULL;
51         g_caKeyPem = NULL;
52         g_caCertPem = NULL;
53
54         if (!m_PMHelper.initProvisionClient())
55         {
56             SET_FAILURE(m_PMHelper.getFailureMessage());
57             return;
58         }
59     }
60
61     virtual void TearDown()
62     {
63         CommonTestUtil::runCommonTCTearDownPart();
64         CommonUtil::killApp(KILL_SERVERS);
65     }
66 };
67
68 /**
69  * @since           2017-02-28
70  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
71  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
72  * @see             OCStackResult OCInitPM(const char* dbPath)
73  * @objective       Test OCRegisterTrustCertChainNotifier Positively
74  * @target          OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
75  * @test_data       Regular data for OCRegisterTrustCertChainNotifier
76  * @pre_condition   Start two justworks simulators
77  * @procedure       1. call OCRegisterPersistentStorageHandler
78  *                  2. call OCInit
79  *                  3. call OCInitPM
80  *                  4. call OCRegisterTrustCertChainNotifier
81  * @post_condition  None
82  * @expected        OCRegisterTrustCertChainNotifier will return OC_STACK_OK
83  */
84 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
85 TEST_F(PMCsdkCertTest_btc, RegisterTrustCertChainNotifier_SRC_RV_P)
86 {
87     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
88     {
89         SET_FAILURE(m_PMCertHelper.getFailureMessage());
90     }
91 }
92 #endif
93
94 /**
95  * @since           2017-02-28
96  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
97  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
98  * @see             OCStackResult OCInitPM(const char* dbPath)
99  * @objective       Test OCRegisterTrustCertChainNotifier Negatively with TrustCertChainChangeCB as NULL
100  * @target          OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
101  * @test_data       TrustCertChainChangeCB as NULL
102  * @pre_condition   Start two justworks simulators
103  * @procedure       1. call OCRegisterPersistentStorageHandler
104  *                  2. call OCInit
105  *                  3. call OCInitPM
106  *                  4. call OCRegisterTrustCertChainNotifier
107  * @post_condition  None
108  * @expected        OCRegisterTrustCertChainNotifier will return OC_STACK_OK
109  */
110 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
111 TEST_F(PMCsdkCertTest_btc, RegisterTrustCertChainNotifierCb_NV_N)
112 {
113     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, NULL, OC_STACK_OK))
114     {
115         SET_FAILURE(m_PMCertHelper.getFailureMessage());
116     }
117 }
118 #endif
119
120 /**
121  * @since           2017-02-28
122  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
123  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
124  * @see             OCStackResult OCInitPM(const char* dbPath)
125  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
126  * @objective       Test OCRemoveTrustCertChainNotifier positively
127  * @target          void OCRemoveTrustCertChainNotifier(void)
128  * @test_data       Regular data for OCRegisterTrustCertChainNotifier
129  * @pre_condition   Start two justworks simulators
130  * @procedure       1. call OCRegisterPersistentStorageHandler
131  *                  2. call OCInit
132  *                  3. call OCInitPM
133  *                  4. call OCRegisterTrustCertChainNotifier
134  *                  5. call OCRemoveTrustCertChainNotifier
135  * @post_condition  None
136  * @expected        OCRemoveTrustCertChainNotifier will throw no exception
137  */
138 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
139 TEST_F(PMCsdkCertTest_btc, RemoveTrustCertChainNotifier_SRC_RV_P)
140 {
141     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
142     {
143         SET_FAILURE(m_PMCertHelper.getFailureMessage());
144     }
145
146     if (!m_PMCertHelper.removeTrustCertChainNotifier())
147     {
148         SET_FAILURE(m_PMCertHelper.getFailureMessage());
149     }
150 }
151 #endif
152
153 /**
154  * @since           2017-02-28
155  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
156  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
157  * @see             OCStackResult OCInitPM(const char* dbPath)
158  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
159  * @objective       Test OCSaveTrustCertChain positively
160  * @target          OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
161  * @test_data       Regular data for OCRegisterTrustCertChainNotifier
162  * @pre_condition   Start two justworks simulators
163  * @procedure       1. call OCRegisterPersistentStorageHandler
164  *                  2. call OCInit
165  *                  3. call OCInitPM
166  *                  4. call OCRegisterTrustCertChainNotifier
167  *                  5. call OCSaveTrustCertChain
168  * @post_condition  None
169  * @expected        OCSaveTrustCertChain will return OC_STACK_OK
170  */
171 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
172 TEST_F(PMCsdkCertTest_btc, SaveTrustCertChain_SRC_RV_P)
173 {
174     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
175     {
176         SET_FAILURE(m_PMCertHelper.getFailureMessage());
177     }
178
179     ByteArray_t g_trustCertChainArray =
180     {   0, 0};
181
182     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
183
184     uint16_t g_credId = 0;
185     if (!m_PMCertHelper.saveTrustCertChain(g_trustCertChainArray.data, g_trustCertChainArray.len,
186                     OIC_ENCODING_PEM, &g_credId, OC_STACK_OK))
187     {
188         SET_FAILURE(m_PMCertHelper.getFailureMessage());
189     }
190 }
191 #endif
192
193 /**
194  * @since           2017-02-28
195  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
196  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
197  * @see             OCStackResult OCInitPM(const char* dbPath)
198  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
199  * @objective       Test OCSaveTrustCertChain negatively with trustCertChain as NULL
200  * @target          OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
201  * @test_data       trustCertChain as NULL
202  * @pre_condition   Start two justworks simulators
203  * @procedure       1. call OCRegisterPersistentStorageHandler
204  *                  2. call OCInit
205  *                  3. call OCInitPM
206  *                  4. call OCRegisterTrustCertChainNotifier
207  *                  5. call OCSaveTrustCertChain
208  * @post_condition  None
209  * @expected        OCSaveTrustCertChain will return OC_STACK_INVALID_PARAM
210  */
211 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
212 TEST_F(PMCsdkCertTest_btc, SaveTrustCertChainCrtChain_NV_N)
213 {
214     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
215     {
216         SET_FAILURE(m_PMCertHelper.getFailureMessage());
217     }
218
219     ByteArray_t g_trustCertChainArray =
220     {   0, 0};
221
222     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
223
224     uint16_t g_credId = 0;
225     if (!m_PMCertHelper.saveTrustCertChain(NULL, g_trustCertChainArray.len,
226                     OIC_ENCODING_PEM, &g_credId, OC_STACK_INVALID_PARAM))
227     {
228         SET_FAILURE(m_PMCertHelper.getFailureMessage());
229     }
230 }
231 #endif
232
233 /**
234  * @since           2017-02-28
235  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
236  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
237  * @see             OCStackResult OCInitPM(const char* dbPath)
238  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
239  * @objective       Test OCSaveTrustCertChain negatively with chainSize as -1
240  * @target          OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
241  * @test_data       chainSize as -1
242  * @pre_condition   Start two justworks simulators
243  * @procedure       1. call OCRegisterPersistentStorageHandler
244  *                  2. call OCInit
245  *                  3. call OCInitPM
246  *                  4. call OCRegisterTrustCertChainNotifier
247  *                  5. call OCSaveTrustCertChain
248  * @post_condition  None
249  * @expected        OCSaveTrustCertChain will return OC_STACK_NO_MEMORY
250  */
251 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
252 TEST_F(PMCsdkCertTest_btc, SaveTrustCertChainCrtChainLen_NV_N)
253 {
254     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
255     {
256         SET_FAILURE(m_PMCertHelper.getFailureMessage());
257     }
258
259     ByteArray_t g_trustCertChainArray =
260     {   0, 0};
261
262     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
263
264     uint16_t g_credId = 0;
265     if (!m_PMCertHelper.saveTrustCertChain(g_trustCertChainArray.data, -1,
266                     OIC_ENCODING_PEM, &g_credId, OC_STACK_NO_MEMORY))
267     {
268         SET_FAILURE(m_PMCertHelper.getFailureMessage());
269     }
270 }
271 #endif
272
273 /**
274  * @since           2017-02-28
275  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
276  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
277  * @see             OCStackResult OCInitPM(const char* dbPath)
278  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
279  * @see             OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
280  * @objective       Test OCReadTrustCertChain positively with regular data
281  * @target          OCStackResult OCReadTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize)
282  * @test_data       chainSize as NULL
283  * @pre_condition   Start two justworks simulators
284  * @procedure       1. call OCRegisterPersistentStorageHandler
285  *                  2. call OCInit
286  *                  3. call OCInitPM
287  *                  4. call OCRegisterTrustCertChainNotifier
288  *                  5. call OCSaveTrustCertChain
289  *                  6. call OCReadTrustCertChain
290  * @post_condition  None
291  * @expected        OCReadTrustCertChain will return OC_STACK_OK
292  */
293 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
294 TEST_F(PMCsdkCertTest_btc, ReadTrustCertChain_SRC_RV_P)
295 {
296     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
297     {
298         SET_FAILURE(m_PMCertHelper.getFailureMessage());
299     }
300
301     ByteArray_t g_trustCertChainArray =
302     {   0, 0};
303
304     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
305
306     uint16_t g_credId = 0;
307     if (!m_PMCertHelper.saveTrustCertChain(g_trustCertChainArray.data, g_trustCertChainArray.len,
308                     OIC_ENCODING_PEM, &g_credId, OC_STACK_OK))
309     {
310         SET_FAILURE(m_PMCertHelper.getFailureMessage());
311     }
312
313     ByteArray_t g_trustCertChainArray1 =
314     {   0, 0};
315
316     if (!m_PMCertHelper.readTrustCertChain(g_credId, &g_trustCertChainArray1.data, &g_trustCertChainArray1.len, OC_STACK_OK))
317     {
318         SET_FAILURE(m_PMCertHelper.getFailureMessage());
319     }
320 }
321 #endif
322
323 /**
324  * @since           2017-02-28
325  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
326  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
327  * @see             OCStackResult OCInitPM(const char* dbPath)
328  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
329  * @see             OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
330  * @objective       Test OCReadTrustCertChain positively with credId as -1
331  * @target          OCStackResult OCReadTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize)
332  * @test_data       credId as -1
333  * @pre_condition   Start two justworks simulators
334  * @procedure       1. call OCRegisterPersistentStorageHandler
335  *                  2. call OCInit
336  *                  3. call OCInitPM
337  *                  4. call OCRegisterTrustCertChainNotifier
338  *                  5. call OCSaveTrustCertChain
339  *                  6. call OCReadTrustCertChain
340  * @post_condition  None
341  * @expected        OCReadTrustCertChain will return OC_STACK_ERROR
342  */
343 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
344 TEST_F(PMCsdkCertTest_btc, ReadTrustCertChainCredId_LOBV_N)
345 {
346     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
347     {
348         SET_FAILURE(m_PMCertHelper.getFailureMessage());
349     }
350
351     ByteArray_t g_trustCertChainArray =
352     {   0, 0};
353
354     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
355
356     uint16_t g_credId = 0;
357     if (!m_PMCertHelper.saveTrustCertChain(g_trustCertChainArray.data, g_trustCertChainArray.len,
358                     OIC_ENCODING_PEM, &g_credId, OC_STACK_OK))
359     {
360         SET_FAILURE(m_PMCertHelper.getFailureMessage());
361     }
362
363     ByteArray_t g_trustCertChainArray1 =
364     {   0, 0};
365
366     if (!m_PMCertHelper.readTrustCertChain(-1, &g_trustCertChainArray1.data, &g_trustCertChainArray1.len, OC_STACK_ERROR))
367     {
368         SET_FAILURE(m_PMCertHelper.getFailureMessage());
369     }
370 }
371 #endif
372
373 /**
374  * @since           2017-02-28
375  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
376  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
377  * @see             OCStackResult OCInitPM(const char* dbPath)
378  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
379  * @see             OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
380  * @objective       Test OCReadTrustCertChain positively with trustCertChain as NULL
381  * @target          OCStackResult OCReadTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize)
382  * @test_data       trustCertChain as NULL
383  * @pre_condition   Start two justworks simulators
384  * @procedure       1. call OCRegisterPersistentStorageHandler
385  *                  2. call OCInit
386  *                  3. call OCInitPM
387  *                  4. call OCRegisterTrustCertChainNotifier
388  *                  5. call OCSaveTrustCertChain
389  *                  6. call OCReadTrustCertChain
390  * @post_condition  None
391  * @expected        OCReadTrustCertChain will return OC_STACK_INVALID_PARAM
392  */
393 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
394 TEST_F(PMCsdkCertTest_btc, ReadTrustCertChainCertChain_NV_N)
395 {
396     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
397     {
398         SET_FAILURE(m_PMCertHelper.getFailureMessage());
399     }
400
401     ByteArray_t g_trustCertChainArray =
402     {   0, 0};
403
404     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
405
406     uint16_t g_credId = 0;
407     if (!m_PMCertHelper.saveTrustCertChain(g_trustCertChainArray.data, g_trustCertChainArray.len,
408                     OIC_ENCODING_PEM, &g_credId, OC_STACK_OK))
409     {
410         SET_FAILURE(m_PMCertHelper.getFailureMessage());
411     }
412
413     ByteArray_t g_trustCertChainArray1 =
414     {   0, 0};
415
416     if (!m_PMCertHelper.readTrustCertChain(g_credId, NULL, &g_trustCertChainArray1.len, OC_STACK_INVALID_PARAM))
417     {
418         SET_FAILURE(m_PMCertHelper.getFailureMessage());
419     }
420 }
421 #endif
422
423 /**
424  * @since           2017-02-28
425  * @see             OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
426  * @see             OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
427  * @see             OCStackResult OCInitPM(const char* dbPath)
428  * @see             OCStackResult OCRegisterTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB)
429  * @see             OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize, OicEncodingType_t encodingType, uint16_t *credId)
430  * @objective       Test OCReadTrustCertChain positively with chainSize as NULL
431  * @target          OCStackResult OCReadTrustCertChain(uint16_t credId, uint8_t **trustCertChain, size_t *chainSize)
432  * @test_data       chainSize as NULL
433  * @pre_condition   Start two justworks simulators
434  * @procedure       1. call OCRegisterPersistentStorageHandler
435  *                  2. call OCInit
436  *                  3. call OCInitPM
437  *                  4. call OCRegisterTrustCertChainNotifier
438  *                  5. call OCSaveTrustCertChain
439  *                  6. call OCReadTrustCertChain
440  * @post_condition  None
441  * @expected        OCReadTrustCertChain will return OC_STACK_INVALID_PARAM
442  */
443 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
444 TEST_F(PMCsdkCertTest_btc, ReadTrustCertChainCertChainSize_NV_N)
445 {
446     if (!m_PMCertHelper.registerTrustCertChainNotifier((void*)CTX_PROV_TRUST_CERT, PMCsdkCertHelper::trustCertChainChangeCB, OC_STACK_OK))
447     {
448         SET_FAILURE(m_PMCertHelper.getFailureMessage());
449     }
450
451     ByteArray_t g_trustCertChainArray =
452     {   0, 0};
453
454     m_PMCertHelper.readFile(ROOT_CERT_FILE, (OCByteString *) &g_trustCertChainArray);
455
456     uint16_t g_credId = 0;
457     if (!m_PMCertHelper.saveTrustCertChain(g_trustCertChainArray.data, g_trustCertChainArray.len,
458                     OIC_ENCODING_PEM, &g_credId, OC_STACK_OK))
459     {
460         SET_FAILURE(m_PMCertHelper.getFailureMessage());
461     }
462
463     ByteArray_t g_trustCertChainArray1 =
464     {   0, 0};
465
466     if (!m_PMCertHelper.readTrustCertChain(g_credId, &g_trustCertChainArray1.data, NULL, OC_STACK_INVALID_PARAM))
467     {
468         SET_FAILURE(m_PMCertHelper.getFailureMessage());
469     }
470 }
471 #endif