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 // protected header, should be used only be persistence components
  34 #include "../include_protected/persistence_client_library_db_access.h"
  35
  36
  37 #define BUF_SIZE     64
  38 #define NUM_OF_FILES 3
  39 #define READ_SIZE    1024
  40
  41
  42 char* dayOfWeek[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
  43
  44
  45
  46 START_TEST (test_GetData)
  47 {
  48    int ret = 0;
  49    unsigned char buffer[READ_SIZE];
  50
  51    memset(buffer, 0, READ_SIZE);
  52    ret = key_read_data(0xFF, "language/country_code",         0, 0, buffer, READ_SIZE);
  53    fail_unless(strncmp((char*)buffer, "Custom plugin -> plugin_get_data_handle",
  54                strlen((char*)buffer)) == 0, "Buffer not correctly read");
  55    fail_unless(ret = strlen("Custom plugin -> plugin_get_data_handle"));
  56
  57    memset(buffer, 0, READ_SIZE);
  58    ret = key_read_data(0xFF, "pos/last_position",         0, 0, buffer, READ_SIZE);
  59    fail_unless(strncmp((char*)buffer, "CACHE_ +48° 10' 38.95\", +8° 44' 39.06\"",
  60                strlen((char*)buffer)) == 0, "Buffer not correctly read");
  61    fail_unless(ret = strlen("CACHE_ +48° 10' 38.95\", +8° 44' 39.06\""));
  62
  63    memset(buffer, 0, READ_SIZE);
  64    ret = key_read_data(0,    "language/current_language", 3, 0, buffer, READ_SIZE);
  65    fail_unless(strncmp((char*)buffer, "CACHE_ Kisuaheli", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  66
  67    memset(buffer, 0, READ_SIZE);
  68    ret = key_read_data(0xFF, "status/open_document",      3, 2, buffer, READ_SIZE);
  69    fail_unless(strncmp((char*)buffer, "WT_ /var/opt/user_manual_climateControl.pdf", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  70
  71    memset(buffer, 0, READ_SIZE);
  72    ret = key_read_data(0x20, "address/home_address",      4, 0, buffer, READ_SIZE);
  73    fail_unless(strncmp((char*)buffer, "WT_ 55327 Heimatstadt, Wohnstrasse 31", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  74
  75    memset(buffer, 0, READ_SIZE);
  76    ret = key_read_data(0xFF, "pos/last_satellites",       0, 0, buffer, READ_SIZE);
  77    fail_unless(strncmp((char*)buffer, "WT_ 17", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  78
  79    memset(buffer, 0, READ_SIZE);
  80    ret = key_read_data(0x84, "links/last_link",           2, 0, buffer, READ_SIZE);
  81    fail_unless(strncmp((char*)buffer, "CACHE_ /last_exit/brooklyn", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  82
  83    memset(buffer, 0, READ_SIZE);
  84    ret = key_read_data(0x84, "links/last_link",           2, 1, buffer, READ_SIZE);
  85    fail_unless(strncmp((char*)buffer, "CACHE_ /last_exit/queens", strlen((char*)buffer)) == 0, "Buffer not correctly read");
  86 }
  87 END_TEST
  88
  89
  90
  91 START_TEST (test_GetDataHandle)
  92 {
  93    int ret = 0, handle = 0, handle2 = 0, handle3 = 0, handle4 = 0, size = 0;
  94    unsigned char buffer[READ_SIZE];
  95    struct tm *locTime;
  96    time_t t = time(0);
  97
  98    char sysTimeBuffer[128];
  99    memset(buffer, 0, READ_SIZE);
 100
 101    locTime = localtime(&t);
 102
 103    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),
 104                                                                   locTime->tm_hour, locTime->tm_min, locTime->tm_sec);
 105    // open handle ---------------------------------------------------
 106    handle = key_handle_open(0xFF, "posHandle/last_position", 0, 0);
 107    fail_unless(handle >= 0, "Failed to open handle ==> /posHandle/last_position");
 108
 109    ret = key_handle_read_data(handle, buffer, READ_SIZE);
 110    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");
 111
 112    size = key_handle_get_size(handle);
 113    fail_unless(size = strlen("WT_ H A N D L E: +48° 10' 38.95\", +8° 44' 39.06\""));
 114
 115
 116    // open handle ---------------------------------------------------
 117    handle2 = key_handle_open(0xFF, "statusHandle/open_document", 3, 2);
 118    fail_unless(handle2 >= 0, "Failed to open handle /statusHandle/open_document");
 119
 120    size = key_handle_write_data(handle2, (unsigned char*)sysTimeBuffer, strlen(sysTimeBuffer));
 121    fail_unless(size = strlen(sysTimeBuffer));
 122    // close
 123    ret = key_handle_close(handle2);
 124
 125
 126    // open handle ---------------------------------------------------
 127    memset(buffer, 0, READ_SIZE);
 128    handle4 = key_handle_open(0xFF, "language/country_code", 0, 0);
 129    fail_unless(handle4 >= 0, "Failed to open handle /language/country_code");
 130
 131    ret = key_handle_read_data(handle4, buffer, READ_SIZE);
 132    fail_unless(strncmp((char*)buffer, "Custom plugin -> plugin_get_data_handle", -1) == 0, "Buffer not correctly read");
 133
 134    size = key_handle_get_size(handle4);
 135    fail_unless(size = strlen("Custom plugin -> plugin_get_data_handle"));
 136
 137    ret = key_handle_write_data(handle4, (unsigned char*)"Only dummy implementation behind custom library", READ_SIZE);
 138
 139
 140    // open handle ---------------------------------------------------
 141    handle3 = key_handle_open(0xFF, "statusHandle/open_document", 3, 2);
 142    fail_unless(handle3 >= 0, "Failed to open handle /statusHandle/open_document");
 143
 144    ret = key_handle_read_data(handle3, buffer, READ_SIZE);
 145    fail_unless(strncmp((char*)buffer, sysTimeBuffer, strlen(sysTimeBuffer)) == 0, "Buffer not correctly read");
 146
 147    size = key_handle_get_size(handle3);
 148    fail_unless(size = strlen(sysTimeBuffer));
 149
 150    // close handle
 151    ret = key_handle_close(handle);
 152    ret = key_handle_close(handle3);
 153    ret = key_handle_close(handle4);
 154
 155
 156 }
 157 END_TEST
 158
 159
 160
 161 START_TEST(test_SetData)
 162 {
 163    int ret = 0;
 164    unsigned char buffer[READ_SIZE];
 165    char write1[READ_SIZE];
 166    char write2[READ_SIZE];
 167    char sysTimeBuffer[256];
 168
 169    struct tm *locTime;
 170    time_t t = time(0);
 171
 172    locTime = localtime(&t);
 173    memset(buffer, 0, READ_SIZE);
 174    memset(write1, 0, READ_SIZE);
 175    memset(write2, 0, READ_SIZE);
 176
 177    // write data
 178    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),
 179                                                                  locTime->tm_hour, locTime->tm_min, locTime->tm_sec);
 180
 181    ret = key_write_data(0xFF, "69", 1, 2, (unsigned char*)sysTimeBuffer, strlen(sysTimeBuffer));
 182    fail_unless(ret == strlen(sysTimeBuffer), "Wrong write size");
 183
 184    snprintf(write1, 128, "%s %s", "/70",  sysTimeBuffer);
 185    ret = key_write_data(0xFF, "70", 1, 2, (unsigned char*)write1, strlen(write1));
 186    fail_unless(ret == strlen(write1), "Wrong write size");
 187
 188    snprintf(write2, 128, "%s %s", "/key_70",  sysTimeBuffer);
 189    ret = key_write_data(0xFF, "key_70", 1, 2, (unsigned char*)write2, strlen(write2));
 190    fail_unless(ret == strlen(write2), "Wrong write size");
 191
 192    // read data again and and verify datat has been written correctly
 193    memset(buffer, 0, READ_SIZE);
 194    ret = key_read_data(0xFF, "69", 1, 2, buffer, READ_SIZE);
 195    fail_unless(strncmp((char*)buffer, sysTimeBuffer, strlen(sysTimeBuffer)) == 0, "Buffer not correctly read");
 196    fail_unless(ret == strlen(sysTimeBuffer), "Wrong read size");
 197
 198    memset(buffer, 0, READ_SIZE);
 199    ret = key_read_data(0xFF, "70", 1, 2, buffer, READ_SIZE);
 200    fail_unless(strncmp((char*)buffer, write1, strlen(write1)) == 0, "Buffer not correctly read");
 201    fail_unless(ret == strlen(write1), "Wrong read size");
 202
 203    memset(buffer, 0, READ_SIZE);
 204    ret = key_read_data(0xFF, "key_70", 1, 2, buffer, READ_SIZE);
 205    fail_unless(strncmp((char*)buffer, write2, strlen(write2)) == 0, "Buffer not correctly read");
 206    fail_unless(ret == strlen(write2), "Wrong read size");
 207
 208 }
 209 END_TEST
 210
 211
 212
 213 START_TEST(test_SetDataNoPRCT)
 214 {
 215    int ret = 0;
 216    unsigned char buffer[READ_SIZE];
 217    struct tm *locTime;
 218    time_t t = time(0);
 219
 220    char sysTimeBuffer[128];
 221    memset(buffer, 0, READ_SIZE);
 222
 223    locTime = localtime(&t);
 224
 225    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),
 226                                                                   locTime->tm_hour, locTime->tm_min, locTime->tm_sec);
 227
 228    ret = key_write_data(0xFF, "NoPRCT", 1, 2, (unsigned char*)sysTimeBuffer, strlen(sysTimeBuffer));
 229    fail_unless(ret == strlen(sysTimeBuffer), "Wrong write size");
 230    printf("Write Buffer : %s\n", sysTimeBuffer);
 231
 232    // read data again and and verify datat has been written correctly
 233    memset(buffer, 0, READ_SIZE);
 234    ret = key_read_data(0xFF, "NoPRCT", 1, 2, buffer, READ_SIZE);
 235    fail_unless(strncmp((char*)buffer, sysTimeBuffer, strlen(sysTimeBuffer)) == 0, "Buffer not correctly read");
 236    fail_unless(ret == strlen(sysTimeBuffer), "Wrong read size");
 237    printf("read buffer  : %s\n", buffer);
 238
 239 }
 240 END_TEST
 241
 242
 243
 244 START_TEST(test_GetDataSize)
 245 {
 246    int size = 0;
 247
 248    size = key_get_size(0xFF, "status/open_document", 3, 2);
 249    fail_unless(size == strlen("WT_ /var/opt/user_manual_climateControl.pdf"), "Invalid size");
 250
 251    size = key_get_size(0x84, "links/last_link", 2, 1);
 252    fail_unless(size == strlen("CACHE_ /last_exit/queens"), "Invalid size");
 253 }
 254 END_TEST
 255
 256
 257
 258 START_TEST(test_DeleteData)
 259 {
 260    int rval = 0;
 261    unsigned char buffer[READ_SIZE];
 262
 263    // delete key
 264    rval = key_delete(0xFF, "key_70", 1, 2);
 265    fail_unless(rval == 0, "Failed to delete key");
 266    // reading from key must fail now
 267    rval = key_read_data(0xFF, "key_70", 1, 2, buffer, READ_SIZE);
 268    fail_unless(rval == EPERS_NOKEY, "Read form key key_70 works, but should fail");
 269
 270
 271    rval = key_delete(0xFF, "70", 1, 2);
 272    fail_unless(rval == 0, "Failed to delete key");
 273    rval = key_read_data(0xFF, "70", 1, 2, buffer, READ_SIZE);
 274    fail_unless(rval == EPERS_NOKEY, "Read form key 70 works, but should fail");
 275 }
 276 END_TEST
 277
 278
 279
 280 START_TEST(test_DataFile)
 281 {
 282    int fd = 0, i = 0, idx = 0;
 283    int size = 0, ret = 0;
 284    int writeSize = 16*1024;
 285    unsigned char buffer[READ_SIZE];
 286    const char* refBuffer = "/Data/mnt-wt/lt-persistence_client_library_test/user/1/seat/1/media";
 287    char* writeBuffer;
 288    char* fileMap = NULL;
 289    writeBuffer = malloc(writeSize);
 290
 291
 292    // fill buffer a sequence
 293    for(i = 0; i<(writeSize/8); i++)
 294    {
 295       writeBuffer[idx++] = 'A';
 296       writeBuffer[idx++] = 'B';
 297       writeBuffer[idx++] = 'C';
 298       writeBuffer[idx++] = ' ';
 299       writeBuffer[idx++] = 'D';
 300       writeBuffer[idx++] = 'E';
 301       writeBuffer[idx++] = 'F';
 302       writeBuffer[idx++] = ' ';
 303    }
 304    memset(buffer, 0, READ_SIZE);
 305
 306    // create file
 307    fd = open("/Data/mnt-wt/lt-persistence_client_library_test/user/1/seat/1/media/mediaDBWrite.db",
 308              O_CREAT|O_RDWR|O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
 309    close(fd);
 310
 311    // open ----------------------------------------------------------
 312    fd = file_open(0xFF, "media/mediaDB.db", 1, 1);
 313    fail_unless(fd != -1, "Could not open file ==> /media/mediaDB.db");
 314
 315    size = file_get_size(fd);
 316    fail_unless(size == 68, "Wrong file size");
 317
 318    size = file_read_data(fd, buffer, READ_SIZE);
 319    fail_unless(strncmp((char*)buffer, refBuffer, strlen(refBuffer)) == 0, "Buffer not correctly read");
 320    fail_unless(size == (strlen(refBuffer)+1), "Wrong size returned");      // strlen + 1 ==> inlcude cr/lf
 321
 322    ret = file_close(fd);
 323    fail_unless(ret == 0, "Failed to close file");
 324
 325
 326    // open ----------------------------------------------------------
 327    fd = file_open(0xFF, "media/mediaDBWrite.db", 1, 1);
 328    fail_unless(fd != -1, "Could not open file ==> /media/mediaDBWrite.db");
 329
 330    size = file_write_data(fd, writeBuffer, strlen(writeBuffer));
 331    fail_unless(size == strlen(writeBuffer), "Failed to write data");
 332
 333    ret = file_close(fd);
 334    fail_unless(ret == 0, "Failed to close file");
 335
 336
 337    // remove ----------------------------------------------------------
 338    ret = file_remove(0xFF, "media/mediaDBWrite.db", 1, 1);
 339    fail_unless(ret == 0, "File can't be removed ==> /media/mediaDBWrite.db");
 340
 341    fd = file_open(0xFF, "media/mediaDBWrite.db", 1, 1);
 342    fail_unless(fd != -1, "File can't be opend ==> /media/mediaDBWrite.db");
 343
 344    ret = file_remove(0xFF, "media/mediaDBWrite.db", 1, 1);
 345    fail_unless(ret == 0, "File can't be removed ==> /media/mediaDBWrite.db");
 346
 347
 348    // map file ------------------------------------------------------
 349    fd = file_open(0xFF, "media/mediaDB.db", 1, 1);
 350
 351    size = file_get_size(fd);
 352    file_map_data(fileMap, size, 0, fd);
 353    fail_unless(fileMap != MAP_FAILED, "Failed to map file");
 354
 355    ret = file_unmap_data(fileMap, size);
 356    fail_unless(ret != -1, "Failed to unmap file");
 357
 358    // negative test
 359    size = file_get_size(1024);
 360    fail_unless(ret == 0, "Got size, but should not");
 361
 362
 363    free(writeBuffer);
 364 }
 365 END_TEST
 366
 367
 368
 369 START_TEST(test_DataHandle)
 370 {
 371    int handle1 = 0, handle2 = 0;
 372    int ret = 0;
 373
 374    // test file handles
 375    handle1 = file_open(0xFF, "media/mediaDB.db", 1, 1);
 376    fail_unless(handle1 != -1, "Could not open file ==> /media/mediaDB.db");
 377
 378    ret = file_close(handle1);
 379    fail_unless(handle1 != -1, "Could not closefile ==> /media/mediaDB.db");
 380
 381    ret = file_close(1024);
 382    fail_unless(ret == -1, "Could close file, but should not!!");
 383
 384    ret = file_close(17);
 385    fail_unless(ret == -1, "Could close file, but should not!!");
 386
 387
 388    // test key handles
 389    handle2 = key_handle_open(0xFF, "statusHandle/open_document", 3, 2);
 390    fail_unless(handle2 >= 0, "Failed to open handle /statusHandle/open_document");
 391
 392    ret = key_handle_close(handle2);
 393    fail_unless(ret != -1, "Failed to close handle!!");
 394
 395    ret = key_handle_close(1024);
 396    fail_unless(ret == -1, "Could close, but should not!!");
 397 }
 398 END_TEST
 399
 400
 401
 402 START_TEST(test_DataHandleOpen)
 403 {
 404    int hd1 = -2, hd2 = -2, hd3 = -2, hd4 = -2, hd5 = -2, hd6 = -2, hd7 = -2, hd8 = -2, hd9 = -2, ret = 0;
 405
 406    // open handles ----------------------------------------------------
 407    hd1 = key_handle_open(0xFF, "posHandle/last_position1", 0, 0);
 408    fail_unless(hd1 == 1, "Failed to open handle ==> /posHandle/last_position1");
 409
 410    hd2 = key_handle_open(0xFF, "posHandle/last_position2", 0, 0);
 411    fail_unless(hd2 == 2, "Failed to open handle ==> /posHandle/last_position2");
 412
 413    hd3 = key_handle_open(0xFF, "posHandle/last_position3", 0, 0);
 414    fail_unless(hd3 == 3, "Failed to open handle ==> /posHandle/last_position3");
 415
 416    // close handles ---------------------------------------------------
 417    ret = key_handle_close(hd1);
 418    fail_unless(ret != -1, "Failed to close handle!!");
 419
 420    ret = key_handle_close(hd2);
 421    fail_unless(ret != -1, "Failed to close handle!!");
 422
 423    ret = key_handle_close(hd3);
 424    fail_unless(ret != -1, "Failed to close handle!!");
 425
 426    // open handles ----------------------------------------------------
 427    hd4 = key_handle_open(0xFF, "posHandle/last_position4", 0, 0);
 428    fail_unless(hd4 == 3, "Failed to open handle ==> /posHandle/last_position4");
 429
 430    hd5 = key_handle_open(0xFF, "posHandle/last_position5", 0, 0);
 431    fail_unless(hd5 == 2, "Failed to open handle ==> /posHandle/last_position5");
 432
 433    hd6 = key_handle_open(0xFF, "posHandle/last_position6", 0, 0);
 434    fail_unless(hd6 == 1, "Failed to open handle ==> /posHandle/last_position6");
 435
 436    hd7 = key_handle_open(0xFF, "posHandle/last_position7", 0, 0);
 437    fail_unless(hd7 == 4, "Failed to open handle ==> /posHandle/last_position7");
 438
 439    hd8 = key_handle_open(0xFF, "posHandle/last_position8", 0, 0);
 440    fail_unless(hd8 == 5, "Failed to open handle ==> /posHandle/last_position8");
 441
 442    hd9 = key_handle_open(0xFF, "posHandle/last_position9", 0, 0);
 443    fail_unless(hd9 == 6, "Failed to open handle ==> /posHandle/last_position9");
 444
 445    // close handles ---------------------------------------------------
 446    ret = key_handle_close(hd4);
 447    fail_unless(ret != -1, "Failed to close handle!!");
 448
 449    ret = key_handle_close(hd5);
 450    fail_unless(ret != -1, "Failed to close handle!!");
 451
 452    ret = key_handle_close(hd6);
 453    fail_unless(ret != -1, "Failed to close handle!!");
 454
 455    ret = key_handle_close(hd7);
 456    fail_unless(ret != -1, "Failed to close handle!!");
 457
 458    ret = key_handle_close(hd8);
 459    fail_unless(ret != -1, "Failed to close handle!!");
 460
 461    ret = key_handle_close(hd9);
 462    fail_unless(ret != -1, "Failed to close handle!!");
 463 }
 464 END_TEST
 465
 466
 467
 468 START_TEST(test_Cursor)
 469 {
 470    int handle = -1, rval = 0, size = 0, handle1 = 0;
 471    char bufferKeySrc[READ_SIZE];
 472    char bufferDataSrc[READ_SIZE];
 473    char bufferKeyDst[READ_SIZE];
 474    char bufferDataDst[READ_SIZE];
 475
 476    memset(bufferKeySrc, 0, READ_SIZE);
 477    memset(bufferDataSrc, 0, READ_SIZE);
 478
 479    memset(bufferKeyDst, 0, READ_SIZE);
 480    memset(bufferDataDst, 0, READ_SIZE);
 481
 482    // create cursor
 483    handle = pers_db_cursor_create("/Data/mnt-c/lt-persistence_client_library_test/cached.itz");
 484
 485    fail_unless(handle != -1, "Failed to create cursor!!");
 486
 487    // create cursor
 488    handle1 = pers_db_cursor_create("/Data/mnt-c/lt-persistence_client_library_test/wt.itz");
 489
 490    fail_unless(handle1 != -1, "Failed to create cursor!!");
 491
 492    do
 493    {
 494       memset(bufferKeySrc, 0, READ_SIZE);
 495       memset(bufferDataSrc, 0, READ_SIZE);
 496       memset(bufferKeyDst, 0, READ_SIZE);
 497       memset(bufferDataDst, 0, READ_SIZE);
 498
 499       // get key
 500       rval = pers_db_cursor_get_key(handle, bufferKeySrc, 128);
 501       fail_unless(rval != -1, "Cursor failed to get key!!");
 502       // get data
 503       rval = pers_db_cursor_get_data(handle, bufferDataSrc, 128);
 504       fail_unless(rval != -1, "Cursor failed to get data!!");
 505       // get size
 506       size = pers_db_cursor_get_data_size(handle);
 507       fail_unless(size != -1, "Cursor failed to get size!!");
 508       //printf("1. Key: %s | Data: %s » Size: %d \n", bufferKeySrc, bufferDataSrc, size);
 509
 510       // get key
 511       rval = pers_db_cursor_get_key(handle1, bufferKeyDst, 128);
 512       fail_unless(rval != -1, "Cursor failed to get key!!");
 513       // get data
 514       rval = pers_db_cursor_get_data(handle1, bufferDataDst, 128);
 515       fail_unless(rval != -1, "Cursor failed to get data!!");
 516       // get size
 517       size = pers_db_cursor_get_data_size(handle1);
 518       fail_unless(size != -1, "Cursor failed to get size!!");
 519       //printf("  2. Key: %s | Data: %s » Size: %d \n", bufferKeyDst, bufferDataDst, size);
 520    }
 521    while( (pers_db_cursor_next(handle) == 0) && (pers_db_cursor_next(handle1) == 0) ); // next cursor
 522
 523    // destory cursor
 524    rval = pers_db_cursor_destroy(handle);
 525    fail_unless(rval != -1, "Failed to destroy cursor!!");
 526
 527    rval = pers_db_cursor_destroy(handle1);
 528    fail_unless(rval != -1, "Failed to destroy cursor!!");
 529 }
 530 END_TEST
 531
 532
 533
 534 static Suite * persistencyClientLib_suite()
 535 {
 536    Suite * s  = suite_create("Persistency client library");
 537
 538    TCase * tc_persGetData = tcase_create("GetData");
 539    tcase_add_test(tc_persGetData, test_GetData);
 540
 541    TCase * tc_persSetData = tcase_create("SetData");
 542    tcase_add_test(tc_persSetData, test_SetData);
 543
 544    TCase * tc_persSetDataNoPRCT = tcase_create("SetDataNoPRCT");
 545    tcase_add_test(tc_persSetDataNoPRCT, test_SetDataNoPRCT);
 546
 547    TCase * tc_persGetDataSize = tcase_create("GetDataSize");
 548    tcase_add_test(tc_persGetDataSize, test_GetDataSize);
 549
 550    TCase * tc_persDeleteData = tcase_create("DeleteData");
 551    tcase_add_test(tc_persDeleteData, test_DeleteData);
 552
 553    TCase * tc_persGetDataHandle = tcase_create("GetDataHandle");
 554    tcase_add_test(tc_persGetDataHandle, test_GetDataHandle);
 555
 556    TCase * tc_persDataHandle = tcase_create("DataHandle");
 557    tcase_add_test(tc_persDataHandle, test_DataHandle);
 558
 559    TCase * tc_persDataHandleOpen = tcase_create("DataHandleOpen");
 560    tcase_add_test(tc_persDataHandleOpen, test_DataHandleOpen);
 561
 562    TCase * tc_persDataFile = tcase_create("DataFile");
 563    tcase_add_test(tc_persDataFile, test_DataFile);
 564
 565    TCase * tc_Cursor = tcase_create("Cursor");
 566    tcase_add_test(tc_Cursor, test_Cursor);
 567
 568    suite_add_tcase(s, tc_persGetData);
 569    suite_add_tcase(s, tc_persSetData);
 570    suite_add_tcase(s, tc_persSetDataNoPRCT);
 571    suite_add_tcase(s, tc_persGetDataSize);
 572    suite_add_tcase(s, tc_persDeleteData);
 573    suite_add_tcase(s, tc_persGetDataHandle);
 574    suite_add_tcase(s, tc_persDataHandle);
 575    suite_add_tcase(s, tc_persDataHandleOpen);
 576    suite_add_tcase(s, tc_persDataFile);
 577    suite_add_tcase(s, tc_Cursor);
 578
 579    return s;
 580 }
 581
 582
 583
 584
 585 int main(int argc, char *argv[])
 586 {
 587    int nr_failed = 0;
 588
 589    Suite * s = persistencyClientLib_suite();
 590    SRunner * sr = srunner_create(s);
 591    srunner_run_all(sr, CK_VERBOSE);
 592    nr_failed = srunner_ntests_failed(sr);
 593
 594    srunner_free(sr);
 595    return (0==nr_failed)?EXIT_SUCCESS:EXIT_FAILURE;
 596
 597 }
 598