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     //This test case cannot succeed. because doxm resource has not been initialized.
 314     result = SRPSaveOwnCertChain(&cert, &key, &credId);
 315
 316     EXPECT_EQ(OC_STACK_ERROR, result);
 317 }
 318
 319 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCert)
 320 {
 321     int result;
 322     uint16_t credId;
 323     OicSecKey_t key;
 324
 325     key.data = keyData;
 326     key.len = sizeof(keyData);
 327
 328     result = SRPSaveOwnCertChain(NULL, &key, &credId);
 329
 330     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 331 }
 332
 333 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCertData)
 334 {
 335     int result;
 336     uint16_t credId;
 337     OicSecCert_t cert;
 338     OicSecKey_t key;
 339
 340     cert.data = NULL;
 341     cert.len = sizeof(certData);
 342     key.data = keyData;
 343     key.len = sizeof(keyData);
 344
 345     result = SRPSaveOwnCertChain(&cert, &key, &credId);
 346
 347     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 348 }
 349
 350 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullKey)
 351 {
 352     int result;
 353     uint16_t credId;
 354     OicSecCert_t cert;
 355
 356     cert.data = certData;
 357     cert.len = sizeof(certData);
 358
 359     result = SRPSaveOwnCertChain(&cert, NULL, &credId);
 360
 361     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 362 }
 363
 364 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullKeyData)
 365 {
 366     int result;
 367     uint16_t credId;
 368     OicSecCert_t cert;
 369     OicSecKey_t key;
 370
 371     cert.data = certData;
 372     cert.len = sizeof(certData);
 373     key.data = NULL;
 374     key.len = sizeof(keyData);
 375
 376     result = SRPSaveOwnCertChain(&cert, &key, &credId);
 377
 378     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 379 }
 380
 381 TEST_F(SRPTest, SRPSaveOwnCertChainTestNullCredId)
 382 {
 383     int result;
 384     OicSecCert_t cert;
 385     OicSecKey_t key;
 386
 387     cert.data = certData;
 388     cert.len = sizeof(certData);
 389     key.data = keyData;
 390     key.len = sizeof(keyData);
 391
 392     result = SRPSaveOwnCertChain(&cert, &key, NULL);
 393
 394     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 395 }
 396
 397
 398 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainNullSelectedDeviceInfo)
 399 {
 400     int result;
 401     int ctx;
 402     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
 403     uint16_t credId = 0;
 404
 405     result = SRPProvisionTrustCertChain(&ctx, type, credId, NULL, provisioningCB);
 406     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 407 }
 408
 409 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainNullResultCallback)
 410 {
 411     int result;
 412     int ctx;
 413     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
 414     uint16_t credId = 0;
 415     OCProvisionDev_t selectedDeviceInfo;
 416
 417     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, NULL);
 418     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, result);
 419 }
 420
 421 TEST(SRPProvisionTrustCertChainTest, SRPProvisionTrustCertChainInvalidOicSecCredType)
 422 {
 423     int result;
 424     int ctx;
 425     OicSecCredType_t type = PIN_PASSWORD;
 426     uint16_t credId = 0;
 427     OCProvisionDev_t selectedDeviceInfo;
 428
 429     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, provisioningCB);
 430     EXPECT_EQ(OC_STACK_INVALID_PARAM, result);
 431 }
 432
 433 TEST_F(SRPTest, SRPProvisionTrustCertChainNoResource)
 434 {
 435     int result;
 436     int ctx;
 437     OicSecCredType_t type = SIGNED_ASYMMETRIC_KEY;
 438     uint16_t credId = 0;
 439     OCProvisionDev_t selectedDeviceInfo;
 440
 441     result = SRPProvisionTrustCertChain(&ctx, type, credId, &selectedDeviceInfo, provisioningCB);
 442     EXPECT_EQ(OC_STACK_NO_RESOURCE, result);
 443 }
 444
 445 TEST(SRPProvisionTrustCertChainTest, SRPGetACLResourceNoCallback)
 446 {
 447     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPGetACLResource(NULL, &pDev1, NULL));
 448 }
 449
 450 TEST(SRPProvisionTrustCertChainTest, SRPGetACLResourceNoDevice)
 451 {
 452     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPGetACLResource(NULL, NULL, provisioningCB));
 453 }
 454
 455 TEST(SRPProvisionTrustCertChainTest, SRPGetCredResourceNoCallback)
 456 {
 457     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPGetCredResource(NULL, &pDev1, NULL));
 458 }
 459
 460 TEST(SRPProvisionTrustCertChainTest, SRPGetCredResourceNoDevice)
 461 {
 462     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPGetCredResource(NULL, NULL, provisioningCB));
 463 }
 464
 465 TEST(SRPProvisionTrustCertChainTest, SRPResetDeviceNoCallback)
 466 {
 467     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPResetDevice(&pDev1, NULL));
 468 }
 469
 470 TEST(SRPProvisionTrustCertChainTest, SRPResetDeviceNoDevice)
 471 {
 472     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPResetDevice(NULL, provisioningCB));
 473 }
 474
 475 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceNoCallback)
 476 {
 477     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, SRPSyncDevice(NULL, timeout, &pDev1, NULL));
 478 }
 479
 480 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceNoDevice)
 481 {
 482     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPSyncDevice(NULL, timeout, NULL, provisioningCB));
 483 }
 484
 485 TEST(SRPProvisionTrustCertChainTest, SRPSyncDeviceZeroWaitTime)
 486 {
 487     EXPECT_EQ(OC_STACK_INVALID_PARAM, SRPSyncDevice(NULL, 0, &pDev1, provisioningCB));
 488 }
 489
 490 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoCallback)
 491 {
 492     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,
 493               SRPRemoveDeviceWithoutDiscovery(NULL, &pDev1, &pDev2, NULL));
 494 }
 495
 496 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoDevice)
 497 {
 498     EXPECT_EQ(OC_STACK_INVALID_PARAM,
 499               SRPRemoveDeviceWithoutDiscovery(NULL, &pDev1, NULL, provisioningCB));
 500 }
 501
 502 TEST(SRPProvisionTrustCertChainTest, SRPRemoveDeviceWithoutDiscoveryNoDeviceList)
 503 {
 504     EXPECT_EQ(OC_STACK_CONTINUE,
 505               SRPRemoveDeviceWithoutDiscovery(NULL, NULL, &pDev2, provisioningCB));
 506 }
 507