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, int 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     return fopen(SECURE_RESOURCE_PROVIDER_TEST_FILE_NAME, mode);
 180 }
 181
 182 void SetPersistentHandler(OCPersistentStorage *ps)
 183 {
 184     if(ps)
 185     {
 186         ps->open = TestFopen;
 187         ps->read = fread;
 188         ps->write = fwrite;
 189         ps->close = fclose;
 190         ps->unlink = unlink;
 191     }
 192 }
 193
 194 class SRPTest : public ::testing::Test
 195 {
 196 public:
 197     static void SetUpTestCase()
 198     {
 199         SetPersistentHandler(&ps);
 200         OCStackResult res = OCRegisterPersistentStorageHandler(&ps);
 201         ASSERT_TRUE(res == OC_STACK_OK);
 202     }
 203
 204     static void TearDownTestCase()
 205     {
 206     }
 207
 208     static const ByteArray g_caPublicKey;
 209
 210     static const ByteArray g_derCode ;
 211
 212     static ByteArray g_serNum;
 213 };
 214
 215 static uint8_t certData[] = {
 216         0x30, 0x82, 0x02, 0x39, 0x30, 0x82, 0x01, 0xdf, 0x02, 0x01, 0x01, 0x30, 0x0a, 0x06, 0x08, 0x2a,
 217         0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x7c, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
 218         0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c,
 219         0x09, 0x53, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03,
 220         0x55, 0x04, 0x07, 0x0c, 0x08, 0x53, 0x6f, 0x6d, 0x65, 0x63, 0x69, 0x74, 0x79, 0x31, 0x0b, 0x30,
 221         0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x42, 0x42, 0x31, 0x16, 0x30, 0x14, 0x06, 0x03,
 222         0x55, 0x04, 0x0b, 0x0c, 0x0d, 0x53, 0x65, 0x71, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x50, 0x61,
 223         0x72, 0x74, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x02, 0x6f, 0x62, 0x31,
 224         0x14, 0x30, 0x12, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x05,
 225         0x6f, 0x62, 0x40, 0x62, 0x62, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x36, 0x30, 0x38, 0x31, 0x35, 0x31,
 226         0x33, 0x31, 0x31, 0x31, 0x37, 0x5a, 0x17, 0x0d, 0x31, 0x39, 0x30, 0x35, 0x31, 0x32, 0x31, 0x33,
 227         0x31, 0x31, 0x31, 0x37, 0x5a, 0x30, 0x81, 0xd4, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
 228         0x06, 0x13, 0x02, 0x55, 0x41, 0x31, 0x0c, 0x30, 0x0a, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x03,
 229         0x41, 0x73, 0x64, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x06, 0x47, 0x6f,
 230         0x74, 0x68, 0x61, 0x6d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x5a,
 231         0x5a, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x08, 0x42, 0x65, 0x61, 0x6d,
 232         0x54, 0x65, 0x61, 0x6d, 0x31, 0x1c, 0x30, 0x1a, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
 233         0x01, 0x09, 0x01, 0x16, 0x0d, 0x72, 0x61, 0x69, 0x6c, 0x40, 0x6d, 0x61, 0x69, 0x6c, 0x2e, 0x63,
 234         0x6f, 0x6d, 0x31, 0x32, 0x30, 0x30, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x29, 0x75, 0x75, 0x69,
 235         0x64, 0x3a, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x2d,
 236         0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32,
 237         0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x31, 0x34, 0x30, 0x32, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x0c,
 238         0x2b, 0x75, 0x73, 0x65, 0x72, 0x69, 0x64, 0x3a, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37,
 239         0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d,
 240         0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x30, 0x59, 0x30, 0x13,
 241         0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 242         0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xf7, 0x13, 0x5c, 0x73, 0x72, 0xce, 0x10, 0xe5, 0x09,
 243         0x97, 0x9a, 0xf8, 0xf2, 0x70, 0xa6, 0x3d, 0x89, 0xf5, 0xc5, 0xe4, 0x44, 0xe2, 0x4a, 0xb6, 0x61,
 244         0xa8, 0x12, 0x8d, 0xb4, 0xdc, 0x2b, 0x47, 0x84, 0x60, 0x0c, 0x25, 0x66, 0xe9, 0xe0, 0xe5, 0xac,
 245         0x22, 0xbf, 0x15, 0xdc, 0x71, 0xb1, 0x88, 0x4f, 0x16, 0xbf, 0xc2, 0x77, 0x37, 0x76, 0x3f, 0xe0,
 246         0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 247         0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x47, 0xcc, 0x41, 0x8a, 0x27, 0xc7,
 248         0xd0, 0xaa, 0xb4, 0xab, 0x85, 0xbf, 0x09, 0x4d, 0x06, 0xd7, 0x7e, 0x0d, 0x39, 0xf9, 0x36, 0xa1,
 249         0x3d, 0x96, 0x23, 0xe2, 0x24, 0x64, 0x98, 0x63, 0x21, 0xba, 0x02, 0x21, 0x00, 0xe5, 0x8f, 0x7f,
 250         0xf1, 0xa6, 0x82, 0x03, 0x6a, 0x18, 0x7a, 0x54, 0xe7, 0x0e, 0x25, 0x77, 0xd8, 0x46, 0xfa, 0x96,
 251         0x8a, 0x7e, 0x14, 0xc4, 0xcb, 0x21, 0x32, 0x3e, 0x89, 0xd9, 0xba, 0x8c, 0x3f
 252     };
 253
 254 static uint8_t keyData[] = {
 255             0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 256         0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x47, 0xcc, 0x41, 0x8a, 0x27, 0xc7,
 257         0xd0, 0xaa, 0xb4, 0xab, 0x85, 0xbf, 0x09, 0x4d, 0x06, 0xd7, 0x7e, 0x0d, 0x39, 0xf9, 0x36, 0xa1,
 258         0x3d, 0x96, 0x23, 0xe2, 0x24, 0x64, 0x98, 0x63, 0x21, 0xba, 0x02, 0x21
 259     };
 260
 261 TEST_F(SRPTest, SRPSaveTrustCertChainDER)
 262 {
 263     int result;
 264     uint16_t credId;
 265
 266     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_DER, &credId);
 267
 268     EXPECT_EQ(OC_STACK_OK, result);
 269 }
 270
 271 TEST_F(SRPTest, SRPSaveTrustCertChainPEM)
 272 {
 273     int result;
 274     uint16_t credId;
 275
 276     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_PEM, &credId);
 277
 278     EXPECT_EQ(OC_STACK_OK, result);
 279 }
 280
 281 TEST_F(SRPTest, SRPSaveTrustCertChainNullCertData)
 282 {
 283     int result;
 284     uint16_t credId;
 285
 286     result = SRPSaveTrustCertChain(NULL, sizeof(certData), OIC_ENCODING_DER, &credId);
 287
 288     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 289 }
 290
 291 TEST_F(SRPTest, SRPSaveTrustCertChainNullCredId)
 292 {
 293     int result;
 294     uint16_t credId;
 295
 296     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_DER, NULL);
 297
 298     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 299 }
 300
 301 TEST_F(SRPTest, SRPSaveOwnCertChainTest)
 302 {
 303     int result;
 304     uint16_t credId;
 305     OicSecCert_t cert;
 306     OicSecKey_t key;
 307
 308     cert.data = certData;
 309     cert.len = sizeof(certData);
 310     key.data = keyData;
 311     key.len = sizeof(keyData);
 312
 313     result = SRPSaveOwnCertChain(&cert, &key, &credId);
 314
 315     EXPECT_EQ(OC_STACK_OK, result);
 316 }
 317
 318 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCert)
 319 {
 320     int result;
 321     uint16_t credId;
 322     OicSecKey_t key;
 323
 324     key.data = keyData;
 325     key.len = sizeof(keyData);
 326
 327     result = SRPSaveOwnCertChain(NULL, &key, &credId);
 328
 329     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 330 }
 331
 332 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCertData)
 333 {
 334     int result;
 335     uint16_t credId;
 336     OicSecCert_t cert;
 337     OicSecKey_t key;
 338
 339     cert.data = NULL;
 340     cert.len = sizeof(certData);
 341     key.data = keyData;
 342     key.len = sizeof(keyData);
 343
 344     result = SRPSaveOwnCertChain(&cert, &key, &credId);
 345
 346     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 347 }
 348
 349 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullKey)
 350 {
 351     int result;
 352     uint16_t credId;
 353     OicSecCert_t cert;
 354
 355     cert.data = certData;
 356     cert.len = sizeof(certData);
 357
 358     result = SRPSaveOwnCertChain(&cert, NULL, &credId);
 359
 360     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 361 }
 362
 363 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullKeyData)
 364 {
 365     int result;
 366     uint16_t credId;
 367     OicSecCert_t cert;
 368     OicSecKey_t key;
 369
 370     cert.data = certData;
 371     cert.len = sizeof(certData);
 372     key.data = NULL;
 373     key.len = sizeof(keyData);
 374
 375     result = SRPSaveOwnCertChain(&cert, &key, &credId);
 376
 377     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 378 }
 379
 380 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCredId)
 381 {
 382     int result;
 383     OicSecCert_t cert;
 384     OicSecKey_t key;
 385
 386     cert.data = certData;
 387     cert.len = sizeof(certData);
 388     key.data = keyData;
 389     key.len = sizeof(keyData);
 390
 391     result = SRPSaveOwnCertChain(&cert, &key, NULL);
 392
 393     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 394 }
 395
 396
 397 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainNullSelectedDeviceInfo)
 398 {
 399     int result;
 400     int ctx;
 401     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
 402     uint16_t credId = 0;
 403
 404     result = SRPProvisionTrustCertChain(&ctx, type, credId, NULL, provisioningCB);
 405     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 406 }
 407
 408 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainNullResultCallback)
 409 {
 410     int result;
 411     int ctx;
 412     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
 413     uint16_t credId = 0;
 414     OCProvisionDev_t selectedDeviceInfo;
 415
 416     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, NULL);
 417     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, result);
 418 }
 419
 420 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainInvalidOicSecCredType)
 421 {
 422     int result;
 423     int ctx;
 424     OicSecCredType_t type = PIN_PASSWORD;
 425     uint16_t credId = 0;
 426     OCProvisionDev_t selectedDeviceInfo;
 427
 428     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, provisioningCB);
 429     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 430 }
 431
 432 TEST_F(SRPTest, SRPProvisionTrustCertChainNoResource)
 433 {
 434     int result;
 435     int ctx;
 436     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
 437     uint16_t credId = 0;
 438     OCProvisionDev_t selectedDeviceInfo;
 439
 440     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, provisioningCB);
 441     EXPECT_EQ(OC_STACK_NO_RESOURCE, result);
 442 }
 443
 444 TEST(SRPProvisionTrustCertChainTest, SRPGetACLResourceNoCallback)
 445 {
 446     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPGetACLResource(NULL, &pDev1, NULL));
 447 }
 448
 449 TEST(SRPProvisionTrustCertChainTest, SRPGetACLResourceNoDevice)
 450 {
 451     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPGetACLResource(NULL, NULL, provisioningCB));
 452 }
 453
 454 TEST(SRPProvisionTrustCertChainTest, SRPGetCredResourceNoCallback)
 455 {
 456     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPGetCredResource(NULL, &pDev1, NULL));
 457 }
 458
 459 TEST(SRPProvisionTrustCertChainTest, SRPGetCredResourceNoDevice)
 460 {
 461     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPGetCredResource(NULL, NULL, provisioningCB));
 462 }
 463
 464 TEST(SRPProvisionTrustCertChainTest, SRPResetDeviceNoCallback)
 465 {
 466     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPResetDevice(&pDev1, NULL));
 467 }
 468
 469 TEST(SRPProvisionTrustCertChainTest, SRPResetDeviceNoDevice)
 470 {
 471     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPResetDevice(NULL, provisioningCB));
 472 }
 473
 474 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceNoCallback)
 475 {
 476     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPSyncDevice(NULL, timeout, &pDev1, NULL));
 477 }
 478
 479 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceNoDevice)
 480 {
 481     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPSyncDevice(NULL, timeout, NULL, provisioningCB));
 482 }
 483
 484 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceZeroWaitTime)
 485 {
 486     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPSyncDevice(NULL, 0, &pDev1, provisioningCB));
 487 }
 488
 489 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoCallback)
 490 {
 491     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,
 492               SRPRemoveDeviceWithoutDiscovery(NULL, &pDev1, &pDev2, NULL));
 493 }
 494
 495 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoDevice)
 496 {
 497     EXPECT_EQ(OC_STACK_INVALID_PARAM,
 498               SRPRemoveDeviceWithoutDiscovery(NULL, &pDev1, NULL, provisioningCB));
 499 }
 500
 501 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoDeviceList)
 502 {
 503     EXPECT_EQ(OC_STACK_CONTINUE,
 504               SRPRemoveDeviceWithoutDiscovery(NULL, NULL, &pDev2, provisioningCB));
 505 }
 506