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