resource/csdk/security/provisioning/unittest/ocprovisioningmanager.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 "ocprovisioningmanager.h"
  22
  23 static OicSecAcl_t acl1;
  24 static OicSecAcl_t acl2;
  25 static OCProvisionDev_t pDev1;
  26 static OCProvisionDev_t pDev2;
  27 static OicSecCredType_t credType = SYMMETRIC_PAIR_WISE_KEY;
  28 static OicSecOxm_t oicSecDoxmJustWorks = OIC_JUST_WORKS;
  29 static OicSecOxm_t oicSecDoxmRandomPin = OIC_RANDOM_DEVICE_PIN;
  30 static OicSecDoxm_t defaultDoxm1 =
  31 {
  32     &oicSecDoxmJustWorks,  /* uint16_t *oxm */
  33     1,                      /* size_t oxmLen */
  34     OIC_JUST_WORKS,         /* uint16_t oxmSel */
  35     SYMMETRIC_PAIR_WISE_KEY,/* OicSecCredType_t sct */
  36     false,                  /* bool owned */
  37     {{0}},                  /* OicUuid_t deviceID */
  38     false,                  /* bool dpc */
  39     {{0}},                  /* OicUuid_t owner */
  40 #ifdef MULTIPLE_OWNER
  41     NULL,                   /* OicSecSubOwner_t* subOwners */
  42     NULL,                   /* OicSecMom_t *mom */
  43 #endif //MULTIPLE_OWNER
  44     {{0}}                   /* rownerID */
  45 };
  46
  47 static OicSecDoxm_t defaultDoxm2 =
  48 {
  49     &oicSecDoxmRandomPin,   /* uint16_t *oxm */
  50     1,                      /* size_t oxmLen */
  51     OIC_RANDOM_DEVICE_PIN,  /* uint16_t oxmSel */
  52     SYMMETRIC_PAIR_WISE_KEY,/* OicSecCredType_t sct */
  53     false,                  /* bool owned */
  54     {{0}},                  /* OicUuid_t deviceID */
  55     false,                  /* bool dpc */
  56     {{0}},                  /* OicUuid_t owner */
  57 #ifdef MULTIPLE_OWNER
  58     NULL,                   /* OicSecSubOwner_t* subOwners */
  59     NULL,                   /* OicSecMom_t *mom */
  60 #endif //MULTIPLE_OWNER
  61     {{0}}                   /* rownerID */
  62 };
  63
  64 static void provisioningCB (void* UNUSED1, size_t UNUSED2, OCProvisionResult_t *UNUSED3, bool UNUSED4)
  65 {
  66     //dummy callback
  67     (void) UNUSED1;
  68     (void) UNUSED2;
  69     (void) UNUSED3;
  70     (void) UNUSED4;
  71 }
  72
  73 static OCStackResult OTMLoadSecretCallback(OTMContext_t* otmCtx)
  74 {
  75     //dummy callback
  76     (void) otmCtx;
  77     return OC_STACK_OK;
  78 }
  79
  80 TEST(OCInitPMTest, NullPath)
  81 {
  82     EXPECT_EQ(OC_STACK_OK, OCInitPM(NULL));
  83 }
  84
  85 TEST(OCProvisionPairwiseDevicesTest, NullDevice1)
  86 {
  87     pDev1.doxm = &defaultDoxm1;
  88     uint8_t deviceId1[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64};
  89     memcpy(pDev1.doxm->deviceID.id, deviceId1, sizeof(deviceId1));
  90
  91     pDev2.doxm = &defaultDoxm2;
  92     uint8_t deviceId2[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x63};
  93     memcpy(pDev2.doxm->deviceID.id, deviceId2, sizeof(deviceId2));
  94
  95     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCProvisionPairwiseDevices(NULL, credType,
  96                                                               OWNER_PSK_LENGTH_128, NULL, &acl1,
  97                                                               &pDev2, &acl2, &provisioningCB));
  98 }
  99
 100 TEST(OCProvisionPairwiseDevicesTest, NullDevice2)
 101 {
 102     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCProvisionPairwiseDevices(NULL, credType,
 103                                                               OWNER_PSK_LENGTH_128, &pDev1, &acl1,
 104                                                               NULL, &acl2, &provisioningCB));
 105 }
 106
 107 TEST(OCProvisionPairwiseDevicesTest, SamelDeviceId)
 108 {
 109     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCProvisionPairwiseDevices(NULL, credType,
 110                                                               OWNER_PSK_LENGTH_128, &pDev1, &acl1,
 111                                                               &pDev1, &acl2, &provisioningCB));
 112 }
 113
 114 TEST(OCProvisionPairwiseDevicesTest, NullCallback)
 115 {
 116     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCProvisionPairwiseDevices(NULL, credType,
 117                                                               OWNER_PSK_LENGTH_128, &pDev1, &acl1,
 118                                                               &pDev2, &acl2, NULL));
 119 }
 120
 121 TEST(OCProvisionPairwiseDevicesTest, InvalidKeySize)
 122 {
 123     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCProvisionPairwiseDevices(NULL, credType,
 124                                                               0, &pDev1, &acl1,
 125                                                               &pDev2, &acl2 ,&provisioningCB));
 126 }
 127
 128 TEST(OCUnlinkDevicesTest, NullDevice1)
 129 {
 130     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCUnlinkDevices(NULL, NULL, &pDev2, provisioningCB));
 131 }
 132
 133 TEST(OCUnlinkDevicesTest, NullDevice2)
 134 {
 135     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCUnlinkDevices(NULL, &pDev1, NULL, provisioningCB));
 136 }
 137
 138 TEST(OCUnlinkDevicesTest, NullCallback)
 139 {
 140     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCUnlinkDevices(NULL, &pDev1, &pDev2, NULL));
 141 }
 142
 143 TEST(OCUnlinkDevicesTest, SamelDeviceId)
 144 {
 145     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCUnlinkDevices(NULL,&pDev1, &pDev1, &provisioningCB));
 146 }
 147
 148 TEST(OCRemoveDeviceTest, NullTargetDevice)
 149 {
 150     unsigned short waitTime = 10 ;
 151     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCRemoveDevice(NULL, waitTime, NULL, provisioningCB));
 152 }
 153
 154 TEST(OCRemoveDeviceWithUuidTest, NullTargetDevice)
 155 {
 156     unsigned short waitTime = 10 ;
 157     OicUuid_t uuid;
 158     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCRemoveDeviceWithUuid(NULL, waitTime, NULL, provisioningCB));
 159
 160     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCRemoveDeviceWithUuid(NULL, waitTime, &uuid, NULL));
 161 }
 162
 163 TEST(OCRemoveDeviceTest, NullResultCallback)
 164 {
 165     unsigned short waitTime = 10;
 166     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCRemoveDevice(NULL, waitTime, &pDev1, NULL));
 167 }
 168
 169 TEST(OCRemoveDeviceTest, ZeroWaitTime)
 170 {
 171     unsigned short waitTime = 0;
 172     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCRemoveDevice(NULL, waitTime, &pDev1, provisioningCB));
 173 }
 174
 175 TEST(OCGetDevInfoFromNetworkTest, NullUnOwnedDeviceInfo)
 176 {
 177     unsigned short waitTime = 10;
 178     OCProvisionDev_t *ownedList = NULL;
 179     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCGetDevInfoFromNetwork(waitTime, &ownedList, NULL));
 180 }
 181
 182 TEST(OCGetDevInfoFromNetworkTest, NullOwnedDeviceInfo)
 183 {
 184     unsigned short waitTime = 10;
 185     OCProvisionDev_t *unownedList = NULL;
 186     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCGetDevInfoFromNetwork(waitTime, NULL, &unownedList));
 187 }
 188
 189 TEST(OCGetDevInfoFromNetworkTest, ZeroWaitTime)
 190 {
 191     unsigned short waitTime = 0;
 192     OCProvisionDev_t *ownedList = NULL;
 193     OCProvisionDev_t *unownedList = NULL;
 194     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCGetDevInfoFromNetwork(waitTime, &ownedList, &unownedList));
 195 }
 196
 197 TEST(OCGetLinkedStatusTest, NULLDeviceID)
 198 {
 199     OCUuidList_t *list = NULL;
 200     size_t noOfDevices = 0;
 201     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCGetLinkedStatus(NULL, &list, &noOfDevices));
 202 }
 203
 204 TEST(OCDeleteUuidListTest, NullUuidList)
 205 {
 206     OCDeleteUuidList(NULL);
 207     EXPECT_EQ(1, 1);
 208 }
 209
 210 TEST(OCDeleteACLListTest, NullACLList)
 211 {
 212     OCDeleteACLList(NULL);
 213     EXPECT_EQ(1, 1);
 214 }
 215
 216 TEST(OCDeletePdAclListTest, NullPdACLList)
 217 {
 218     OCDeletePdAclList(NULL);
 219     EXPECT_EQ(1, 1);
 220 }
 221
 222 TEST(OCDeleteDiscoveredDevicesTest, NullProvisionDevList)
 223 {
 224     OCDeleteDiscoveredDevices(NULL);
 225     EXPECT_EQ(1, 1);
 226 }
 227
 228 TEST(OCSetOwnerTransferCallbackDataTest, NULLCallback)
 229 {
 230     OicSecOxm_t ownershipTransferMethod = OIC_JUST_WORKS;
 231     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCSetOwnerTransferCallbackData(ownershipTransferMethod,
 232     NULL));
 233 }
 234
 235 TEST(OCSetOwnerTransferCallbackDataTest, InvalidOXMType)
 236 {
 237     OicSecOxm_t ownershipTransferMethod = OIC_OXM_COUNT;
 238     OTMCallbackData_t stOTMCallbackData = { &OTMLoadSecretCallback, NULL, NULL, NULL};
 239     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetOwnerTransferCallbackData(ownershipTransferMethod,
 240     &stOTMCallbackData));
 241 }