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