tests/test_getset.c

   1 /***************************************************************************
   2  *          test_setget.c  -  setting and getting test suite
   3  *                -------------------
   4  *  begin                : Wed Aug 26 2006
   5  *  copyright            : (C) 2006 by Patrick Sabin
   6  *  email                : patricksabin@gmx.at
   7  ****************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the BSD License (revised).                      *
  13  *                                                                         *
  14  ***************************************************************************/
  15
  16
  17 #include <tests.h>
  18
  19 void test_subdir()
  20 {
  21         KDB *kdb;
  22         Key *key,*key1,*key2;
  23         KeySet *ks;
  24         KeySet *returned;
  25         int key1_found;
  26         const char* name;
  27         Key *parent;
  28
  29         printf("testing subdir\n");
  30
  31         kdb=kdbOpen();
  32         exit_if_fail(kdb,"kdbOpen() failed");
  33
  34         ks=ksNew(0);
  35         exit_if_fail(ks,"ksNew(0) failed");
  36
  37         /* Test creating two keys */
  38         key=keyNew(KEY_ROOT "/test_d", KEY_DIR, KEY_VALUE, "dirkey", KEY_COMMENT, "dircomment", KEY_END);
  39         succeed_if(key!=NULL, "keyNew: Unable to create a new key: user/test");
  40         succeed_if(keySetString(key,"test value")!=0, "keySetString: Cannot set value");
  41         succeed_if(keySetComment(key,"empty")!=0, "keySetComment: Cannot set the key Comment");
  42         ksAppendKey(ks,key);
  43
  44         key=keyNew(KEY_ROOT "/test_d/test", KEY_END);
  45         succeed_if(key!=NULL, "keyNew: Unable to create a new key: user/test/test");
  46         succeed_if(keySetString(key,"test value2")!=0, "keySetString: Cannot set value");
  47         succeed_if(keySetComment(key,"empty")!=0, "keySetComment: Cannot set the key Comment");
  48         ksAppendKey(ks,key);
  49
  50         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "kdbSet failed");
  51
  52         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
  53         exit_if_fail((kdb=kdbOpen())!=NULL,"Could not open elektra");
  54
  55         // read the directory key
  56
  57         succeed_if(ksDel(ks)==0,"Could not close keySet");
  58         ks=ksNew(0);
  59
  60         returned=ksNew(0);
  61         parent=keyNew(KEY_ROOT "/",KEY_END);
  62         succeed_if (kdbGet(kdb,returned,parent,0)!=-1, "kdbGet failed");
  63
  64         key1_found=0;
  65         for (key=ksNext(returned);key;key=ksNext(returned)) {
  66                 name=keyName(key);
  67                 if (!strcmp(name, KEY_ROOT "/test_d")) {
  68                         key1_found=1;
  69                         /*
  70                         output_key(key);
  71                         */
  72                         succeed_if(!strcmp(keyValue(key),"test value"),"value of directory key not correct");
  73                         succeed_if(!strcmp(keyComment(key),"empty"),"comment of directory key not correct");
  74                 }
  75         }
  76         succeed_if(key1_found, KEY_ROOT "/test1 not found");
  77         ksDel(returned);
  78         keyDel(parent);
  79
  80         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
  81         exit_if_fail((kdb=kdbOpen())!=NULL,"Could not open elektra");
  82
  83         // user/test and user/test/test keys are written. Now overwrite them
  84
  85         key1=keyNew(KEY_ROOT "/test_d", KEY_DIR,  KEY_END);
  86         succeed_if(key1!=NULL, "keyNew: Unable to create a new key: user/test");
  87         succeed_if(keySetString(key1,"test value")!=0, "keySetString: Cannot set value");
  88         succeed_if(keySetComment(key1,"empty")!=0, "keySetComment: Cannot set the key Comment");
  89         ksAppendKey(ks,key1);
  90
  91         key2=keyNew(KEY_ROOT "/test_d/test", KEY_END);
  92         succeed_if(key2!=NULL, "keyNew: Unable to create a new key: user/test/test");
  93         succeed_if(keySetString(key2,"test value2")!=0, "keySetString: Cannot set value");
  94         succeed_if(keySetComment(key2,"empty")!=0, "keySetComment: Cannot set the key Comment");
  95         ksAppendKey(ks,key2);
  96
  97         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "kdbSet failed");
  98
  99         keyRemove (key2);
 100         succeed_if(kdbSetKey(kdb,key2)==0,"Cannot remove key2");
 101         keyRemove (key1);
 102         succeed_if(kdbSetKey(kdb,key1)==0,"Cannot remove key1");
 103         succeed_if(ksDel(ks)==0,"Could not close keySet");
 104         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
 105 }
 106
 107 void test_writeread()
 108 {
 109         KDB *kdb;
 110         Key *parent,*key,*key1,*key2;
 111         KeySet *ks;
 112         KeySet *returned;
 113         const char *name;
 114         int key1_found,key2_found;
 115         //char buffer[1024];
 116
 117         printf("testing write/read\n");
 118         kdb=kdbOpen();
 119         exit_if_fail(kdb,"kdbOpen() failed");
 120
 121         ks=ksNew(0);
 122         exit_if_fail(ks,"ksNew(0) failed");
 123
 124         /* Test creating two keys */
 125         key1=keyNew(KEY_ROOT "/test1", KEY_VALUE,"value1", KEY_END);
 126         succeed_if(key1!=NULL, "keyNew: Unable to create a new key: user/test");
 127         ksAppendKey(ks,key1);
 128
 129         key2=keyNew(KEY_ROOT "/test2", KEY_VALUE,"value2",KEY_COMMENT,"comment2",KEY_END);
 130         succeed_if(key2!=NULL, "keyNew: Unable to create a new key: user/test2");
 131         ksAppendKey(ks,key2);
 132
 133         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "kdbSet failed");
 134         succeed_if(ksDel(ks)==0,"Could not close keySet");
 135
 136         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
 137         kdb=kdbOpen();
 138
 139         /* Test reading the written keys */
 140
 141         returned=ksNew(0);
 142         parent=keyNew(KEY_ROOT "/",KEY_END);
 143
 144         succeed_if (kdbGet(kdb,returned,parent,0)!=-1, "could not get keys");
 145
 146         key1_found=key2_found=0;
 147         for (key=ksNext(returned);key;key=ksNext(returned)) {
 148                 name=keyName(key);
 149                 if (!strcmp(name, KEY_ROOT "/test1")) {
 150                         key1_found=1;
 151                         /*
 152                         output_key(key);
 153                         */
 154                         succeed_if(!strcmp(keyValue(key),"value1"),"value of first written key not correct");
 155                         succeed_if(!strcmp(keyComment(key),""),"comment of first written key not correct");
 156                 }
 157                 if (!strcmp(name, KEY_ROOT "/test2")) {
 158                         key2_found=1;
 159                         /*
 160                         output_key(key);
 161                         */
 162                         succeed_if(!strcmp(keyValue(key),"value2"),"value of second written key not correct");
 163                         succeed_if(!strcmp(keyComment(key),"comment2"),"value of second written key not correct");
 164                 }
 165         }
 166         succeed_if(key1_found, KEY_ROOT "/test1 not found");
 167         succeed_if(key2_found, KEY_ROOT "/test2 not found");
 168         ksDel(returned);
 169         keyDel(parent);
 170
 171         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
 172         exit_if_fail((kdb=kdbOpen())!=NULL,"Could not open elektra");
 173
 174         /* Test overwriting the keys */
 175
 176         ks=ksNew(0);
 177         exit_if_fail(ks,"ksNew(0) failed");
 178
 179         key1=keyNew(KEY_ROOT "/test1", KEY_VALUE,"value_new1",KEY_COMMENT,"comment1",KEY_END);
 180         succeed_if(key1!=NULL, "keyNew: Unable to create a new key: user/test");
 181         ksAppendKey(ks,key1);
 182
 183         key2=keyNew(KEY_ROOT "/test2", KEY_VALUE,"value_new2",KEY_END);
 184         succeed_if(key2!=NULL, "keyNew: Unable to create a new key: user/test/test");
 185         ksAppendKey(ks,key2);
 186
 187         succeed_if(kdbSet(kdb,ks,0,0)!=-1, "kdbSet failed");
 188
 189         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
 190         exit_if_fail((kdb=kdbOpen())!=NULL,"Could not open elektra");
 191
 192         /* Test reading the overwritten keys */
 193
 194         returned=ksNew(0);
 195         parent=keyNew(KEY_ROOT "/",KEY_END);
 196
 197         succeed_if (kdbGet(kdb,returned,parent,0)!=-1, "could not kdbGet keys");
 198         succeed_if (keyDel (parent) == 0, "Could not delete parent key");
 199
 200         key1_found=key2_found=0;
 201         ksRewind(returned);
 202         while ((key=ksNext(returned))!=0)
 203         {
 204                 name=keyName(key);
 205                 if (!strcmp(name, KEY_ROOT "/test1")) {
 206                         key1_found=1;
 207                         succeed_if(!strcmp(keyValue(key),"value_new1"),"value of first overwritten key not correct");
 208                         succeed_if(!strcmp(keyComment(key),"comment1"),"comment of first overwritten key not correct");
 209                 }
 210                 if (!strcmp(name, KEY_ROOT "/test2")) {
 211                         key2_found=1;
 212                         succeed_if(!strcmp(keyValue(key),"value_new2"),"value of second overwritten key not correct");
 213                         succeed_if(!strcmp(keyComment(key),""),"comment of second overwritten key not correct");
 214                 }
 215         }
 216         succeed_if(key1_found, KEY_ROOT "/test1 not found");
 217         succeed_if(key2_found, KEY_ROOT "/test2 not found");
 218         ksDel(returned);
 219
 220         keyRemove (key2);
 221         succeed_if(kdbSetKey(kdb,key2)==0,"Cannot remove key2");
 222         keyRemove (key1);
 223         succeed_if(kdbSetKey(kdb,key1)==0,"Cannot remove key1");
 224         succeed_if(ksDel(ks)==0,"Could not close keySet");
 225         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
 226 }
 227
 228 void test_mode()
 229 {
 230         KDB *kdb;
 231         Key *key,*key1,*key2,*parent;
 232         KeySet *returned,*ks;
 233         int key1_found;
 234         int ret;
 235         int mode, setMode;
 236
 237         printf("testing mode\n");
 238         kdb=kdbOpen();
 239         exit_if_fail(kdb,"kdbOpen() failed");
 240
 241         //TODO: mode 0..5
 242         for (mode = 6; mode < 8; mode++)
 243         {
 244                 setMode = mode | mode << 3 | mode << 6;
 245                 printf ("Testing mode: %o\n", setMode);
 246
 247                 exit_if_fail(ks=ksNew(0),"ksNew(0) failed");
 248                 /* Create a key with permission setMode */
 249                 key=keyNew(KEY_ROOT "/mode", KEY_MODE, setMode, KEY_VALUE,"value1",
 250                                 KEY_COMMENT,"comment1",KEY_END);
 251                 succeed_if(key!=NULL, "keyNew: Unable to create a new key: user/test");
 252                 succeed_if(keyGetMode(key) == setMode, "Could not set mode");
 253                 ksAppendKey(ks,key);
 254                 /*errno = KDB_ERR_OK;*/
 255                 ret = kdbSet(kdb,ks,0,0);
 256                 if (mode & MODE_WRITE)
 257                 {
 258                         // succeed_if (ret == 0, "could not write key");
 259                 } else {
 260                         succeed_if (ret == -1, "wrote key without write mode?");
 261                         /*succeed_if (errno == KDB_ERR_NOCRED, "Errno not set correctly");*/
 262                         // TODO: exit_if_fail (ksCurrent(ks), "no current key, where did it fail?");
 263                         // succeed_if (strcmp (keyName(ksCurrent(ks)), KEY_ROOT "/mode") == 0, "did stop at wrong key");
 264                         // succeed_if (strcmp (keyValue(ksCurrent(ks)), "value1") == 0, "wrong value");
 265                         // succeed_if (strcmp (keyComment(ksCurrent(ks)), "comment1") == 0, "wrong comment");
 266                 }
 267                 ksDel (ks);
 268
 269                 returned=ksNew(0);
 270                 parent=keyNew(KEY_ROOT, KEY_END);
 271                 ret = kdbGet(kdb,returned,parent,0);
 272                 keyDel(parent);
 273
 274                 key1_found=0;
 275
 276                 ksRewind(returned);
 277                 while ((key=ksNext(returned))!=0)
 278                 {
 279                         if (!strcmp(keyName(key), KEY_ROOT "/mode")) {
 280                                 key1_found=1;
 281                                 // succeed_if(keyGetMode(key) == setMode, "Mode not correct after get");
 282                                 if ((mode & MODE_READ) && (mode & MODE_WRITE))
 283                                 {
 284                                         succeed_if(strcmp (keyValue (key), "value1") == 0,
 285                                                         "Could not read value, but should be allowed to");
 286                                         succeed_if(strcmp (keyComment (key), "comment1") == 0,
 287                                                         "Could not read comment, but should be allowed to");
 288                                 }
 289                                 else if (mode & MODE_WRITE)
 290                                 {
 291                                         succeed_if(!strcmp (keyValue (key), "value1") == 0,
 292                                                         "Could read value, but should not be allowed to");
 293                                         succeed_if(strcmp (keyValue (key), "") == 0,
 294                                                         "Value not empty, but write should have failed");
 295                                         succeed_if(!strcmp (keyComment (key), "comment1") == 0,
 296                                                         "Could read comment, but should not be allowed to");
 297                                         succeed_if(strcmp (keyComment (key), "") == 0,
 298                                                         "Comment not empty, but write should have failed");
 299                                 }
 300                                 else if (mode & MODE_READ)
 301                                 {
 302                                         succeed_if(!strcmp (keyValue (key), "value1") == 0,
 303                                                         "Could read value, but should not be allowed to");
 304                                         succeed_if(strcmp (keyValue (key), "") == 0,
 305                                                         "Value not empty after not allowed read");
 306                                         succeed_if(!strcmp (keyComment (key), "comment1") == 0,
 307                                                         "Could read comment, but should not be allowed to");
 308                                         succeed_if(strcmp (keyComment (key), "") == 0,
 309                                                         "Comment not empty after not allowed read");
 310                                 }
 311                         }
 312                 }
 313
 314                 succeed_if(key1_found, KEY_ROOT "/test1 key not found");
 315                 ksDel(returned);
 316
 317                 /* Overwrite the key*/
 318                 // TODO: copy code from above
 319
 320
 321                 /* Create a sub key for /mode */
 322                 exit_if_fail(ks=ksNew(0), "ksNew(0) failed");
 323                 key2=keyNew(KEY_ROOT "/mode/key", KEY_VALUE,"value_sub",KEY_COMMENT,"comment_sub",KEY_END);
 324                 succeed_if(key2!=NULL, "keyNew: Unable to create a new subkey");
 325                 ksAppendKey(ks,key2);
 326
 327                 if (kdbSet(kdb,ks,0,0)==-1) {
 328                         if (!(mode & 1)) // not a directory, can't write subkey
 329                         {
 330                                 succeed_if(0,"kdbSet failed");
 331                         }
 332                 }
 333                 ksDel(ks);
 334
 335                 /* Overwrite the directory key if there is already a subkey */
 336                 ks=ksNew(0);
 337                 key1=keyNew(KEY_ROOT "/mode/key", KEY_VALUE,"value_new",KEY_COMMENT,"comment_new",KEY_END);
 338                 key2=keyNew(KEY_ROOT "/mode", KEY_VALUE,"value_new",KEY_COMMENT,"comment_new",KEY_END);
 339                 ksAppendKey(ks,key1);
 340                 ksAppendKey(ks,key2);
 341
 342                 if (kdbSet(kdb,ks,0,0)==-1)
 343                 {
 344                         // succeed_if(errno==KDB_ERR_NOTEMPTY, "kdbSet delete nonempty key KDB_ERR_NOTEMPTY expected");
 345                         // TODO exit_if_fail (ksCurrent(ks) != 0, "key is Null but should be set to incorrect key");
 346                         // printf("trapped: %s\n",keyName(ksCurrent(ks)));
 347                         // succeed_if (!strcmp(KEY_ROOT "/mode",keyName(ksCurrent(ks))), "kdbSet messed up setting ksCurrent()");
 348                 } else {
 349                         /*
 350                         if (!(mode & 1)) // is not directory key
 351                         {
 352                                 succeed_if(0,"Could overwrite a directory with subkeys");
 353                         }
 354                         */
 355                 }
 356
 357                 /* Cleanup */
 358                 succeed_if (kdbRemove (kdb, KEY_ROOT "/mode/key") == 0, "Could not remove mode/key");
 359                 succeed_if (kdbRemove (kdb, KEY_ROOT "/mode") == 0, "Could not remove mode");
 360                 succeed_if(ksDel(ks)==0,"Could not close keySet");
 361         }
 362         exit_if_fail(kdbClose(kdb)==0,"Could not close libelektra");
 363
 364
 365         return;
 366 }
 367
 368 /* This tests the lowest-level way to set a key and get it afterwards */
 369 void test_simple_getset()
 370 {
 371         KDB *kdb;
 372         Key *key,*key1;
 373         KeySet *ks;
 374         KeySet *returned;
 375
 376         printf("testing simple write/read\n");
 377
 378         // create key test1
 379         kdb=kdbOpen();
 380         ks=ksNew(0);
 381         key1=keyNew(KEY_ROOT "/test1", KEY_VALUE,"value", KEY_COMMENT,"comment", KEY_END);
 382         ksAppendKey(ks,key1);
 383
 384         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 385         ksDel(ks);
 386         kdbClose(kdb);
 387
 388         // get key test1
 389         kdb=kdbOpen();
 390         key=keyNew(KEY_ROOT, KEY_END);
 391         returned = ksNew(0);
 392         if (kdbGet(kdb,returned,key,0)==-1) {
 393                 succeed_if(0,"kdbGet failed");
 394         }
 395         keyDel(key);
 396         key1 = ksLookupByName (returned, KEY_ROOT "/test1", 0);
 397         exit_if_fail (key1 != 0, "could not lookup key");
 398         succeed_if (strcmp (keyValue (key1), "value") == 0, "Value not correct");
 399         succeed_if (strcmp (keyComment(key1), "comment") == 0, "Comment not correct");
 400         ksDel (returned);
 401         kdbClose(kdb);
 402
 403         // delete key test1
 404         kdb=kdbOpen();
 405         ks=ksNew(0);
 406         key1=keyNew(KEY_ROOT "/test1", KEY_REMOVE, KEY_END);
 407         ksAppendKey(ks,key1);
 408         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 409         ksDel(ks);
 410         kdbClose(kdb);
 411
 412         return;
 413 }
 414
 415 /* This tests the highlevel-level way to set a key and get it afterwards */
 416 void test_highlevel_getset()
 417 {
 418         KDB *kdb;
 419         Key *key1;
 420
 421         printf("testing simple write/read\n");
 422
 423         // create key test3
 424         kdb=kdbOpen();
 425         key1=keyNew(KEY_ROOT "/test3", KEY_VALUE,"value", KEY_COMMENT,"comment", KEY_END);
 426         succeed_if (kdbSetKey(kdb,key1)!=-1, "could not kdbSet keys");
 427         keyDel (key1);
 428         kdbClose(kdb);
 429
 430         // get key test3
 431         kdb=kdbOpen();
 432         key1=keyNew(KEY_ROOT "/test3", KEY_END);
 433         if (kdbGetKey(kdb,key1)==-1) {
 434                 succeed_if(0,"kdbGetKey failed");
 435         }
 436         succeed_if (strcmp (keyValue (key1), "value") == 0, "Value not correct");
 437         succeed_if (strcmp (keyComment(key1), "comment") == 0, "Comment not correct");
 438         keyDel (key1);
 439         kdbClose(kdb);
 440
 441         // delete key test3
 442         kdb=kdbOpen();
 443         key1=keyNew(KEY_ROOT "/test3", KEY_REMOVE, KEY_END);
 444         succeed_if (kdbSetKey (kdb,key1)==0, "could not get a key");
 445         keyDel (key1);
 446         kdbClose(kdb);
 447
 448         return;
 449 }
 450
 451 /* This tests do recursive set and get keys */
 452 void test_simple_recursive_getset()
 453 {
 454         KDB *kdb;
 455         Key *key,*key1;
 456         KeySet *ks;
 457         KeySet *returned;
 458
 459         printf("testing recursive write/read\n");
 460
 461         // create key test1
 462         kdb=kdbOpen();
 463         ks=ksNew(0);
 464         key1=keyNew(KEY_ROOT "/dir", KEY_DIR, KEY_VALUE,"dirvalue", KEY_COMMENT,"dircomment", KEY_END);
 465         ksAppendKey(ks,key1);
 466         key1=keyNew(KEY_ROOT "/dir/key", KEY_VALUE,"value", KEY_COMMENT,"comment", KEY_END);
 467         ksAppendKey(ks,key1);
 468
 469         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 470         ksDel(ks);
 471         kdbClose(kdb);
 472
 473         // get key test1
 474         kdb=kdbOpen();
 475         key=keyNew(KEY_ROOT, KEY_END);
 476         returned = ksNew(0);
 477         if (kdbGet(kdb,returned,key,0)==-1) {
 478                 succeed_if(0,"kdbGet failed");
 479         }
 480         keyDel(key);
 481         key1 = ksLookupByName (returned, KEY_ROOT "/dir/key", 0);
 482         exit_if_fail (key1 != 0, "could not lookup key");
 483         succeed_if (strcmp (keyValue (key1), "value") == 0, "Value not correct");
 484         succeed_if (strcmp (keyComment(key1), "comment") == 0, "Comment not correct");
 485
 486         key1 = ksLookupByName (returned, KEY_ROOT "/dir", 0);
 487         exit_if_fail (key1 != 0, "could not lookup key");
 488         succeed_if (strcmp (keyValue (key1), "dirvalue") == 0, "Value not correct");
 489         succeed_if (strcmp (keyComment(key1), "dircomment") == 0, "Comment not correct");
 490         ksDel (returned);
 491         kdbClose(kdb);
 492
 493         // delete key test1
 494         kdb=kdbOpen();
 495         ks=ksNew(0);
 496         key1=keyNew(KEY_ROOT "/dir/key", KEY_REMOVE, KEY_END);
 497         ksAppendKey(ks,key1);
 498         key1=keyNew(KEY_ROOT "/dir", KEY_DIR, KEY_REMOVE, KEY_END);
 499         ksAppendKey(ks,key1);
 500         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 501         ksDel(ks);
 502         kdbClose(kdb);
 503
 504         return;
 505 }
 506
 507 /* This tests do recursive set and get keys */
 508 void test_recursive_getset()
 509 {
 510         KDB *kdb;
 511         Key *key,*key1;
 512         KeySet *ks;
 513         KeySet *returned;
 514         int found [5];
 515         int i;
 516
 517         for (i=0; i<5; i++) found[i] = 0;
 518
 519         printf("testing recursive write/read\n");
 520
 521         // create key test1
 522         kdb=kdbOpen();
 523         ks=ksNew(0);
 524         key1=keyNew(KEY_ROOT "/key1", KEY_VALUE,"value1", KEY_COMMENT,"comment", KEY_END);
 525         ksAppendKey(ks,key1);
 526         key1=keyNew(KEY_ROOT "/dir2", KEY_DIR, KEY_VALUE,"dirvalue", KEY_COMMENT,"dircomment", KEY_END);
 527         ksAppendKey(ks,key1);
 528         key1=keyNew(KEY_ROOT "/dir1", KEY_DIR, KEY_VALUE,"dirvalue", KEY_COMMENT,"dircomment", KEY_END);
 529         ksAppendKey(ks,key1);
 530         key1=keyNew(KEY_ROOT "/dir1/key2", KEY_VALUE,"value2", KEY_COMMENT,"comment", KEY_END);
 531         ksAppendKey(ks,key1);
 532         key1=keyNew(KEY_ROOT "/dir1/key1", KEY_VALUE,"value1", KEY_COMMENT,"comment", KEY_END);
 533         ksAppendKey(ks,key1);
 534
 535         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 536         ksDel(ks);
 537         kdbClose(kdb);
 538
 539         // get key test1
 540         kdb=kdbOpen();
 541         key=keyNew(KEY_ROOT, KEY_END);
 542         returned = ksNew(0);
 543         if (kdbGet(kdb,returned,key,0)==-1) {
 544                 succeed_if(0,"kdbGet failed");
 545         }
 546         keyDel(key);
 547
 548         // check if all keys are in set and exactly once
 549         // output_keyset(returned, 0);
 550         ksRewind(returned);
 551         while ((key=ksNext(returned))!=0)
 552         {
 553                 if (strcmp (keyName(key), KEY_ROOT "/key1") == 0) found [0]++;
 554                 else if (strcmp (keyName(key), KEY_ROOT "/dir2") == 0) found [1]++;
 555                 else if (strcmp (keyName(key), KEY_ROOT "/dir1") == 0) found [2]++;
 556                 else if (strcmp (keyName(key), KEY_ROOT "/dir1/key2") == 0) found [3]++;
 557                 else if (strcmp (keyName(key), KEY_ROOT "/dir1/key1") == 0) found [4]++;
 558         }
 559
 560         for (i=0; i<5;i++)
 561         {
 562                 // printf("%d", found[i]);
 563                 succeed_if (found[i] == 1, "key did not appear exactly once");
 564         }
 565
 566
 567         key1 = ksLookupByName (returned, KEY_ROOT "/dir1/key1", 0);
 568         exit_if_fail (key1 != 0, "could not lookup key");
 569         succeed_if (strcmp (keyValue (key1), "value1") == 0, "Value not correct");
 570         succeed_if (strcmp (keyComment(key1), "comment") == 0, "Comment not correct");
 571
 572         key1 = ksLookupByName (returned, KEY_ROOT "/dir1", 0);
 573         exit_if_fail (key1 != 0, "could not lookup key");
 574         succeed_if (strcmp (keyValue (key1), "dirvalue") == 0, "Value not correct");
 575         succeed_if (strcmp (keyComment(key1), "dircomment") == 0, "Comment not correct");
 576         ksDel (returned);
 577         kdbClose(kdb);
 578
 579         // delete key test1
 580         kdb=kdbOpen();
 581         ks=ksNew(0);
 582         key1=keyNew(KEY_ROOT "/dir1/key1", KEY_REMOVE, KEY_END);
 583         ksAppendKey(ks,key1);
 584         key1=keyNew(KEY_ROOT "/dir1/key2", KEY_REMOVE, KEY_END);
 585         ksAppendKey(ks,key1);
 586         key1=keyNew(KEY_ROOT "/dir1", KEY_REMOVE, KEY_END);
 587         ksAppendKey(ks,key1);
 588         key1=keyNew(KEY_ROOT "/dir2", KEY_REMOVE, KEY_END);
 589         ksAppendKey(ks,key1);
 590         key1=keyNew(KEY_ROOT "/key1", KEY_REMOVE, KEY_END);
 591         ksAppendKey(ks,key1);
 592         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 593         ksDel(ks);
 594         kdbClose(kdb);
 595
 596         return;
 597 }
 598
 599 /* This tests the lowest-level way to set a directory key and get it afterwards */
 600 void test_directory_getset()
 601 {
 602         KDB *kdb;
 603         Key *key,*key1;
 604         KeySet *ks;
 605         KeySet *returned;
 606
 607         printf("testing simple write/read\n");
 608
 609         // create key test1
 610         kdb=kdbOpen();
 611         ks=ksNew(0);
 612         key1=keyNew(KEY_ROOT "/dir4", KEY_DIR, KEY_VALUE,"value4", KEY_COMMENT,"comment4", KEY_END);
 613         ksAppendKey(ks,key1);
 614
 615         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 616         ksDel(ks);
 617         kdbClose(kdb);
 618
 619         // get key test1
 620         kdb=kdbOpen();
 621         key=keyNew(KEY_ROOT, KEY_END);
 622         returned = ksNew(0);
 623         if (kdbGet(kdb,returned,key,0)==-1) {
 624                 succeed_if(0,"kdbGet failed");
 625         }
 626         keyDel(key);
 627         key1 = ksLookupByName (returned, KEY_ROOT "/dir4", 0);
 628         succeed_if (strcmp (keyValue (key1), "value4") == 0, "Value not correct");
 629         succeed_if (strcmp (keyComment(key1), "comment4") == 0, "Comment not correct");
 630         succeed_if (keyIsDir(key1) , "not a directory");
 631         ksDel (returned);
 632         kdbClose(kdb);
 633
 634         // delete key test1
 635         kdb=kdbOpen();
 636         ks=ksNew(0);
 637         key1=keyNew(KEY_ROOT "/dir4", KEY_REMOVE, KEY_END);
 638         ksAppendKey(ks,key1);
 639         succeed_if (kdbSet(kdb,ks,0,0)!=-1, "could not kdbSet keys");
 640         ksDel(ks);
 641         kdbClose(kdb);
 642
 643         return;
 644 }
 645
 646 /* This tests the highlevel-level way to set a directory and get it afterwards */
 647 void test_directory_highlevel_getset()
 648 {
 649         KDB *kdb;
 650         Key *key1;
 651
 652         printf("testing simple write/read\n");
 653
 654         // create key test3
 655         kdb=kdbOpen();
 656         key1=keyNew(KEY_ROOT "/dir5", KEY_DIR, KEY_VALUE,"value5", KEY_COMMENT,"comment5", KEY_END);
 657         succeed_if (kdbSetKey(kdb,key1)!=-1, "could not kdbSet a key");
 658         keyDel (key1);
 659         kdbClose(kdb);
 660
 661         // get key test3
 662         kdb=kdbOpen();
 663         key1=keyNew(KEY_ROOT "/dir5", KEY_END);
 664         if (kdbGetKey(kdb,key1)==-1) {
 665                 succeed_if(0,"kdbGetKey failed");
 666         }
 667         succeed_if (strcmp (keyValue (key1), "value5") == 0, "Value not correct");
 668         succeed_if (strcmp (keyComment(key1), "comment5") == 0, "Comment not correct");
 669         succeed_if (keyIsDir(key1) , "not a directory");
 670         keyDel (key1);
 671         kdbClose(kdb);
 672
 673         // delete key test3
 674         kdb=kdbOpen();
 675         key1=keyNew(KEY_ROOT "/dir5", KEY_REMOVE, KEY_END);
 676         succeed_if (kdbSetKey (kdb,key1)!=-1, "could not set a key");
 677         keyDel (key1);
 678         kdbClose(kdb);
 679
 680         return;
 681 }
 682
 683 int main()
 684 {
 685         printf("\n\n");
 686         printf("ELEKTRA SET/GET TEST SUITE\n");
 687         printf("========================================\n\n");
 688
 689         exit_if_fail (loadToolsLib()==0, "Unable to load elektratools");
 690
 691         init ();
 692
 693         test_simple_getset();
 694         test_writeread();
 695         test_subdir();
 696         test_mode();
 697         test_highlevel_getset();
 698         test_simple_recursive_getset();
 699         test_recursive_getset();
 700         test_directory_getset();
 701         test_directory_highlevel_getset();
 702
 703         printf("\ntest_getset RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
 704
 705         return nbError;
 706 }
 707