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 "iotivity_config.h"
  21 #include "gtest/gtest.h"
  22 #include "provisioningdatabasemanager.h"
  23
  24 #define DB_FILE "PDM.db"
  25 const char ID_1 [] = "1111111111111111";
  26 const char ID_2 [] = "2111111111111111";
  27 const char ID_3 [] = "3111111111111111";
  28 const char ID_4 [] = "4111111111111111";
  29 const char ID_5 [] = "5111111111111111";
  30 const char ID_6 [] = "6111111111111111";
  31 const char ID_7 [] = "7111111111111111";
  32 const char ID_8 [] = "8111111111111111";
  33 const char ID_9 [] = "9111111111111111";
  34 const char ID_10[] = "1222222222222222";
  35 const char ID_11[] = "2222222222222222";
  36 const char ID_12[] = "3222222222222222";
  37 const char ID_13[] = "4222222222222222";
  38
  39
  40 TEST(CallPDMAPIbeforeInit, BeforeInit)
  41 {
  42     if (0 == access(DB_FILE, F_OK))
  43     {
  44         EXPECT_EQ(0, unlink(DB_FILE));
  45     }
  46     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMAddDevice(NULL));
  47     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMIsDuplicateDevice(NULL,NULL));
  48     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMLinkDevices(NULL, NULL));
  49     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMUnlinkDevices(NULL, NULL));
  50     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMDeleteDevice(NULL));
  51     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMGetOwnedDevices(NULL, NULL));
  52     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMGetLinkedDevices(NULL, NULL, NULL));
  53     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMSetLinkStale(NULL, NULL));
  54     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMGetToBeUnlinkedDevices(NULL, NULL));
  55     EXPECT_EQ(OC_STACK_PDM_IS_NOT_INITIALIZED, PDMIsLinkExists(NULL, NULL, NULL));
  56 }
  57
  58 TEST(PDMInitTest, PDMInitWithNULL)
  59 {
  60     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
  61 }
  62
  63 TEST(PDMAddDeviceTest, NullUUID)
  64 {
  65     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMAddDevice(NULL));
  66 }
  67
  68 TEST(PDMIsDuplicateDeviceTest, NullUUID)
  69 {
  70     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMIsDuplicateDevice(NULL,NULL));
  71 }
  72
  73
  74 TEST(PDMIsDuplicateDeviceTest, ValidUUID)
  75 {
  76     OicUuid_t uid1 = {{0,}};
  77     memcpy(&uid1.id, ID_1, sizeof(uid1.id));
  78     PDMAddDevice(&uid1);
  79     OicUuid_t uid2 = {{0,}};
  80     memcpy(&uid2.id, ID_2, sizeof(uid2.id));
  81     PDMAddDevice(&uid2);
  82     OicUuid_t uid3 = {{0,}};
  83     memcpy(&uid3.id, ID_3, sizeof(uid3.id));
  84     bool isDuplicate = true;
  85     EXPECT_EQ(OC_STACK_OK, PDMIsDuplicateDevice(&uid1,&isDuplicate));
  86     EXPECT_TRUE(isDuplicate);
  87
  88     EXPECT_EQ(OC_STACK_OK, PDMIsDuplicateDevice(&uid3, &isDuplicate));
  89     EXPECT_FALSE(isDuplicate);
  90 }
  91
  92 TEST(PDMAddDeviceTest, ValidUUID)
  93 {
  94     OicUuid_t uid = {{0,}};
  95
  96     uint8_t id[UUID_LENGTH] = {0,};
  97     for (size_t i = 0 ; i < sizeof(id) ; i++)
  98     {
  99         int tem = rand() % 25;
 100
 101         id[i] = tem + 65;
 102     }
 103
 104     memcpy(&uid.id, &id, UUID_LENGTH);
 105
 106     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid));
 107     EXPECT_EQ(OC_STACK_OK, PDMDeleteDevice(&uid));
 108 }
 109
 110 TEST(PDMLinkDevicesTest, NULLDevice1)
 111 {
 112     OicUuid_t uid = {{0,}};
 113     memcpy(&uid.id, ID_2, sizeof(uid.id));
 114     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMLinkDevices(NULL, &uid));
 115 }
 116
 117 TEST(PDMLinkDevicesTest, NULLDevice2)
 118 {
 119     OicUuid_t uid = {{0,}};
 120     memcpy(&uid.id, ID_3, sizeof(uid.id));
 121     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMLinkDevices(&uid, NULL));
 122 }
 123
 124 TEST(PDMLinkDevicesTest, ValidCase)
 125 {
 126     OicUuid_t uid1 = {{0,}};
 127     memcpy(&uid1.id, ID_4, sizeof(uid1.id));
 128     PDMAddDevice(&uid1);
 129     OicUuid_t uid2 = {{0,}};
 130     memcpy(&uid2.id, ID_5, sizeof(uid2.id));
 131     PDMAddDevice(&uid2);
 132     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid1, &uid2));
 133 }
 134
 135 TEST(PDMUnlinkDevicesTest, NULLDevice1)
 136 {
 137     OicUuid_t uid = {{0,}};
 138     memcpy(&uid.id, ID_3, sizeof(uid.id));
 139     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMUnlinkDevices(NULL, &uid));
 140 }
 141
 142 TEST(PDMUnlinkDevicesTest, NULLDevice2)
 143 {
 144     OicUuid_t uid = {{0,}};
 145     memcpy(&uid.id, ID_3, sizeof(uid.id));
 146     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMUnlinkDevices(&uid, NULL));
 147 }
 148
 149 TEST(PDMUnlinkDevices, ValidCase)
 150 {
 151     OicUuid_t uid1 = {{0,}};
 152     memcpy(&uid1.id, ID_4, sizeof(uid1.id));
 153     OicUuid_t uid2 = {{0,}};
 154     memcpy(&uid2.id, ID_5, sizeof(uid2.id));
 155     EXPECT_EQ(OC_STACK_OK, PDMUnlinkDevices(&uid1, &uid2));
 156 }
 157
 158
 159 TEST (PDMDeleteDevice, NULLDeviceID)
 160 {
 161     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMDeleteDevice(NULL));
 162 }
 163
 164 TEST (PDMDeleteDevice, ValidButNonExistDeviceID)
 165 {
 166
 167     OicUuid_t uid = {{0,}};
 168     uint8_t id[UUID_LENGTH] = {0,};
 169     for (size_t i = 0 ; i < sizeof(id) ; i++)
 170     {
 171         int tem = rand() % 25;
 172
 173         id[i] = tem + 65;
 174     }
 175
 176     memcpy(&uid.id, &id, sizeof(uid.id));
 177     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMDeleteDevice(&uid));
 178 }
 179
 180 TEST(PDMGetOwnedDevices, ValidCase)
 181 {
 182     OCUuidList_t *list = NULL;
 183     size_t noOfDevcies = 0;
 184     EXPECT_EQ(OC_STACK_OK, PDMGetOwnedDevices(&list, &noOfDevcies));
 185 }
 186
 187 TEST(PDMGetLinkedDevices, NULLDeviceID)
 188 {
 189     OCUuidList_t *list = NULL;
 190     size_t noOfDevices = 0;
 191     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMGetLinkedDevices(NULL, &list, &noOfDevices));
 192 }
 193
 194 TEST(PDMGetLinkedDevices, ValidCase)
 195 {
 196     OicUuid_t uid = {{0,}};
 197     memcpy(&uid.id, ID_1, sizeof(uid.id));
 198     OCUuidList_t *list = NULL;
 199     size_t noOfDevices = 0;
 200     EXPECT_EQ(OC_STACK_OK, PDMGetLinkedDevices(&uid, &list, &noOfDevices));
 201 }
 202
 203 TEST(PDMGetLinkedDevices, InvalidCase)
 204 {
 205     OicUuid_t uid = {{0,}};
 206     memcpy(&uid.id, ID_6, sizeof(uid.id));
 207     OCUuidList_t *list = NULL;
 208     size_t noOfDevices = 0;
 209     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMGetLinkedDevices(&uid, &list, &noOfDevices));
 210 }
 211
 212 TEST(PDMSetLinkStale, NULLDeviceID1)
 213 {
 214     OicUuid_t uid = {{0,}};
 215     memcpy(&uid.id, ID_1, sizeof(uid.id));
 216     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetLinkStale(NULL, &uid));
 217 }
 218
 219 TEST(PDMSetLinkStale, NULLDeviceID2)
 220 {
 221     OicUuid_t uid = {{0,}};
 222     memcpy(&uid.id, ID_1, sizeof(uid.id));
 223     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetLinkStale(&uid, NULL));
 224 }
 225
 226 TEST(PDMSetLinkStale, ValidCase)
 227 {
 228     OicUuid_t uid1 = {{0,}};
 229     memcpy(&uid1.id, ID_6, sizeof(uid1.id));
 230     OicUuid_t uid2 = {{0,}};
 231     memcpy(&uid2.id, ID_1, sizeof(uid2.id));
 232
 233     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetLinkStale(&uid1, &uid2));
 234
 235     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 236
 237     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid1, &uid2));
 238
 239     EXPECT_EQ(OC_STACK_OK, PDMSetLinkStale(&uid1, &uid2));
 240 }
 241
 242 TEST(PDMGetToBeUnlinkedDevices, ValidCase)
 243 {
 244     OCPairList_t *list = NULL;
 245     size_t noOfDevices = 0;
 246     EXPECT_EQ(OC_STACK_OK, PDMGetToBeUnlinkedDevices(&list, &noOfDevices));
 247 }
 248
 249 TEST(PDMClose, ValidCase)
 250 {
 251    EXPECT_EQ(OC_STACK_OK, PDMClose());
 252 }
 253
 254 TEST(PDMDestoryOicUuidLinkList, NULLParam)
 255 {
 256     PDMDestoryOicUuidLinkList(NULL);
 257 }
 258
 259 TEST(PDMDestoryStaleLinkList, NULLParam)
 260 {
 261     PDMDestoryStaleLinkList(NULL);
 262 }
 263
 264 TEST(PDMIsLinkExistsTest, DuplicateID)
 265 {
 266     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
 267     OicUuid_t uid1 = {{0,}};
 268     memcpy(&uid1.id, ID_7, sizeof(uid1.id));
 269     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 270     OicUuid_t uid2 = {{0,}};
 271     memcpy(&uid2.id, ID_8, sizeof(uid2.id));
 272     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid2));
 273
 274     bool linkExisits = true;
 275     OCStackResult res = PDMIsLinkExists(&uid1, &uid2, &linkExisits);
 276     EXPECT_EQ(OC_STACK_OK, res);
 277     EXPECT_FALSE(linkExisits);
 278 }
 279
 280 TEST(PDMSetDeviceStaleTest, NULLUUID)
 281 {
 282     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
 283     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMSetDeviceStale(NULL));
 284 }
 285
 286 TEST(PDMSetDeviceStaleTest, VALIDUUID)
 287 {
 288     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
 289     OicUuid_t uid1 = {{0,}};
 290     memcpy(&uid1.id, ID_9, sizeof(uid1.id));
 291     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 292     EXPECT_EQ(OC_STACK_OK,PDMSetDeviceStale(&uid1));
 293 }
 294
 295 TEST(PDMSetDeviceStaleTest, StaleDeviceNotinDeviceList)
 296 {
 297     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
 298     OicUuid_t uid1 = {{0,}};
 299     memcpy(&uid1.id, ID_10, sizeof(uid1.id));
 300     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 301     EXPECT_EQ(OC_STACK_OK,PDMSetDeviceStale(&uid1));
 302
 303     OCUuidList_t *list = NULL;
 304     size_t noOfDevcies = 0;
 305     EXPECT_EQ(OC_STACK_OK, PDMGetOwnedDevices(&list, &noOfDevcies));
 306
 307     while (list)
 308     {
 309         EXPECT_FALSE(0 == memcmp(list->dev.id, uid1.id,sizeof(uid1.id)));
 310         list = list->next;
 311     }
 312 }
 313
 314 TEST(PDMSetDeviceStaleTest, StaleDeviceNotinLinkedDevice)
 315 {
 316     EXPECT_EQ(OC_STACK_OK, PDMInit(NULL));
 317     OicUuid_t uid1 = {{0,}};
 318     memcpy(&uid1.id, ID_11, sizeof(uid1.id));
 319
 320     OicUuid_t uid2 = {{0,}};
 321     memcpy(&uid2.id, ID_12, sizeof(uid2.id));
 322
 323     OicUuid_t uid3 = {{0,}};
 324     memcpy(&uid3.id, ID_13, sizeof(uid3.id));
 325
 326     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid1));
 327     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid2));
 328     EXPECT_EQ(OC_STACK_OK, PDMAddDevice(&uid3));
 329
 330     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid1, &uid2));
 331     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid2, &uid3));
 332     EXPECT_EQ(OC_STACK_OK, PDMLinkDevices(&uid1, &uid3));
 333
 334     EXPECT_EQ(OC_STACK_OK,PDMSetDeviceStale(&uid1));
 335
 336     OCUuidList_t *list1 = NULL;
 337     size_t noOfDevices1 = 0;
 338     EXPECT_EQ(OC_STACK_INVALID_PARAM, PDMGetLinkedDevices(&uid1, &list1, &noOfDevices1));
 339
 340     OCUuidList_t *list2 = NULL;
 341     size_t noOfDevices2 = 0;
 342     EXPECT_EQ(OC_STACK_OK, PDMGetLinkedDevices(&uid2, &list2, &noOfDevices2));
 343     OCUuidList_t *ptr = list2;
 344     while(ptr)
 345     {
 346         EXPECT_FALSE(0 == memcmp(ptr->dev.id, uid1.id,sizeof(uid1.id)));
 347         ptr = ptr->next;
 348     }
 349     ptr = list2;
 350     while(ptr)
 351     {
 352         EXPECT_TRUE(0 == memcmp(ptr->dev.id, uid3.id,sizeof(uid3.id)));
 353         ptr = ptr->next;
 354     }
 355
 356     OCUuidList_t *list3 = NULL;
 357     size_t noOfDevices3 = 0;
 358     EXPECT_EQ(OC_STACK_OK, PDMGetLinkedDevices(&uid3, &list3, &noOfDevices3));
 359     ptr = list3;
 360     while(ptr)
 361     {
 362         EXPECT_FALSE(0 == memcmp(ptr->dev.id, uid1.id,sizeof(uid1.id)));
 363         ptr = ptr->next;
 364     }
 365
 366     ptr = list3;
 367     while(ptr)
 368     {
 369         EXPECT_TRUE(0 == memcmp(ptr->dev.id, uid2.id,sizeof(uid2.id)));
 370         ptr = ptr->next;
 371     }
 372 }