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 extern "C" {
  22 #include "secureresourceprovider.h"
  23 #include "psinterface.h"
  24 }
  25
  26 static OicSecAcl_t acl;
  27 static OCProvisionDev_t pDev1;
  28 static OCProvisionDev_t pDev2;
  29 static OicSecCredType_t credType = SYMMETRIC_PAIR_WISE_KEY;
  30 static OCProvisionDev_t selectedDeviceInfo;
  31 static OicSecPconf_t pconf;
  32 static OicSecOxm_t oicSecDoxmJustWorks = OIC_JUST_WORKS;
  33 static OicSecOxm_t oicSecDoxmRandomPin = OIC_RANDOM_DEVICE_PIN;
  34 static unsigned short timeout = 60;
  35 static OicSecDoxm_t defaultDoxm1 =
  36 {
  37     NULL,                   /* OicUrn_t *oxmType */
  38     0,                      /* size_t oxmTypeLen */
  39     &oicSecDoxmJustWorks,  /* uint16_t *oxm */
  40     1,                      /* size_t oxmLen */
  41     OIC_JUST_WORKS,         /* uint16_t oxmSel */
  42     SYMMETRIC_PAIR_WISE_KEY,/* OicSecCredType_t sct */
  43     false,                  /* bool owned */
  44     {{0}},            /* OicUuid_t deviceID */
  45     false,                  /* bool dpc */
  46     {{0}},            /* OicUuid_t owner */
  47 };
  48
  49 static OicSecDoxm_t defaultDoxm2 =
  50 {
  51     NULL,                   /* OicUrn_t *oxmType */
  52     0,                      /* size_t oxmTypeLen */
  53     &oicSecDoxmRandomPin,  /* uint16_t *oxm */
  54     1,                      /* size_t oxmLen */
  55     OIC_RANDOM_DEVICE_PIN,         /* uint16_t oxmSel */
  56     SYMMETRIC_PAIR_WISE_KEY,/* OicSecCredType_t sct */
  57     false,                  /* bool owned */
  58     {{0}},            /* OicUuid_t deviceID */
  59     false,                  /* bool dpc */
  60     {{0}},            /* OicUuid_t owner */
  61 };
  62
  63 static void provisioningCB (void* UNUSED1, int UNUSED2, OCProvisionResult_t *UNUSED3, bool UNUSED4)
  64 {
  65     //dummy callback
  66     (void) UNUSED1;
  67     (void) UNUSED2;
  68     (void) UNUSED3;
  69     (void) UNUSED4;
  70 }
  71
  72 TEST(SRPProvisionACLTest, NullDeviceInfo)
  73 {
  74     pDev1.doxm = &defaultDoxm1;
  75     uint8_t deviceId1[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64};
  76     memcpy(pDev1.doxm->deviceID.id, deviceId1, sizeof(deviceId1));
  77
  78     pDev2.doxm = &defaultDoxm2;
  79     uint8_t deviceId2[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x63};
  80     memcpy(pDev2.doxm->deviceID.id, deviceId2, sizeof(deviceId2));
  81
  82     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionACL(NULL, NULL, &acl, &provisioningCB));
  83 }
  84
  85 TEST(SRPProvisionACLTest, NullCallback)
  86 {
  87     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPProvisionACL(NULL, &pDev1, &acl, NULL));
  88 }
  89
  90 TEST(SRPProvisionACLTest, NullACL)
  91 {
  92     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionACL(NULL, &pDev1, NULL, &provisioningCB));
  93 }
  94
  95 TEST(SRPProvisionCredentialsTest, NullDevice1)
  96 {
  97     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionCredentials(NULL, credType,
  98                                                               OWNER_PSK_LENGTH_128, NULL,
  99                                                               &pDev2, &provisioningCB));
 100 }
 101
 102 TEST(SRPProvisionCredentialsTest, SamelDeviceId)
 103 {
 104     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionCredentials(NULL, credType,
 105                                                               OWNER_PSK_LENGTH_128, &pDev1,
 106                                                               &pDev1, &provisioningCB));
 107 }
 108
 109 TEST(SRPProvisionCredentialsTest, NullCallback)
 110 {
 111     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPProvisionCredentials(NULL, credType,
 112                                                                  OWNER_PSK_LENGTH_128,
 113                                                                  &pDev1, &pDev2, NULL));
 114 }
 115
 116 TEST(SRPProvisionCredentialsTest, InvalidKeySize)
 117 {
 118     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionCredentials(NULL, credType,
 119                                                                 0, &pDev1, &pDev2,
 120                                                                 &provisioningCB));
 121 }
 122
 123 TEST(SRPUnlinkDevicesTest, NullDevice1)
 124 {
 125     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPUnlinkDevices(NULL, NULL, &pDev2, provisioningCB));
 126 }
 127
 128 TEST(SRPUnlinkDevicesTest, NullDevice2)
 129 {
 130     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPUnlinkDevices(NULL, &pDev1, NULL, provisioningCB));
 131 }
 132
 133 TEST(SRPUnlinkDevicesTest, SamelDeviceId)
 134 {
 135     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPUnlinkDevices(NULL, &pDev1, &pDev1, provisioningCB));
 136 }
 137
 138 TEST(SRPUnlinkDevicesTest, NullCallback)
 139 {
 140     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPUnlinkDevices(NULL, &pDev1, &pDev2, NULL));
 141 }
 142
 143 TEST(SRPRemoveDeviceTest, NullTargetDevice)
 144 {
 145     unsigned short waitTime = 10 ;
 146     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPRemoveDevice(NULL, waitTime, NULL, provisioningCB));
 147 }
 148
 149 TEST(SRPRemoveDeviceTest, NullResultCallback)
 150 {
 151     unsigned short waitTime = 10;
 152     OCProvisionDev_t dev1;
 153     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPRemoveDevice(NULL, waitTime, &dev1, NULL));
 154 }
 155
 156 TEST(SRPRemoveDeviceTest, ZeroWaitTime)
 157 {
 158     OCProvisionDev_t dev1;
 159     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPRemoveDevice(NULL, 0, &dev1, NULL));
 160 }
 161
 162 TEST(SRPProvisionDirectPairingTest, NullselectedDeviceInfo)
 163 {
 164     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionDirectPairing(NULL, NULL, &pconf, &provisioningCB));
 165 }
 166
 167 TEST(SRPProvisionDirectPairingTest, Nullpconf)
 168 {
 169     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPProvisionDirectPairing(NULL, &selectedDeviceInfo, NULL, &provisioningCB));
 170 }
 171
 172 TEST(SRPProvisionDirectPairingTest, Nullcallback)
 173 {
 174     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPProvisionDirectPairing(NULL, &selectedDeviceInfo, &pconf, NULL));
 175 }
 176
 177 const char *SECURE_RESOURCE_PROVIDER_TEST_FILE_NAME = "secureresourceprovider.dat";
 178 OCPersistentStorage ps = { NULL, NULL, NULL, NULL, NULL};
 179
 180 static FILE* TestFopen(const char * /*path*/, const char *mode)
 181 {
 182     return fopen(SECURE_RESOURCE_PROVIDER_TEST_FILE_NAME, mode);
 183 }
 184
 185 void SetPersistentHandler(OCPersistentStorage *ps)
 186 {
 187     if(ps)
 188     {
 189         ps->open = TestFopen;
 190         ps->read = fread;
 191         ps->write = fwrite;
 192         ps->close = fclose;
 193         ps->unlink = unlink;
 194     }
 195 }
 196
 197 class SRPTest : public ::testing::Test
 198 {
 199 public:
 200     static void SetUpTestCase()
 201     {
 202         InitPersistentStorageInterface();
 203         SetPersistentHandler(&ps);
 204         OCStackResult res = OCRegisterPersistentStorageHandler(&ps);
 205         ASSERT_TRUE(res == OC_STACK_OK);
 206     }
 207
 208     static void TearDownTestCase()
 209     {
 210     }
 211
 212     static const ByteArray g_caPublicKey;
 213
 214     static const ByteArray g_derCode ;
 215
 216     static ByteArray g_serNum;
 217 };
 218
 219 static uint8_t certData[] = {
 220         0x30, 0x82, 0x02, 0x39, 0x30, 0x82, 0x01, 0xdf, 0x02, 0x01, 0x01, 0x30, 0x0a, 0x06, 0x08, 0x2a,
 221         0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x7c, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
 222         0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c,
 223         0x09, 0x53, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03,
 224         0x55, 0x04, 0x07, 0x0c, 0x08, 0x53, 0x6f, 0x6d, 0x65, 0x63, 0x69, 0x74, 0x79, 0x31, 0x0b, 0x30,
 225         0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x42, 0x42, 0x31, 0x16, 0x30, 0x14, 0x06, 0x03,
 226         0x55, 0x04, 0x0b, 0x0c, 0x0d, 0x53, 0x65, 0x71, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x50, 0x61,
 227         0x72, 0x74, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x02, 0x6f, 0x62, 0x31,
 228         0x14, 0x30, 0x12, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x05,
 229         0x6f, 0x62, 0x40, 0x62, 0x62, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x36, 0x30, 0x38, 0x31, 0x35, 0x31,
 230         0x33, 0x31, 0x31, 0x31, 0x37, 0x5a, 0x17, 0x0d, 0x31, 0x39, 0x30, 0x35, 0x31, 0x32, 0x31, 0x33,
 231         0x31, 0x31, 0x31, 0x37, 0x5a, 0x30, 0x81, 0xd4, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
 232         0x06, 0x13, 0x02, 0x55, 0x41, 0x31, 0x0c, 0x30, 0x0a, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x03,
 233         0x41, 0x73, 0x64, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x06, 0x47, 0x6f,
 234         0x74, 0x68, 0x61, 0x6d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x5a,
 235         0x5a, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x08, 0x42, 0x65, 0x61, 0x6d,
 236         0x54, 0x65, 0x61, 0x6d, 0x31, 0x1c, 0x30, 0x1a, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
 237         0x01, 0x09, 0x01, 0x16, 0x0d, 0x72, 0x61, 0x69, 0x6c, 0x40, 0x6d, 0x61, 0x69, 0x6c, 0x2e, 0x63,
 238         0x6f, 0x6d, 0x31, 0x32, 0x30, 0x30, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x29, 0x75, 0x75, 0x69,
 239         0x64, 0x3a, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x2d,
 240         0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x2d, 0x33, 0x32, 0x33, 0x32, 0x33, 0x32,
 241         0x33, 0x32, 0x33, 0x32, 0x33, 0x32, 0x31, 0x34, 0x30, 0x32, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x0c,
 242         0x2b, 0x75, 0x73, 0x65, 0x72, 0x69, 0x64, 0x3a, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37,
 243         0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d, 0x36, 0x37, 0x36, 0x37, 0x2d,
 244         0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x36, 0x37, 0x30, 0x59, 0x30, 0x13,
 245         0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 246         0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xf7, 0x13, 0x5c, 0x73, 0x72, 0xce, 0x10, 0xe5, 0x09,
 247         0x97, 0x9a, 0xf8, 0xf2, 0x70, 0xa6, 0x3d, 0x89, 0xf5, 0xc5, 0xe4, 0x44, 0xe2, 0x4a, 0xb6, 0x61,
 248         0xa8, 0x12, 0x8d, 0xb4, 0xdc, 0x2b, 0x47, 0x84, 0x60, 0x0c, 0x25, 0x66, 0xe9, 0xe0, 0xe5, 0xac,
 249         0x22, 0xbf, 0x15, 0xdc, 0x71, 0xb1, 0x88, 0x4f, 0x16, 0xbf, 0xc2, 0x77, 0x37, 0x76, 0x3f, 0xe0,
 250         0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 251         0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x47, 0xcc, 0x41, 0x8a, 0x27, 0xc7,
 252         0xd0, 0xaa, 0xb4, 0xab, 0x85, 0xbf, 0x09, 0x4d, 0x06, 0xd7, 0x7e, 0x0d, 0x39, 0xf9, 0x36, 0xa1,
 253         0x3d, 0x96, 0x23, 0xe2, 0x24, 0x64, 0x98, 0x63, 0x21, 0xba, 0x02, 0x21, 0x00, 0xe5, 0x8f, 0x7f,
 254         0xf1, 0xa6, 0x82, 0x03, 0x6a, 0x18, 0x7a, 0x54, 0xe7, 0x0e, 0x25, 0x77, 0xd8, 0x46, 0xfa, 0x96,
 255         0x8a, 0x7e, 0x14, 0xc4, 0xcb, 0x21, 0x32, 0x3e, 0x89, 0xd9, 0xba, 0x8c, 0x3f
 256     };
 257
 258 static uint8_t keyData[] = {
 259             0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 260         0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x47, 0xcc, 0x41, 0x8a, 0x27, 0xc7,
 261         0xd0, 0xaa, 0xb4, 0xab, 0x85, 0xbf, 0x09, 0x4d, 0x06, 0xd7, 0x7e, 0x0d, 0x39, 0xf9, 0x36, 0xa1,
 262         0x3d, 0x96, 0x23, 0xe2, 0x24, 0x64, 0x98, 0x63, 0x21, 0xba, 0x02, 0x21
 263     };
 264
 265 TEST_F(SRPTest, SRPSaveTrustCertChainDER)
 266 {
 267     int result;
 268     uint16_t credId;
 269
 270     //This test case cannot succeed. because doxm resource has not been initialized.
 271     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_DER, &credId);
 272
 273     EXPECT_EQ(OC_STACK_ERROR, result);
 274 }
 275
 276 TEST_F(SRPTest, SRPSaveTrustCertChainPEM)
 277 {
 278     int result;
 279     uint16_t credId;
 280
 281     //This test case cannot succeed. because doxm resource has not been initialized.
 282     result = SRPSaveTrustCertChain(certData, sizeof(certData), OIC_ENCODING_PEM, &credId);
 283
 284     EXPECT_EQ(OC_STACK_ERROR, result);
 285 }
 286
 287 TEST_F(SRPTest, SRPSaveTrustCertChainNullCertData)
 288 {
 289     int result;
 290     uint16_t credId;
 291
 292     result = SRPSaveTrustCertChain(NULL, sizeof(certData), OIC_ENCODING_DER, &credId);
 293
 294     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 295 }
 296
 297 TEST_F(SRPTest, SRPSaveTrustCertChainNullCredId)
 298 {
 299     int result;
 300     uint16_t credId;
 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