test/persistence_client_library_test.c

   1 /******************************************************************************
   2  * Project         Persistency
   3  * (c) copyright   2012
   4  * Company         XS Embedded GmbH
   5  *****************************************************************************/
   6 /******************************************************************************
   7  * This Source Code Form is subject to the terms of the
   8  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed
   9  * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  10 ******************************************************************************/
  11  /**
  12  * @file           persistence_client_library_test.c
  13  * @ingroup        Persistence client library test
  14  * @author         Ingo Huerner
  15  * @brief          Test of persistence client library
  16  * @see
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <unistd.h>     /* exit */
  24 #include <check.h>
  25 #include <time.h>
  26 #include <fcntl.h>
  27 #include <sys/mman.h>
  28
  29 #include "../include/persistence_client_library_key.h"
  30 #include "../include/persistence_client_library_file.h"
  31 #include "../include/persistence_client_library_error_def.h"
  32
  33
  34 // protected header, should be used only be persistence components
  35 // included here for testing purpose
  36 #include "../include_protected/persistence_client_library_db_access.h"
  37
  38
  39 #define BUF_SIZE     64
  40 #define NUM_OF_FILES 3
  41 #define READ_SIZE    1024
  42
  43 // definition of weekday
  44 char* dayOfWeek[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
  45
  46
  47
  48 /**
  49  * Test the key value interface using different logicalDB id's, users and seats.
  50  * Each resource below has an entry in the resource configuration table where the
  51  * storage location (cached or write through) and type (e.g. custom) has been configured.
  52  */
  53 START_TEST (test_GetData)
  54 {
  55    int ret = 0;
  56    unsigned char buffer[READ_SIZE];
  57    memset(buffer, 0, READ_SIZE);
  58
  59    /**
  60     * Logical DB ID: 0xFF with user 0 and seat 0
  61     *       ==> local value accessible by all users (user 0, seat 0)
  62     */
  63    ret = pclKeyReadData(0xFF, "language/country_code",         0, 0, buffer, READ_SIZE);
  64    fail_unless(strncmp((char*)buffer, "Custom plugin -> plugin_get_data_handle",
  65                strlen((char*)buffer)) == 0, "Buffer not correctly read");
  66    fail_unless(ret = strlen("Custom plugin -> plugin_get_data_handle"));
  67
  68    memset(buffer, 0, READ_SIZE);
  69
  70    /**
  71     * Logical DB ID: 0xFF with user 0 and seat 0
  72     *       ==> local value accessible by all users (user 0, seat 0)
  73     */
  74    ret = pclKeyReadData(0xFF, "pos/last_position",         0, 0, buffer, READ_SIZE);
  75    fail_unless(strncmp((char*)buffer, "CACHE_ +48° 10' 38.95\", +8° 44' 39.06\"",
  76                strlen((char*)buffer)) == 0, "Buffer not correctly read");
  77    fail_unless(ret = strlen("CACHE_ +48° 10' 38.95\", +8° 44' 39.06\""));
  78
  79    memset(buffer, 0, READ_SIZE);
  80
  81    /**
  82     * Logical DB ID: 0 with user 3 and seat 0
  83     *       ==> public shared user value (user 3, seat 0)
  84     */
  85    ret = pclKeyReadData(0,    "language/current_language", 3, 0, buffer, READ_SIZE);
  86    fail_unless(strncmp((char*)buffer, "CACHE_ Kisuaheli", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  87
  88    memset(buffer, 0, READ_SIZE);
  89
  90    /**
  91     * Logical DB ID: 0xFF with user 3 and seat 2
  92     *       ==> local USER value (user 3, seat 2)
  93     */
  94    ret = pclKeyReadData(0xFF, "status/open_document",      3, 2, buffer, READ_SIZE);
  95    fail_unless(strncmp((char*)buffer, "WT_ /var/opt/user_manual_climateControl.pdf", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  96
  97    memset(buffer, 0, READ_SIZE);
  98
  99    /**
 100     * Logical DB ID: 0x20 with user 4 and seat 0
 101     *       ==> shared user value accessible by a group (user 4 and seat 0)
 102     */
 103    ret = pclKeyReadData(0x20, "address/home_address",      4, 0, buffer, READ_SIZE);
 104    fail_unless(strncmp((char*)buffer, "WT_ 55327 Heimatstadt, Wohnstrasse 31", strlen((char*)buffer)) == 0, "Buffer not correctly read");
 105
 106    memset(buffer, 0, READ_SIZE);
 107
 108    /**
 109     * Logical DB ID: 0xFF with user 0 and seat 0
 110     *       ==> local value accessible by ALL USERS (user 0, seat 0)
 111     */
 112    ret = pclKeyReadData(0xFF, "pos/last_satellites",       0, 0, buffer, READ_SIZE);
 113    fail_unless(strncmp((char*)buffer, "WT_ 17", strlen((char*)buffer)) == 0, "Buffer not correctly read");
 114
 115    memset(buffer, 0, READ_SIZE);
 116
 117    /**
 118     * Logical DB ID: 0x84 with user 4 and seat 0
 119     *       ==> shared user value accessible by A GROUP (user 4 and seat 0)
 120     */
 121    ret = pclKeyReadData(0x84, "links/last_link",           2, 0, buffer, READ_SIZE);
 122    fail_unless(strncmp((char*)buffer, "CACHE_ /last_exit/brooklyn", strlen((char*)buffer)) == 0, "Buffer not correctly read");
 123
 124    memset(buffer, 0, READ_SIZE);
 125
 126    /**
 127     * Logical DB ID: 0x84 with user 2 and seat 1
 128     *       ==> local merge value
 129     */
 130    ret = pclKeyReadData(0x84, "links/last_link",           2, 1, buffer, READ_SIZE);
 131    fail_unless(strncmp((char*)buffer, "CACHE_ /last_exit/queens", strlen((char*)buffer)) == 0, "Buffer not correctly read");
 132 }
 133 END_TEST
 134
 135
 136
 137 /**
 138  * Test the key value  h a n d l e  interface using different logicalDB id's, users and seats
 139  * Each resource below has an entry in the resource configuration table where
 140  * the storage location (cached or write through) and type (e.g. custom) has bee configured.
 141  */
 142 START_TEST (test_GetDataHandle)
 143 {
 144    int ret = 0, handle = 0, handle2 = 0, handle3 = 0, handle4 = 0, size = 0;
 145    unsigned char buffer[READ_SIZE];
 146    struct tm *locTime;
 147    time_t t = time(0);
 148
 149    char sysTimeBuffer[128];
 150    memset(buffer, 0, READ_SIZE);
 151
 152    locTime = localtime(&t);
 153
 154    snprintf(sysTimeBuffer, 128, "TimeAndData: \"%s %d.%d.%d - %d:%.2d:%.2d Uhr\"", dayOfWeek[locTime->tm_wday], locTime->tm_mday, locTime->tm_mon, (locTime->tm_year+1900),
 155                                                                   locTime->tm_hour, locTime->tm_min, locTime->tm_sec);
 156
 157
 158    // open handle ---------------------------------------------------
 159    /**
 160     * Logical DB ID: 0xFF with user 0 and seat 0
 161     *       ==> local value accessible by ALL USERS (user 0, seat 0)
 162     */
 163    handle = pclKeyHandleOpen(0xFF, "posHandle/last_position", 0, 0);
 164    fail_unless(handle >= 0, "Failed to open handle ==> /posHandle/last_position");
 165
 166    ret = pclKeyHandleReadData(handle, buffer, READ_SIZE);
 167    fail_unless(strncmp((char*)buffer, "WT_ H A N D L E: +48° 10' 38.95\", +8° 44' 39.06\"", ret-1) == 0, "Buffer not correctly read");
 168
 169    size = pclKeyHandleGetSize(handle);
 170    fail_unless(size = strlen("WT_ H A N D L E: +48° 10' 38.95\", +8° 44' 39.06\""));
 171    // ---------------------------------------------------------------------------------------------
 172
 173
 174    // open handle ---------------------------------------------------
 175    /**
 176     * Logical DB ID: 0xFF with user 3 and seat 2
 177     *       ==> local USER value (user 3, seat 2)
 178     */
 179    handle2 = pclKeyHandleOpen(0xFF, "statusHandle/open_document", 3, 2);
 180    fail_unless(handle2 >= 0, "Failed to open handle /statusHandle/open_document");
 181
 182    size = pclKeyHandleWriteData(handle2, (unsigned char*)sysTimeBuffer, strlen(sysTimeBuffer));
 183    fail_unless(size = strlen(sysTimeBuffer));
 184    // close
 185    ret = pclKeyHandleClose(handle2);
 186    // ---------------------------------------------------------------------------------------------
 187
 188
 189    // open handle ---------------------------------------------------
 190    /**
 191     * Logical DB ID: 0xFF with user 0 and seat 0
 192     *       ==> local value accessible by ALL USERS (user 0, seat 0)
 193     */
 194    memset(buffer, 0, READ_SIZE);
 195    handle4 = pclKeyHandleOpen(0xFF, "language/country_code", 0, 0);
 196    fail_unless(handle4 >= 0, "Failed to open handle /language/country_code");
 197
 198    ret = pclKeyHandleReadData(handle4, buffer, READ_SIZE);
 199    fail_unless(strncmp((char*)buffer, "Custom plugin -> plugin_get_data_handle", -1) == 0, "Buffer not correctly read");
 200
 201    size = pclKeyHandleGetSize(handle4);
 202    fail_unless(size = strlen("Custom plugin -> plugin_get_data_handle"));
 203
 204    ret = pclKeyHandleWriteData(handle4, (unsigned char*)"Only dummy implementation behind custom library", READ_SIZE);
 205    // ---------------------------------------------------------------------------------------------
 206
 207
 208    // open handle ---------------------------------------------------
 209    /**
 210     * Logical DB ID: 0xFF with user 3 and seat 2
 211     *       ==> local USER value (user 3, seat 2)
 212     */
 213    handle3 = pclKeyHandleOpen(0xFF, "statusHandle/open_document", 3, 2);
 214    fail_unless(handle3 >= 0, "Failed to open handle /statusHandle/open_document");
 215
 216    ret = pclKeyHandleReadData(handle3, buffer, READ_SIZE);
 217    fail_unless(strncmp((char*)buffer, sysTimeBuffer, strlen(sysTimeBuffer)) == 0, "Buffer not correctly read");
 218
 219    size = pclKeyHandleGetSize(handle3);
 220    fail_unless(size = strlen(sysTimeBuffer));
 221    // ---------------------------------------------------------------------------------------------
 222
 223
 224    // close handle
 225    ret = pclKeyHandleClose(handle);
 226    ret = pclKeyHandleClose(handle3);
 227    ret = pclKeyHandleClose(handle4);
 228 }
 229 END_TEST
 230
 231
 232
 233 /*
 234  * Write data to a key using the key interface.
 235  * First write data to different keys and after
 236  * read the data for verification.
 237  */
 238 START_TEST(test_SetData)
 239 {
 240    int ret = 0;
 241    unsigned char buffer[READ_SIZE];
 242    char write1[READ_SIZE];
 243    char write2[READ_SIZE];
 244    char sysTimeBuffer[256];
 245
 246    struct tm *locTime;
 247    time_t t = time(0);
 248
 249    locTime = localtime(&t);
 250    memset(buffer, 0, READ_SIZE);
 251    memset(write1, 0, READ_SIZE);
 252    memset(write2, 0, READ_SIZE);
 253
 254    // write data
 255    snprintf(sysTimeBuffer, 128, "\"%s %d.%d.%d - %d:%.2d:%.2d Uhr\"", dayOfWeek[locTime->tm_wday], locTime->tm_mday, locTime->tm_mon, (locTime->tm_year+1900),
 256                                                                  locTime->tm_hour, locTime->tm_min, locTime->tm_sec);
 257
 258    /**
 259     * Logical DB ID: 0xFF with user 1 and seat 2
 260     *       ==> local USER value (user 1, seat 2)
 261     * Resource ID: 69
 262     */
 263    ret = pclKeyWriteData(0xFF, "69", 1, 2, (unsigned char*)sysTimeBuffer, strlen(sysTimeBuffer));
 264    fail_unless(ret == strlen(sysTimeBuffer), "Wrong write size");
 265
 266    snprintf(write1, 128, "%s %s", "/70",  sysTimeBuffer);
 267    /**
 268     * Logical DB ID: 0xFF with user 1 and seat 2
 269     *       ==> local USER value (user 1, seat 2)
 270     * Resource ID: 70
 271     */
 272    ret = pclKeyWriteData(0xFF, "70", 1, 2, (unsigned char*)write1, strlen(write1));
 273    fail_unless(ret == strlen(write1), "Wrong write size");
 274
 275    snprintf(write2, 128, "%s %s", "/key_70",  sysTimeBuffer);
 276    /**
 277     * Logical DB ID: 0xFF with user 1 and seat 2
 278     *       ==> local USER value (user 1, seat 2)
 279     * Resource ID: key_70
 280     */
 281    ret = pclKeyWriteData(0xFF, "key_70", 1, 2, (unsigned char*)write2, strlen(write2));
 282    fail_unless(ret == strlen(write2), "Wrong write size");
 283
 284
 285    /*******************************************************************************************************************************************/
 286    /* used for changed notification testing */
 287    /*******************************************************************************************************************************************/
 288    /**
 289     * Logical DB ID: 0x84 with user 2 and seat 1
 290     *       ==> shared user value accessible by A GROUP (user 2 and seat 1)
 291     *
 292     *       ==> used for shared testing
 293     */
 294    printf("Write data to trigger change notification\n");
 295    ret = pclKeyWriteData(0x84, "links/last_link2",  2, 1, (unsigned char*)"Test notify shared data", strlen("Test notify shared data"));
 296
 297    /**
 298     * Logical DB ID: 0x84 with user 2 and seat 1
 299     *       ==> shared user value accessible by A GROUP (user 2 and seat 1)
 300     *
 301     *       ==> used for shared testing
 302     */
 303    printf("Write data to trigger change notification\n");
 304    ret = pclKeyWriteData(0x84, "links/last_link3",  3, 2, (unsigned char*)"Test notify shared data", strlen("Test notify shared data"));
 305
 306    /**
 307     * Logical DB ID: 0x84 with user 2 and seat 1
 308     *       ==> shared user value accessible by A GROUP (user 2 and seat 1)
 309     *
 310     *       ==> used for shared testing
 311     */
 312    printf("Write data to trigger change notification\n");
 313    ret = pclKeyWriteData(0x84, "links/last_link4",  4, 1, (unsigned char*)"Test notify shared data", strlen("Test notify shared data"));
 314    /*******************************************************************************************************************************************/
 315    /*******************************************************************************************************************************************/
 316
 317
 318    /*
 319     * now read the data written in the previous steps to the keys
 320     * and verify data has been written correctly.
 321     */
 322    memset(buffer, 0, READ_SIZE);
 323
 324    ret = pclKeyReadData(0xFF, "69", 1, 2, buffer, READ_SIZE);
 325    fail_unless(strncmp((char*)buffer, sysTimeBuffer, strlen(sysTimeBuffer)) == 0, "Buffer not correctly read");
 326    fail_unless(ret == strlen(sysTimeBuffer), "Wrong read size");
 327
 328    memset(buffer, 0, READ_SIZE);
 329
 330    ret = pclKeyReadData(0xFF, "70", 1, 2, buffer, READ_SIZE);
 331    fail_unless(strncmp((char*)buffer, write1, strlen(write1)) == 0, "Buffer not correctly read");
 332    fail_unless(ret == strlen(write1), "Wrong read size");
 333
 334    memset(buffer, 0, READ_SIZE);
 335
 336    ret = pclKeyReadData(0xFF, "key_70", 1, 2, buffer, READ_SIZE);
 337    fail_unless(strncmp((char*)buffer, write2, strlen(write2)) == 0, "Buffer not correctly read");
 338    fail_unless(ret == strlen(write2), "Wrong read size");
 339
 340 }
 341 END_TEST
 342
 343
 344
 345 /**
 346  * Write data to a key using the key interface.
 347  * The key is not in the persistence resource table.
 348  * The key sill then be stored to the location local and cached.
 349  */
 350 START_TEST(test_SetDataNoPRCT)
 351 {
 352    int ret = 0;
 353    unsigned char buffer[READ_SIZE];
 354    struct tm *locTime;
 355    time_t t = time(0);
 356
 357    char sysTimeBuffer[128];
 358    memset(buffer, 0, READ_SIZE);
 359
 360    locTime = localtime(&t);
 361
 362    snprintf(sysTimeBuffer, 128, "TimeAndData: \"%s %d.%d.%d - %d:%.2d:%.2d Uhr\"", dayOfWeek[locTime->tm_wday], locTime->tm_mday, locTime->tm_mon, (locTime->tm_year+1900),
 363                                                                   locTime->tm_hour, locTime->tm_min, locTime->tm_sec);
 364
 365    /**
 366     * Logical DB ID: 0xFF with user 1 and seat 2
 367     *       ==> local USER value (user 1, seat 2)
 368     */
 369    ret = pclKeyWriteData(0xFF, "NoPRCT", 1, 2, (unsigned char*)sysTimeBuffer, strlen(sysTimeBuffer));
 370    fail_unless(ret == strlen(sysTimeBuffer), "Wrong write size");
 371    printf("Write Buffer : %s\n", sysTimeBuffer);
 372
 373    // read data again and and verify datat has been written correctly
 374    memset(buffer, 0, READ_SIZE);
 375
 376    ret = pclKeyReadData(0xFF, "NoPRCT", 1, 2, buffer, READ_SIZE);
 377    fail_unless(strncmp((char*)buffer, sysTimeBuffer, strlen(sysTimeBuffer)) == 0, "Buffer not correctly read");
 378    fail_unless(ret == strlen(sysTimeBuffer), "Wrong read size");
 379    printf("read buffer  : %s\n", buffer);
 380
 381 }
 382 END_TEST
 383
 384
 385
 386 /*
 387  * Test the key interface.
 388  * Read the size of a key.
 389  */
 390 START_TEST(test_GetDataSize)
 391 {
 392    int size = 0;
 393
 394    /**
 395     * Logical DB ID: 0xFF with user 3 and seat 2
 396     *       ==> local USER value (user 3, seat 2)
 397     */
 398    size = pclKeyGetSize(0xFF, "status/open_document", 3, 2);
 399    fail_unless(size == strlen("WT_ /var/opt/user_manual_climateControl.pdf"), "Invalid size");
 400
 401
 402    /**
 403     * Logical DB ID: 0x84 with user 2 and seat 1
 404     *       ==> shared user value accessible by A GROUP (user 2 and seat 1)
 405     */
 406    size = pclKeyGetSize(0x84, "links/last_link", 2, 1);
 407    fail_unless(size == strlen("CACHE_ /last_exit/queens"), "Invalid size");
 408 }
 409 END_TEST
 410
 411
 412 /*
 413  * Delete a key using the key value interface.
 414  * First read a from a key, the delte the key
 415  * and then try to read again. The Last read must fail.
 416  */
 417 START_TEST(test_DeleteData)
 418 {
 419    int rval = 0;
 420    unsigned char buffer[READ_SIZE];
 421
 422    // read data from key
 423    rval = pclKeyReadData(0xFF, "key_70", 1, 2, buffer, READ_SIZE);
 424    fail_unless(rval != EPERS_NOKEY, "Read form key key_70 fails");
 425
 426    // delete key
 427    rval = pclKeyDelete(0xFF, "key_70", 1, 2);
 428    fail_unless(rval == 0, "Failed to delete key");
 429
 430    // after deleting the key, reading from key must fail now!
 431    rval = pclKeyReadData(0xFF, "key_70", 1, 2, buffer, READ_SIZE);
 432    fail_unless(rval == EPERS_NOKEY, "Read form key key_70 works, but should fail");
 433
 434
 435
 436    // read data from key
 437    rval = pclKeyReadData(0xFF, "70", 1, 2, buffer, READ_SIZE);
 438    fail_unless(rval != EPERS_NOKEY, "Read form key 70 fails");
 439
 440    // delete key
 441    rval = pclKeyDelete(0xFF, "70", 1, 2);
 442    fail_unless(rval == 0, "Failed to delete key");
 443
 444    // after deleting the key, reading from key must fail now!
 445    rval = pclKeyReadData(0xFF, "70", 1, 2, buffer, READ_SIZE);
 446    fail_unless(rval == EPERS_NOKEY, "Read form key 70 works, but should fail");
 447 }
 448 END_TEST
 449
 450
 451
 452 /*
 453  * Test the file interface:
 454  * - open file
 455  * - read / write
 456  * - remove file
 457  * - map file
 458  * - get size
 459  */
 460 START_TEST(test_DataFile)
 461 {
 462    int fd = 0, i = 0, idx = 0;
 463    int size = 0, ret = 0;
 464    int writeSize = 16*1024;
 465    unsigned char buffer[READ_SIZE];
 466    const char* refBuffer = "/Data/mnt-wt/lt-persistence_client_library_test/user/1/seat/1/media";
 467    char* writeBuffer;
 468    char* fileMap = NULL;
 469    writeBuffer = malloc(writeSize);
 470
 471
 472    // fill buffer a sequence
 473    for(i = 0; i<(writeSize/8); i++)
 474    {
 475       writeBuffer[idx++] = 'A';
 476       writeBuffer[idx++] = 'B';
 477       writeBuffer[idx++] = 'C';
 478       writeBuffer[idx++] = ' ';
 479       writeBuffer[idx++] = 'D';
 480       writeBuffer[idx++] = 'E';
 481       writeBuffer[idx++] = 'F';
 482       writeBuffer[idx++] = ' ';
 483    }
 484    memset(buffer, 0, READ_SIZE);
 485
 486    // create file
 487    fd = open("/Data/mnt-wt/lt-persistence_client_library_test/user/1/seat/1/media/mediaDBWrite.db",
 488              O_CREAT|O_RDWR|O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
 489    close(fd);
 490
 491    // open ------------------------------------------------------------
 492    fd = pclFileOpen(0xFF, "media/mediaDB.db", 1, 1);
 493    fail_unless(fd != -1, "Could not open file ==> /media/mediaDB.db");
 494
 495    size = pclFileGetSize(fd);
 496    fail_unless(size == 68, "Wrong file size");
 497
 498    size = pclFileReadData(fd, buffer, READ_SIZE);
 499    fail_unless(strncmp((char*)buffer, refBuffer, strlen(refBuffer)) == 0, "Buffer not correctly read => media/mediaDB.db");
 500    fail_unless(size == (strlen(refBuffer)+1), "Wrong size returned");      // strlen + 1 ==> inlcude cr/lf
 501
 502    ret = pclFileClose(fd);
 503    fail_unless(ret == 0, "Failed to close file");
 504
 505
 506    // open ------------------------------------------------------------
 507    fd = pclFileOpen(0xFF, "media/mediaDBWrite.db", 1, 1);
 508    fail_unless(fd != -1, "Could not open file ==> /media/mediaDBWrite.db");
 509
 510    size = pclFileWriteData(fd, writeBuffer, strlen(writeBuffer));
 511    fail_unless(size == strlen(writeBuffer), "Failed to write data");
 512
 513    ret = pclFileClose(fd);
 514    fail_unless(ret == 0, "Failed to close file");
 515
 516
 517    // remove ----------------------------------------------------------
 518    ret = pclFileRemove(0xFF, "media/mediaDBWrite.db", 1, 1);
 519    fail_unless(ret == 0, "File can't be removed ==> /media/mediaDBWrite.db");
 520
 521    fd = open("/Data/mnt-wt/lt-persistence_client_library_test/user/1/seat/1/media/mediaDBWrite.db",O_RDWR);
 522    fail_unless(fd == -1, "Failed to remove file, file still exists");
 523    close(fd);
 524
 525
 526    // map file --------------------------------------------------------
 527    fd = pclFileOpen(0xFF, "media/mediaDB.db", 1, 1);
 528
 529    size = pclFileGetSize(fd);
 530    pclFileMapData(fileMap, size, 0, fd);
 531    fail_unless(fileMap != MAP_FAILED, "Failed to map file");
 532
 533    ret = pclFileUnmapData(fileMap, size);
 534    fail_unless(ret != -1, "Failed to unmap file");
 535
 536    // negative test
 537    size = pclFileGetSize(1024);
 538    fail_unless(ret == 0, "Got size, but should not");
 539
 540    ret = pclFileClose(fd);
 541    fail_unless(ret == 0, "Failed to close file");
 542
 543    free(writeBuffer);
 544 }
 545 END_TEST
 546
 547
 548
 549
 550 START_TEST(test_DataFileRecovery)
 551 {
 552    int fd_RW = 0, fd_RO = 0;
 553    int ret = 0;
 554    char* wBuffer = "This is a buffer to write";
 555
 556    // test backup creation --------------------------------------------
 557    fd_RO = pclFileOpen(0xFF, "media/mediaDB_ReadOnly.db", 1, 1);
 558    fail_unless(fd_RO != -1, "Could not open file ==> /media/mediaDB_ReadOnly.db");
 559
 560    fd_RW = pclFileOpen(0xFF, "media/mediaDB_ReadWrite.db", 1, 1);
 561    fail_unless(fd_RW != -1, "Could not open file ==> /media/mediaDB_ReadWrite.db");
 562    pclFileWriteData(fd_RW, wBuffer, strlen(wBuffer));
 563
 564    ret = pclFileClose(fd_RW);
 565    ret = pclFileClose(fd_RO);
 566
 567 }
 568 END_TEST
 569
 570 /*
 571  * The the handle function of the key and file interface.
 572  */
 573 START_TEST(test_DataHandle)
 574 {
 575    int handle1 = 0, handle2 = 0;
 576    int ret = 0;
 577
 578    // test file handles
 579    handle1 = pclFileOpen(0xFF, "media/mediaDB.db", 1, 1);
 580    fail_unless(handle1 != -1, "Could not open file ==> /media/mediaDB.db");
 581
 582    ret = pclFileClose(handle1);
 583    fail_unless(handle1 != -1, "Could not closefile ==> /media/mediaDB.db");
 584
 585    ret = pclFileClose(1024);
 586    fail_unless(ret == -1, "Could close file, but should not!!");
 587
 588    ret = pclFileClose(17);
 589    fail_unless(ret == -1, "Could close file, but should not!!");
 590
 591
 592
 593    // test key handles
 594    handle2 = pclKeyHandleOpen(0xFF, "statusHandle/open_document", 3, 2);
 595    fail_unless(handle2 >= 0, "Failed to open handle /statusHandle/open_document");
 596
 597    ret = pclKeyHandleClose(handle2);
 598    fail_unless(ret != -1, "Failed to close handle!!");
 599
 600    ret = pclKeyHandleClose(1024);
 601    fail_unless(ret == -1, "Could close, but should not!!");
 602 }
 603 END_TEST
 604
 605
 606
 607 /*
 608  * Extended key handle test.
 609  * Test have been created after a bug in the key handle function occured.
 610  */
 611 START_TEST(test_DataHandleOpen)
 612 {
 613    int hd1 = -2, hd2 = -2, hd3 = -2, hd4 = -2, hd5 = -2, hd6 = -2, hd7 = -2, hd8 = -2, hd9 = -2, ret = 0;
 614
 615    // open handles ----------------------------------------------------
 616    hd1 = pclKeyHandleOpen(0xFF, "posHandle/last_position1", 0, 0);
 617    fail_unless(hd1 == 1, "Failed to open handle ==> /posHandle/last_position1");
 618
 619    hd2 = pclKeyHandleOpen(0xFF, "posHandle/last_position2", 0, 0);
 620    fail_unless(hd2 == 2, "Failed to open handle ==> /posHandle/last_position2");
 621
 622    hd3 = pclKeyHandleOpen(0xFF, "posHandle/last_position3", 0, 0);
 623    fail_unless(hd3 == 3, "Failed to open handle ==> /posHandle/last_position3");
 624
 625    // close handles ---------------------------------------------------
 626    ret = pclKeyHandleClose(hd1);
 627    fail_unless(ret != -1, "Failed to close handle!!");
 628
 629    ret = pclKeyHandleClose(hd2);
 630    fail_unless(ret != -1, "Failed to close handle!!");
 631
 632    ret = pclKeyHandleClose(hd3);
 633    fail_unless(ret != -1, "Failed to close handle!!");
 634
 635    // open handles ----------------------------------------------------
 636    hd4 = pclKeyHandleOpen(0xFF, "posHandle/last_position4", 0, 0);
 637    fail_unless(hd4 == 3, "Failed to open handle ==> /posHandle/last_position4");
 638
 639    hd5 = pclKeyHandleOpen(0xFF, "posHandle/last_position5", 0, 0);
 640    fail_unless(hd5 == 2, "Failed to open handle ==> /posHandle/last_position5");
 641
 642    hd6 = pclKeyHandleOpen(0xFF, "posHandle/last_position6", 0, 0);
 643    fail_unless(hd6 == 1, "Failed to open handle ==> /posHandle/last_position6");
 644
 645    hd7 = pclKeyHandleOpen(0xFF, "posHandle/last_position7", 0, 0);
 646    fail_unless(hd7 == 4, "Failed to open handle ==> /posHandle/last_position7");
 647
 648    hd8 = pclKeyHandleOpen(0xFF, "posHandle/last_position8", 0, 0);
 649    fail_unless(hd8 == 5, "Failed to open handle ==> /posHandle/last_position8");
 650
 651    hd9 = pclKeyHandleOpen(0xFF, "posHandle/last_position9", 0, 0);
 652    fail_unless(hd9 == 6, "Failed to open handle ==> /posHandle/last_position9");
 653
 654    // close handles ---------------------------------------------------
 655    ret = pclKeyHandleClose(hd4);
 656    fail_unless(ret != -1, "Failed to close handle!!");
 657
 658    ret = pclKeyHandleClose(hd5);
 659    fail_unless(ret != -1, "Failed to close handle!!");
 660
 661    ret = pclKeyHandleClose(hd6);
 662    fail_unless(ret != -1, "Failed to close handle!!");
 663
 664    ret = pclKeyHandleClose(hd7);
 665    fail_unless(ret != -1, "Failed to close handle!!");
 666
 667    ret = pclKeyHandleClose(hd8);
 668    fail_unless(ret != -1, "Failed to close handle!!");
 669
 670    ret = pclKeyHandleClose(hd9);
 671    fail_unless(ret != -1, "Failed to close handle!!");
 672 }
 673 END_TEST
 674
 675
 676
 677 /**
 678  * Test for  i n t e r n a l  structures.
 679  * Test the cursor functions.
 680  */
 681 START_TEST(test_Cursor)
 682 {
 683    int handle = -1, rval = 0, size = 0, handle1 = 0;
 684    char bufferKeySrc[READ_SIZE];
 685    char bufferDataSrc[READ_SIZE];
 686    char bufferKeyDst[READ_SIZE];
 687    char bufferDataDst[READ_SIZE];
 688
 689    memset(bufferKeySrc, 0, READ_SIZE);
 690    memset(bufferDataSrc, 0, READ_SIZE);
 691
 692    memset(bufferKeyDst, 0, READ_SIZE);
 693    memset(bufferDataDst, 0, READ_SIZE);
 694
 695    // create cursor
 696    handle = pers_db_cursor_create("/Data/mnt-c/lt-persistence_client_library_test/cached.itz");
 697
 698    fail_unless(handle != -1, "Failed to create cursor!!");
 699
 700    // create cursor
 701    handle1 = pers_db_cursor_create("/Data/mnt-c/lt-persistence_client_library_test/wt.itz");
 702
 703    fail_unless(handle1 != -1, "Failed to create cursor!!");
 704
 705    do
 706    {
 707       memset(bufferKeySrc, 0, READ_SIZE);
 708       memset(bufferDataSrc, 0, READ_SIZE);
 709       memset(bufferKeyDst, 0, READ_SIZE);
 710       memset(bufferDataDst, 0, READ_SIZE);
 711
 712       // get key
 713       rval = pers_db_cursor_get_key(handle, bufferKeySrc, 128);
 714       fail_unless(rval != -1, "Cursor failed to get key!!");
 715       // get data
 716       rval = pers_db_cursor_get_data(handle, bufferDataSrc, 128);
 717       fail_unless(rval != -1, "Cursor failed to get data!!");
 718       // get size
 719       size = pers_db_cursor_get_data_size(handle);
 720       fail_unless(size != -1, "Cursor failed to get size!!");
 721       //printf("1. Key: %s | Data: %s » Size: %d \n", bufferKeySrc, bufferDataSrc, size);
 722
 723       // get key
 724       rval = pers_db_cursor_get_key(handle1, bufferKeyDst, 128);
 725       fail_unless(rval != -1, "Cursor failed to get key!!");
 726       // get data
 727       rval = pers_db_cursor_get_data(handle1, bufferDataDst, 128);
 728       fail_unless(rval != -1, "Cursor failed to get data!!");
 729       // get size
 730       size = pers_db_cursor_get_data_size(handle1);
 731       fail_unless(size != -1, "Cursor failed to get size!!");
 732       //printf("  2. Key: %s | Data: %s » Size: %d \n", bufferKeyDst, bufferDataDst, size);
 733    }
 734    while( (pers_db_cursor_next(handle) == 0) && (pers_db_cursor_next(handle1) == 0) ); // next cursor
 735
 736    // destory cursor
 737    rval = pers_db_cursor_destroy(handle);
 738    fail_unless(rval != -1, "Failed to destroy cursor!!");
 739
 740    rval = pers_db_cursor_destroy(handle1);
 741    fail_unless(rval != -1, "Failed to destroy cursor!!");
 742 }
 743 END_TEST
 744
 745
 746
 747 static Suite * persistencyClientLib_suite()
 748 {
 749    Suite * s  = suite_create("Persistency client library");
 750
 751    TCase * tc_persGetData = tcase_create("GetData");
 752    tcase_add_test(tc_persGetData, test_GetData);
 753
 754    TCase * tc_persSetData = tcase_create("SetData");
 755    tcase_add_test(tc_persSetData, test_SetData);
 756
 757    TCase * tc_persSetDataNoPRCT = tcase_create("SetDataNoPRCT");
 758    tcase_add_test(tc_persSetDataNoPRCT, test_SetDataNoPRCT);
 759
 760    TCase * tc_persGetDataSize = tcase_create("GetDataSize");
 761    tcase_add_test(tc_persGetDataSize, test_GetDataSize);
 762
 763    TCase * tc_persDeleteData = tcase_create("DeleteData");
 764    tcase_add_test(tc_persDeleteData, test_DeleteData);
 765
 766    TCase * tc_persGetDataHandle = tcase_create("GetDataHandle");
 767    tcase_add_test(tc_persGetDataHandle, test_GetDataHandle);
 768
 769    TCase * tc_persDataHandle = tcase_create("DataHandle");
 770    tcase_add_test(tc_persDataHandle, test_DataHandle);
 771
 772    TCase * tc_persDataHandleOpen = tcase_create("DataHandleOpen");
 773    tcase_add_test(tc_persDataHandleOpen, test_DataHandleOpen);
 774
 775    TCase * tc_persDataFile = tcase_create("DataFile");
 776    tcase_add_test(tc_persDataFile, test_DataFile);
 777
 778    TCase * tc_persDataFileRecovery = tcase_create("DataFileRecovery");
 779    tcase_add_test(tc_persDataFileRecovery, test_DataFileRecovery);
 780
 781    TCase * tc_Cursor = tcase_create("Cursor");
 782    tcase_add_test(tc_Cursor, test_Cursor);
 783
 784    suite_add_tcase(s, tc_persGetData);
 785    suite_add_tcase(s, tc_persSetData);
 786    suite_add_tcase(s, tc_persSetDataNoPRCT);
 787    suite_add_tcase(s, tc_persGetDataSize);
 788    suite_add_tcase(s, tc_persDeleteData);
 789    suite_add_tcase(s, tc_persGetDataHandle);
 790    suite_add_tcase(s, tc_persDataHandle);
 791    suite_add_tcase(s, tc_persDataHandleOpen);
 792    suite_add_tcase(s, tc_persDataFile);
 793    suite_add_tcase(s, tc_persDataFileRecovery);
 794    suite_add_tcase(s, tc_Cursor);
 795
 796    return s;
 797 }
 798
 799
 800
 801
 802 int main(int argc, char *argv[])
 803 {
 804    int nr_failed = 0;
 805
 806    Suite * s = persistencyClientLib_suite();
 807    SRunner * sr = srunner_create(s);
 808    srunner_run_all(sr, CK_VERBOSE);
 809    nr_failed = srunner_ntests_failed(sr);
 810
 811    srunner_free(sr);
 812    return (0==nr_failed)?EXIT_SUCCESS:EXIT_FAILURE;
 813
 814 }
 815