IOT-1583: Removing /W3 warning from resource/csdk/security.
[iotivity.git] / resource / csdk / security / provisioning / unittest / secureresourceprovider.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 #include "gtest/gtest.h"
21 #include "secureresourceprovider.h"
22
23 static OicSecAcl_t acl;
24 static OCProvisionDev_t pDev1;
25 static OCProvisionDev_t pDev2;
26 static OicSecCredType_t credType = SYMMETRIC_PAIR_WISE_KEY;
27 static OCProvisionDev_t selectedDeviceInfo;
28 static OicSecPconf_t pconf;
29 static OicSecOxm_t oicSecDoxmJustWorks = OIC_JUST_WORKS;
30 static OicSecOxm_t oicSecDoxmRandomPin = OIC_RANDOM_DEVICE_PIN;
31 static unsigned short timeout = 60;
32 static OicSecDoxm_t defaultDoxm1 =
33 {
34     NULL,                   /* OicUrn_t *oxmType */
35     0,                      /* size_t oxmTypeLen */
36     &oicSecDoxmJustWorks,  /* uint16_t *oxm */
37     1,                      /* size_t oxmLen */
38     OIC_JUST_WORKS,         /* uint16_t oxmSel */
39     SYMMETRIC_PAIR_WISE_KEY,/* OicSecCredType_t sct */
40     false,                  /* bool owned */
41     {{0}},            /* OicUuid_t deviceID */
42     false,                  /* bool dpc */
43     {{0}},            /* OicUuid_t owner */
44 };
45
46 static OicSecDoxm_t defaultDoxm2 =
47 {
48     NULL,                   /* OicUrn_t *oxmType */
49     0,                      /* size_t oxmTypeLen */
50     &oicSecDoxmRandomPin,  /* uint16_t *oxm */
51     1,                      /* size_t oxmLen */
52     OIC_RANDOM_DEVICE_PIN,         /* uint16_t oxmSel */
53     SYMMETRIC_PAIR_WISE_KEY,/* OicSecCredType_t sct */
54     false,                  /* bool owned */
55     {{0}},            /* OicUuid_t deviceID */
56     false,                  /* bool dpc */
57     {{0}},            /* OicUuid_t owner */
58 };
59
60 static void provisioningCB (void* UNUSED1, size_t UNUSED2, OCProvisionResult_t *UNUSED3, bool UNUSED4)
61 {
62     //dummy callback
63     (void) UNUSED1;
64     (void) UNUSED2;
65     (void) UNUSED3;
66     (void) UNUSED4;
67 }
68
69 TEST(SRPProvisionACLTest, NullDeviceInfo)
70 {
71     pDev1.doxm = &defaultDoxm1;
72     uint8_t deviceId1[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64};
73     memcpy(pDev1.doxm->deviceID.id, deviceId1, sizeof(deviceId1));
74
75     pDev2.doxm = &defaultDoxm2;
76     uint8_t deviceId2[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x63};
77     memcpy(pDev2.doxm->deviceID.id, deviceId2, sizeof(deviceId2));
78
79     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionACL(NULL, NULL, &acl, &provisioningCB));
80 }
81
82 TEST(SRPProvisionACLTest, NullCallback)
83 {
84     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPProvisionACL(NULL, &pDev1, &acl, NULL));
85 }
86
87 TEST(SRPProvisionACLTest, NullACL)
88 {
89     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionACL(NULL, &pDev1, NULL, &provisioningCB));
90 }
91
92 TEST(SRPProvisionCredentialsTest, NullDevice1)
93 {
94     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionCredentials(NULL, credType,
95                                                               OWNER_PSK_LENGTH_128, NULL,
96                                                               &pDev2, &provisioningCB));
97 }
98
99 TEST(SRPProvisionCredentialsTest, SamelDeviceId)
100 {
101     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionCredentials(NULL, credType,
102                                                               OWNER_PSK_LENGTH_128, &pDev1,
103                                                               &pDev1, &provisioningCB));
104 }
105
106 TEST(SRPProvisionCredentialsTest, NullCallback)
107 {
108     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPProvisionCredentials(NULL, credType,
109                                                                  OWNER_PSK_LENGTH_128,
110                                                                  &pDev1, &pDev2, NULL));
111 }
112
113 TEST(SRPProvisionCredentialsTest, InvalidKeySize)
114 {
115     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionCredentials(NULL, credType,
116                                                                 0, &pDev1, &pDev2,
117                                                                 &provisioningCB));
118 }
119
120 TEST(SRPUnlinkDevicesTest, NullDevice1)
121 {
122     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPUnlinkDevices(NULL, NULL, &pDev2, provisioningCB));
123 }
124
125 TEST(SRPUnlinkDevicesTest, NullDevice2)
126 {
127     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPUnlinkDevices(NULL, &pDev1, NULL, provisioningCB));
128 }
129
130 TEST(SRPUnlinkDevicesTest, SamelDeviceId)
131 {
132     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPUnlinkDevices(NULL, &pDev1, &pDev1, provisioningCB));
133 }
134
135 TEST(SRPUnlinkDevicesTest, NullCallback)
136 {
137     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPUnlinkDevices(NULL, &pDev1, &pDev2, NULL));
138 }
139
140 TEST(SRPRemoveDeviceTest, NullTargetDevice)
141 {
142     unsigned short waitTime = 10 ;
143     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPRemoveDevice(NULL, waitTime, NULL, provisioningCB));
144 }
145
146 TEST(SRPRemoveDeviceTest, NullResultCallback)
147 {
148     unsigned short waitTime = 10;
149     OCProvisionDev_t dev1;
150     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPRemoveDevice(NULL, waitTime, &dev1, NULL));
151 }
152
153 TEST(SRPRemoveDeviceTest, ZeroWaitTime)
154 {
155     OCProvisionDev_t dev1;
156     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPRemoveDevice(NULL, 0, &dev1, NULL));
157 }
158
159 TEST(SRPProvisionDirectPairingTest, NullselectedDeviceInfo)
160 {
161     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionDirectPairing(NULL, NULL, &pconf, &provisioningCB));
162 }
163
164 TEST(SRPProvisionDirectPairingTest, Nullpconf)
165 {
166     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionDirectPairing(NULL, &selectedDeviceInfo, NULL, &provisioningCB));
167 }
168
169 TEST(SRPProvisionDirectPairingTest, Nullcallback)
170 {
171     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPProvisionDirectPairing(NULL, &selectedDeviceInfo, &pconf, NULL));
172 }
173
174 const char *SECURE_RESOURCE_PROVIDER_TEST_FILE_NAME = "secureresourceprovider.dat";
175 OCPersistentStorage ps = { NULL, NULL, NULL, NULL, NULL};
176
177 static FILE* TestFopen(const char *path, const char *mode)
178 {
179     if (0 == strcmp(path, OC_SECURITY_DB_DAT_FILE_NAME))
180     {
181         return fopen(SECURE_RESOURCE_PROVIDER_TEST_FILE_NAME, mode);
182     }
183     else
184     {
185         return fopen(path, mode);
186     }
187 }
188
189 void SetPersistentHandler(OCPersistentStorage *ps)
190 {
191     if(ps)
192     {
193         ps->open = TestFopen;
194         ps->read = fread;
195         ps->write = fwrite;
196         ps->close = fclose;
197         ps->unlink = remove;
198     }
199 }
200
201 class SRPTest : public ::testing::Test
202 {
203 public:
204     static void SetUpTestCase()
205     {
206         SetPersistentHandler(&ps);
207         OCStackResult res = OCRegisterPersistentStorageHandler(&ps);
208         ASSERT_TRUE(res == OC_STACK_OK);
209     }
210
211     static void TearDownTestCase()
212     {
213     }
214
215     static const ByteArray g_caPublicKey;
216
217     static const ByteArray g_derCode ;
218
219     static ByteArray g_serNum;
220 };
221
222 static uint8_t certData[] = {
223         0x30, 0x82, 0x02, 0x39, 0x30, 0x82, 0x01, 0xdf, 0x02, 0x01, 0x01, 0x30, 0x0a, 0x06, 0x08, 0x2a,
224         0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x7c, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
225         0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c,
226         0x09, 0x53, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03,
227         0x55, 0x04, 0x07, 0x0c, 0x08, 0x53, 0x6f, 0x6d, 0x65, 0x63, 0x69, 0x74, 0x79, 0x31, 0x0b, 0x30,
228         0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x42, 0x42, 0x31, 0x16, 0x30, 0x14, 0x06, 0x03,
229         0x55, 0x04, 0x0b, 0x0c, 0x0d, 0x53, 0x65, 0x71, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x50, 0x61,
230         0x72, 0x74, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x02, 0x6f, 0x62, 0x31,
231         0x14, 0x30, 0x12, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x05,
232         0x6f, 0x62, 0x40, 0x62, 0x62, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x36, 0x30, 0x38, 0x31, 0x35, 0x31,
233         0x33, 0x31, 0x31, 0x31, 0x37, 0x5a, 0x17, 0x0d, 0x31, 0x39, 0x30, 0x35, 0x31, 0x32, 0x31, 0x33,
234         0x31, 0x31, 0x31, 0x37, 0x5a, 0x30, 0x81, 0xd4, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
235         0x06, 0x13, 0x02, 0x55, 0x41, 0x31, 0x0c, 0x30, 0x0a, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x03,
236         0x41, 0x73, 0x64, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x06, 0x47, 0x6f,
237         0x74, 0x68, 0x61, 0x6d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x5a,
238         0x5a, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x08, 0x42, 0x65, 0x61, 0x6d,
239         0x54, 0x65, 0x61, 0x6d, 0x31, 0x1c, 0x30, 0x1a, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
240         0x01, 0x09, 0x01, 0x16, 0x0d, 0x72, 0x61, 0x69, 0x6c, 0x40, 0x6d, 0x61, 0x69, 0x6c, 0x2e, 0x63,
241         0x6f, 0x6d, 0x31, 0x32, 0x30, 0x30, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x29, 0x75, 0x75, 0x69,
242         0x64, 0x3a, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x2d,
243         0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32,
244         0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x31, 0x34, 0x30, 0x32, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x0c,
245         0x2b, 0x75, 0x73, 0x65, 0x72, 0x69, 0x64, 0x3a, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37,
246         0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d,
247         0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x30, 0x59, 0x30, 0x13,
248         0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
249         0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xf7, 0x13, 0x5c, 0x73, 0x72, 0xce, 0x10, 0xe5, 0x09,
250         0x97, 0x9a, 0xf8, 0xf2, 0x70, 0xa6, 0x3d, 0x89, 0xf5, 0xc5, 0xe4, 0x44, 0xe2, 0x4a, 0xb6, 0x61,
251         0xa8, 0x12, 0x8d, 0xb4, 0xdc, 0x2b, 0x47, 0x84, 0x60, 0x0c, 0x25, 0x66, 0xe9, 0xe0, 0xe5, 0xac,
252         0x22, 0xbf, 0x15, 0xdc, 0x71, 0xb1, 0x88, 0x4f, 0x16, 0xbf, 0xc2, 0x77, 0x37, 0x76, 0x3f, 0xe0,
253         0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
254         0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x47, 0xcc, 0x41, 0x8a, 0x27, 0xc7,
255         0xd0, 0xaa, 0xb4, 0xab, 0x85, 0xbf, 0x09, 0x4d, 0x06, 0xd7, 0x7e, 0x0d, 0x39, 0xf9, 0x36, 0xa1,
256         0x3d, 0x96, 0x23, 0xe2, 0x24, 0x64, 0x98, 0x63, 0x21, 0xba, 0x02, 0x21, 0x00, 0xe5, 0x8f, 0x7f,
257         0xf1, 0xa6, 0x82, 0x03, 0x6a, 0x18, 0x7a, 0x54, 0xe7, 0x0e, 0x25, 0x77, 0xd8, 0x46, 0xfa, 0x96,
258         0x8a, 0x7e, 0x14, 0xc4, 0xcb, 0x21, 0x32, 0x3e, 0x89, 0xd9, 0xba, 0x8c, 0x3f
259     };
260
261 static uint8_t keyData[] = {
262             0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
263         0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x47, 0xcc, 0x41, 0x8a, 0x27, 0xc7,
264         0xd0, 0xaa, 0xb4, 0xab, 0x85, 0xbf, 0x09, 0x4d, 0x06, 0xd7, 0x7e, 0x0d, 0x39, 0xf9, 0x36, 0xa1,
265         0x3d, 0x96, 0x23, 0xe2, 0x24, 0x64, 0x98, 0x63, 0x21, 0xba, 0x02, 0x21
266     };
267
268 TEST_F(SRPTest, SRPSaveTrustCertChainDER)
269 {
270     int result;
271     uint16_t credId;
272
273     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_DER, &credId);
274
275     EXPECT_EQ(OC_STACK_OK, result);
276 }
277
278 TEST_F(SRPTest, SRPSaveTrustCertChainPEM)
279 {
280     int result;
281     uint16_t credId;
282
283     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_PEM, &credId);
284
285     EXPECT_EQ(OC_STACK_OK, result);
286 }
287
288 TEST_F(SRPTest, SRPSaveTrustCertChainNullCertData)
289 {
290     int result;
291     uint16_t credId;
292
293     result = SRPSaveTrustCertChain(NULL, sizeof(certData), OIC_ENCODING_DER, &credId);
294
295     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
296 }
297
298 TEST_F(SRPTest, SRPSaveTrustCertChainNullCredId)
299 {
300     int result;
301
302     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_DER, NULL);
303
304     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
305 }
306
307 TEST_F(SRPTest, SRPSaveOwnCertChainTest)
308 {
309     int result;
310     uint16_t credId;
311     OicSecKey_t cert;
312     OicSecKey_t key;
313
314     cert.data = certData;
315     cert.len = sizeof(certData);
316     key.data = keyData;
317     key.len = sizeof(keyData);
318
319     //This test case cannot succeed. because doxm resource has not been initialized.
320     result = SRPSaveOwnCertChain(&cert, &key, &credId);
321
322     EXPECT_EQ(OC_STACK_ERROR, result);
323 }
324
325 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCert)
326 {
327     int result;
328     uint16_t credId;
329     OicSecKey_t key;
330
331     key.data = keyData;
332     key.len = sizeof(keyData);
333
334     result = SRPSaveOwnCertChain(NULL, &key, &credId);
335
336     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
337 }
338
339 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCertData)
340 {
341     int result;
342     uint16_t credId;
343     OicSecKey_t cert;
344     OicSecKey_t key;
345
346     cert.data = NULL;
347     cert.len = sizeof(certData);
348     key.data = keyData;
349     key.len = sizeof(keyData);
350
351     result = SRPSaveOwnCertChain(&cert, &key, &credId);
352
353     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
354 }
355
356 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullKey)
357 {
358     int result;
359     uint16_t credId;
360     OicSecKey_t cert;
361
362     cert.data = certData;
363     cert.len = sizeof(certData);
364
365     result = SRPSaveOwnCertChain(&cert, NULL, &credId);
366
367     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
368 }
369
370 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullKeyData)
371 {
372     int result;
373     uint16_t credId;
374     OicSecKey_t cert;
375     OicSecKey_t key;
376
377     cert.data = certData;
378     cert.len = sizeof(certData);
379     key.data = NULL;
380     key.len = sizeof(keyData);
381
382     result = SRPSaveOwnCertChain(&cert, &key, &credId);
383
384     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
385 }
386
387 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCredId)
388 {
389     int result;
390     OicSecKey_t cert;
391     OicSecKey_t key;
392
393     cert.data = certData;
394     cert.len = sizeof(certData);
395     key.data = keyData;
396     key.len = sizeof(keyData);
397
398     result = SRPSaveOwnCertChain(&cert, &key, NULL);
399
400     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
401 }
402
403
404 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainNullSelectedDeviceInfo)
405 {
406     int result;
407     int ctx;
408     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
409     uint16_t credId = 0;
410
411     result = SRPProvisionTrustCertChain(&ctx, type, credId, NULL, provisioningCB);
412     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
413 }
414
415 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainNullResultCallback)
416 {
417     int result;
418     int ctx;
419     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
420     uint16_t credId = 0;
421     OCProvisionDev_t selectedDeviceInfo;
422
423     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, NULL);
424     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, result);
425 }
426
427 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainInvalidOicSecCredType)
428 {
429     int result;
430     int ctx;
431     OicSecCredType_t type = PIN_PASSWORD;
432     uint16_t credId = 0;
433     OCProvisionDev_t selectedDeviceInfo;
434
435     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, provisioningCB);
436     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
437 }
438
439 TEST_F(SRPTest, SRPProvisionTrustCertChainNoResource)
440 {
441     int result;
442     int ctx;
443     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
444     uint16_t credId = 0;
445     OCProvisionDev_t selectedDeviceInfo;
446
447     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, provisioningCB);
448     EXPECT_EQ(OC_STACK_NO_RESOURCE, result);
449 }
450
451 TEST(SRPProvisionTrustCertChainTest, SRPGetACLResourceNoCallback)
452 {
453     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPGetACLResource(NULL, &pDev1, NULL));
454 }
455
456 TEST(SRPProvisionTrustCertChainTest, SRPGetACLResourceNoDevice)
457 {
458     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPGetACLResource(NULL, NULL, provisioningCB));
459 }
460
461 TEST(SRPProvisionTrustCertChainTest, SRPGetCredResourceNoCallback)
462 {
463     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPGetCredResource(NULL, &pDev1, NULL));
464 }
465
466 TEST(SRPProvisionTrustCertChainTest, SRPGetCredResourceNoDevice)
467 {
468     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPGetCredResource(NULL, NULL, provisioningCB));
469 }
470
471 TEST(SRPProvisionTrustCertChainTest, SRPResetDeviceNoCallback)
472 {
473     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPResetDevice(&pDev1, NULL));
474 }
475
476 TEST(SRPProvisionTrustCertChainTest, SRPResetDeviceNoDevice)
477 {
478     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPResetDevice(NULL, provisioningCB));
479 }
480
481 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceNoCallback)
482 {
483     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPSyncDevice(NULL, timeout, &pDev1, NULL));
484 }
485
486 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceNoDevice)
487 {
488     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPSyncDevice(NULL, timeout, NULL, provisioningCB));
489 }
490
491 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceZeroWaitTime)
492 {
493     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPSyncDevice(NULL, 0, &pDev1, provisioningCB));
494 }
495
496 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoCallback)
497 {
498     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,
499               SRPRemoveDeviceWithoutDiscovery(NULL, &pDev1, &pDev2, NULL));
500 }
501
502 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoDevice)
503 {
504     EXPECT_EQ(OC_STACK_INVALID_PARAM,
505               SRPRemoveDeviceWithoutDiscovery(NULL, &pDev1, NULL, provisioningCB));
506 }
507
508 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoDeviceList)
509 {
510     EXPECT_EQ(OC_STACK_CONTINUE,
511               SRPRemoveDeviceWithoutDiscovery(NULL, NULL, &pDev2, provisioningCB));
512 }
513