resource/csdk/security/provisioning/unittest/provisioningdatabasemanager.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 "provisioningdatabasemanager.h"
  22
  23 const char ID_1[] = "1111111111111111";
  24 const char ID_2[] = "2111111111111111";
  25 const char ID_3[] = "3111111111111111";
  26 const char ID_4[] = "4111111111111111";
  27 const char ID_5[] = "5111111111111111";
  28 const char ID_6[] = "6111111111111111";
  29 const char ID_7[] = "7777777777777777";
  30 const char ID_8[] = "8777777777777777";
  31
  32 TEST(CallPDMAPIbeforeInit, BeforeInit)
  33 {
  34     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMAddDevice(NULL));
  35     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMIsDuplicateDevice(NULL,NULL));
  36     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMLinkDevices(NULL, NULL));
  37     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMUnlinkDevices(NULL, NULL));
  38     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMDeleteDevice(NULL));
  39     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMGetOwnedDevices(NULL, NULL));
  40     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMGetLinkedDevices(NULL, NULL, NULL));
  41     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMSetLinkStale(NULL, NULL));
  42     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMGetToBeUnlinkedDevices(NULL, NULL));
  43     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMIsLinkExists(NULL, NULL, NULL));
  44 }
  45
  46 TEST(PDMInitTest, PDMInitWithNULL)
  47 {
  48     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
  49 }
  50
  51 TEST(PDMAddDeviceTest, NullUUID)
  52 {
  53     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMAddDevice(NULL));
  54 }
  55
  56 TEST(PDMIsDuplicateDeviceTest, NullUUID)
  57 {
  58     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMIsDuplicateDevice(NULL,NULL));
  59 }
  60
  61
  62 TEST(PDMIsDuplicateDeviceTest, ValidUUID)
  63 {
  64     OicUuid_t uid1 = {{0,}};
  65     memcpy(&uid1.id, ID_1, sizeof(uid1.id));
  66     PDMAddDevice(&uid1);
  67     OicUuid_t uid2 = {{0,}};
  68     memcpy(&uid2.id, ID_2, sizeof(uid2.id));
  69     PDMAddDevice(&uid2);
  70     OicUuid_t uid3 = {{0,}};
  71     memcpy(&uid3.id, ID_3, sizeof(uid3.id));
  72     bool isDuplicate = true;
  73     EXPECT_EQ(OC_STACK_OK, PDMIsDuplicateDevice(&uid1,&isDuplicate));
  74     EXPECT_TRUE(isDuplicate);
  75
  76     EXPECT_EQ(OC_STACK_OK, PDMIsDuplicateDevice(&uid3, &isDuplicate));
  77     EXPECT_FALSE(isDuplicate);
  78 }
  79
  80 TEST(PDMAddDeviceTest, ValidUUID)
  81 {
  82     OicUuid_t uid = {{0,}};
  83
  84     uint8_t id[UUID_LENGTH] = {0,};
  85     for (size_t i = 0 ; i < sizeof(id) ; i++)
  86     {
  87         int tem = rand() % 25;
  88
  89         id[i] = tem + 65;
  90     }
  91
  92     memcpy(&uid.id, &id, UUID_LENGTH);
  93
  94     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid));
  95     PDMDeleteDevice(&uid);
  96 }
  97
  98 TEST(PDMLinkDevicesTest, NULLDevice1)
  99 {
 100     OicUuid_t uid = {{0,}};
 101     memcpy(&uid.id, ID_2, sizeof(uid.id));
 102     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMLinkDevices(NULL, &uid));
 103 }
 104
 105 TEST(PDMLinkDevicesTest, NULLDevice2)
 106 {
 107     OicUuid_t uid = {{0,}};
 108     memcpy(&uid.id, ID_3, sizeof(uid.id));
 109     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMLinkDevices(&uid, NULL));
 110 }
 111
 112 TEST(PDMLinkDevicesTest, ValidCase)
 113 {
 114     OicUuid_t uid1 = {{0,}};
 115     memcpy(&uid1.id, ID_4, sizeof(uid1.id));
 116     PDMAddDevice(&uid1);
 117     OicUuid_t uid2 = {{0,}};
 118     memcpy(&uid2.id, ID_5, sizeof(uid2.id));
 119     PDMAddDevice(&uid2);
 120     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid1, &uid2));
 121 }
 122
 123 TEST(PDMUnlinkDevicesTest, NULLDevice1)
 124 {
 125     OicUuid_t uid = {{0,}};
 126     memcpy(&uid.id, ID_3, sizeof(uid.id));
 127     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMUnlinkDevices(NULL, &uid));
 128 }
 129
 130 TEST(PDMUnlinkDevicesTest, NULLDevice2)
 131 {
 132     OicUuid_t uid = {{0,}};
 133     memcpy(&uid.id, ID_3, sizeof(uid.id));
 134     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMUnlinkDevices(&uid, NULL));
 135 }
 136
 137 TEST(PDMUnlinkDevices, ValidCase)
 138 {
 139     OicUuid_t uid1 = {{0,}};
 140     memcpy(&uid1.id, ID_4, sizeof(uid1.id));
 141     OicUuid_t uid2 = {{0,}};
 142     memcpy(&uid2.id, ID_5, sizeof(uid2.id));
 143     EXPECT_EQ(OC_STACK_OK, PDMUnlinkDevices(&uid1, &uid2));
 144 }
 145
 146
 147 TEST (PDMDeleteDevice, NULLDeviceID)
 148 {
 149     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMDeleteDevice(NULL));
 150 }
 151
 152 TEST (PDMDeleteDevice, ValidButNonExistDeviceID)
 153 {
 154
 155     OicUuid_t uid = {{0,}};
 156     uint8_t id[UUID_LENGTH] = {0,};
 157     for (size_t i = 0 ; i < sizeof(id) ; i++)
 158     {
 159         int tem = rand() % 25;
 160
 161         id[i] = tem + 65;
 162     }
 163
 164     memcpy(&uid.id, &id, sizeof(uid.id));
 165     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMDeleteDevice(&uid));
 166 }
 167
 168 TEST(PDMGetOwnedDevices, ValidCase)
 169 {
 170     OCUuidList_t *list = NULL;
 171     size_t noOfDevcies = 0;
 172     EXPECT_EQ(OC_STACK_OK, PDMGetOwnedDevices(&list, &noOfDevcies));
 173 }
 174
 175 TEST(PDMGetLinkedDevices, NULLDeviceID)
 176 {
 177     OCUuidList_t *list = NULL;
 178     size_t noOfDevices = 0;
 179     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMGetLinkedDevices(NULL, &list, &noOfDevices));
 180 }
 181
 182 TEST(PDMGetLinkedDevices, ValidCase)
 183 {
 184     OicUuid_t uid = {{0,}};
 185     memcpy(&uid.id, ID_1, sizeof(uid.id));
 186     OCUuidList_t *list = NULL;
 187     size_t noOfDevices = 0;
 188     EXPECT_EQ(OC_STACK_OK, PDMGetLinkedDevices(&uid, &list, &noOfDevices));
 189 }
 190
 191 TEST(PDMGetLinkedDevices, InvalidCase)
 192 {
 193     OicUuid_t uid = {{0,}};
 194     memcpy(&uid.id, ID_6, sizeof(uid.id));
 195     OCUuidList_t *list = NULL;
 196     size_t noOfDevices = 0;
 197     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMGetLinkedDevices(&uid, &list, &noOfDevices));
 198 }
 199
 200 TEST(PDMSetLinkStale, NULLDeviceID1)
 201 {
 202     OicUuid_t uid = {{0,}};
 203     memcpy(&uid.id, ID_1, sizeof(uid.id));
 204     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetLinkStale(NULL, &uid));
 205 }
 206
 207 TEST(PDMSetLinkStale, NULLDeviceID2)
 208 {
 209     OicUuid_t uid = {{0,}};
 210     memcpy(&uid.id, ID_1, sizeof(uid.id));
 211     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetLinkStale(&uid, NULL));
 212 }
 213
 214 TEST(PDMSetLinkStale, ValidCase)
 215 {
 216     OicUuid_t uid1 = {{0,}};
 217     memcpy(&uid1.id, ID_6, sizeof(uid1.id));
 218     OicUuid_t uid2 = {{0,}};
 219     memcpy(&uid2.id, ID_1, sizeof(uid2.id));
 220
 221     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetLinkStale(&uid1, &uid2));
 222
 223     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 224
 225     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid1, &uid2));
 226
 227     EXPECT_EQ(OC_STACK_OK, PDMSetLinkStale(&uid1, &uid2));
 228 }
 229
 230 TEST(PDMGetToBeUnlinkedDevices, ValidCase)
 231 {
 232     OCPairList_t *list = NULL;
 233     size_t noOfDevices = 0;
 234     EXPECT_EQ(OC_STACK_OK, PDMGetToBeUnlinkedDevices(&list, &noOfDevices));
 235 }
 236
 237 TEST(PDMClose, ValidCase)
 238 {
 239    EXPECT_EQ(OC_STACK_OK, PDMClose());
 240 }
 241
 242 TEST(PDMDestoryOicUuidLinkList, NULLParam)
 243 {
 244     PDMDestoryOicUuidLinkList(NULL);
 245 }
 246
 247 TEST(PDMDestoryStaleLinkList, NULLParam)
 248 {
 249     PDMDestoryStaleLinkList(NULL);
 250 }
 251
 252 TEST(PDMIsLinkExistsTest, DuplicateID)
 253 {
 254     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
 255     OicUuid_t uid1 = {{0,}};
 256     memcpy(&uid1.id, ID_7, sizeof(uid1.id));
 257     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 258     OicUuid_t uid2 = {{0,}};
 259     memcpy(&uid2.id, ID_8, sizeof(uid2.id));
 260     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid2));
 261
 262     bool linkExisits = true;
 263     OCStackResult res = PDMIsLinkExists(&uid1, &uid2, &linkExisits);
 264     EXPECT_EQ(OC_STACK_OK, res);
 265     EXPECT_FALSE(linkExisits);
 266 }