tests/test_key.c

   1 /***************************************************************************
   2  *          test_key.c  -  Key struct test suite
   3  *                  -------------------
   4  *  begin                : Thu Aug 03 2006
   5  *  copyright            : (C) 2006 by Yannick Lecaillez
   6  *  email                : sizon5@gmail.com
   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 #ifdef HAVE_CONFIG_H
  17 #include "config.h"
  18 #endif
  19
  20 #include <tests.h>
  21
  22
  23 struct test {
  24         char    *testName;
  25         char    *keyName;
  26
  27         char    *expectedKeyName;
  28         char    *expectedBaseName;
  29         char    *expectedFRootName;
  30         char    *expectedParentName;
  31 };
  32
  33 struct test tstKeyName[] =
  34 {
  35         { "Normal key", "system/foo/bar",
  36                 "system/foo/bar",
  37                 "bar",
  38                 "system",
  39                 "system/foo"
  40         },
  41
  42         { "Key containing redundant & trailing separator", "system//foo//bar//",
  43                 "system/foo/bar",       /* keyName      */
  44                 "bar",                  /* keyBaseName  */
  45                 "system",               /* keyGetFullRootName   */
  46                 "system/foo"            /* keyGetParentName     */
  47         },
  48
  49         { "Normal user key", "user/key",
  50                 "user/key",                     /* keyName      */
  51                 "key",                          /* keyBaseName  */
  52                 "user:env1",                    /* keyGetFullRootName   */
  53                 "user"                          /* keyGetParentName     */
  54
  55         },
  56
  57         { "Normal user key with owner", "user:owner/key",
  58                 "user/key",                     /* keyName      */
  59                 "key",                          /* keyBaseName  */
  60                 "user:owner",                   /* keyGetFullRootName   */
  61                 "user"                          /* keyGetParentName     */
  62
  63         },
  64
  65         { "Depth user key with owner", "user:owner/folder/long/base/dir/key",
  66                 "user/folder/long/base/dir/key", /* keyName     */
  67                 "key",                          /* keyBaseName  */
  68                 "user:owner",                   /* keyGetFullRootName   */
  69                 "user/folder/long/base/dir"     /* keyGetParentName     */
  70
  71         },
  72
  73         { "Key containing escaped separator", "user:yl///foo\\///bar\\/foo_bar\\",
  74                 "user/foo\\//bar\\/foo_bar\\",  /* keyName      */
  75                 "bar\\/foo_bar\\",              /* keyBaseName  */
  76                 "user:yl",                      /* keyGetFullRootName   */
  77                 "user/foo\\/"                   /* keyGetParentName     */
  78
  79         },
  80
  81         { "Key containing escaped separator at the end", "user:yl///foo\\///bar\\/foo_bar\\/",
  82                 "user/foo\\//bar\\/foo_bar\\/", /* keyName      */
  83                 "bar\\/foo_bar\\/",             /* keyBaseName  */
  84                 "user:yl",                      /* keyGetFullRootName   */
  85                 "user/foo\\/"                   /* keyGetParentName     */
  86
  87         },
  88
  89         { NULL, NULL, NULL }
  90 };
  91
  92 void test_keyComparing()
  93 {
  94         Key *key1 = keyNew(0);
  95         Key *key2 = keyNew(0);
  96
  97         succeed_if(keyCompare(key1,key2) == 0, "the keys don't differ of course");
  98
  99         keySetName (key1, "user/myname");
 100         succeed_if(keyCompare(key1,key2) == KEY_NAME, "the keys should differ in name");
 101         keySetName (key2, "user/myname");
 102         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in name");
 103
 104         keySetOwner (key1, "myowner");
 105         succeed_if(keyCompare(key1,key2) == KEY_OWNER, "the keys should differ in owner");
 106         keySetOwner (key2, "myowner");
 107         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in owner");
 108
 109         keySetString (key1, "myvalue");
 110         succeed_if(keyCompare(key1,key2) == (KEY_VALUE|KEY_TYPE), "the keys should differ in value and type");
 111         keySetType (key2, KEY_TYPE_STRING);
 112         succeed_if(keyCompare(key1,key2) == KEY_VALUE, "the keys should differ in value");
 113         keySetString (key2, "myvalue");
 114         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in value");
 115
 116         keySetComment (key1, "mycomment");
 117         succeed_if(keyCompare(key1,key2) == KEY_COMMENT, "the keys should differ in comment");
 118         keySetComment (key2, "mycomment");
 119         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in comment");
 120
 121         keySetUID (key1, 50);
 122         succeed_if(keyCompare(key1,key2) == KEY_UID, "the keys should differ in uid");
 123         keySetUID (key2, 50);
 124         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in uid");
 125
 126         keySetGID (key1, 50);
 127         succeed_if(keyCompare(key1,key2) == KEY_GID, "the keys should differ in gid");
 128         keySetGID (key2, 50);
 129         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in gid");
 130
 131         keySetMode (key1, 0222);
 132         succeed_if(keyCompare(key1,key2) == KEY_MODE, "the keys should differ in mode");
 133         keySetMode (key2, 0222);
 134         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in mode");
 135
 136         keySetType (key1, 50);
 137         succeed_if(keyCompare(key1,key2) == KEY_TYPE, "the keys should differ in type");
 138         keySetType (key2, 50);
 139         succeed_if(keyCompare(key1,key2) == 0, "the keys should not differ in type");
 140
 141         keyDel (key1);
 142         keyDel (key2);
 143 }
 144
 145 void test_keyNewSystem()
 146 {
 147         Key     *key;
 148         char array[] = "here is some data stored";
 149         char * getBack;
 150         Key *k1;
 151         Key *k2;
 152         Key *k3;
 153
 154         printf("Test system key creation\n");
 155
 156         // Empty key
 157         key = keyNew(0);
 158         succeed_if(key != NULL, "keyNew: Unable to create a new empty key");
 159         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete empty key");
 160
 161         // Key with name
 162         key = keyNew("system/sw/test", KEY_END);
 163         succeed_if(key != NULL, "keyNew: Unable to create a key with name");
 164         succeed_if(keyNeedRemove (key) == 0, "KEY_REMOVE set");
 165         succeed_if(strcmp(keyName(key), "system/sw/test") == 0, "keyNew: Key's name setted incorrectly");
 166         keyCopy (key, 0);
 167         succeed_if (strcmp (keyName(key), "") == 0, "name after keyCopy(,0)");
 168         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name");
 169
 170         // Key with name
 171         key = keyNew("system/sw/test", KEY_REMOVE, KEY_END);
 172         succeed_if(key != NULL, "keyNew: Unable to create a key with name");
 173         succeed_if(keyNeedRemove (key) == 1, "KEY_REMOVE not set");
 174         succeed_if(strcmp(keyName(key), "system/sw/test") == 0, "keyNew: Key's name setted incorrectly");
 175         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name");
 176
 177         // Key with name + value (default type must be KEY_TYPE_STRING)
 178         key = keyNew("system/sw/test",
 179                         KEY_VALUE, "test",
 180                         KEY_END);
 181         succeed_if(key != NULL, "keyNew: Unable to create a key with name + value of default type");
 182         succeed_if(keyIsString(key), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 183         succeed_if(strcmp(keyValue(key), "test") == 0, "keyNew: Value not set correctly");
 184         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + value");
 185
 186         // Key with name + UID/GID
 187         key = keyNew("system/sw/test",
 188                         KEY_UID, 123,
 189                         KEY_GID, 456,
 190                         KEY_END);
 191         succeed_if(key != NULL, "keyNew: Unable to create a key with name + UID + GID");
 192         succeed_if(keyGetUID(key) == 123, "keyNew: UID no set correctly");
 193         succeed_if(keyGetGID(key) == 456, "keyNew: GID not set correctly");
 194         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + UID + GID");
 195
 196         // Key with name + MODE
 197         key = keyNew("system/sw/test",
 198                         KEY_MODE, 0644,
 199                         KEY_END);
 200         succeed_if(key != NULL, "keyNew: Unable to create a key with name + mode");
 201         succeed_if(keyGetMode(key) == 0644, "keyNew: mode no set correctly");
 202         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + mode");
 203
 204         key = keyNew("system/valid/there",
 205                         KEY_TYPE, KEY_TYPE_BINARY,
 206                         KEY_SIZE, sizeof(array),
 207                         KEY_VALUE, array,
 208                         KEY_END);
 209         succeed_if(key != NULL, "keyNew: Unable to create a key with name + value of default type");
 210         succeed_if(keyIsBinary (key), "Could not set type to binary");
 211         succeed_if(keyGetValueSize(key) == sizeof(array), "Value size not correct");
 212         succeed_if(memcmp ((char *) keyValue(key), array, sizeof(array)) == 0, "could not get correct binary value");
 213         getBack = malloc (keyGetValueSize(key));
 214         keyGetBinary(key, getBack, keyGetValueSize(key));
 215         succeed_if(memcmp(getBack, array, sizeof(array)) == 0, "could not get correct value with keyGetBinary");
 216         free (getBack);
 217         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + owner");
 218
 219         key = keyNew("system", KEY_END);
 220         succeed_if (strcmp (keyName(key), "system") == 0, "Name Problem: System as basename");
 221         succeed_if (keyGetNameSize(key) == 7, "empty name size" );
 222         succeed_if (strcmp (keyOwner(key), "") == 0, "owner for a system key?");
 223         succeed_if (keyGetOwnerSize(key) == 1, "owner y size" );
 224         keyDel (key);
 225
 226         // testing multiple values at once
 227         k1=keyNew("system/1",  KEY_VALUE, "singlevalue", KEY_END);
 228         k2=keyNew("system/2",   KEY_VALUE, "myvalue", KEY_END);
 229         k3=keyNew("system/3", KEY_VALUE, "syskey",  KEY_END);
 230         succeed_if(k1 != NULL, "keyNew: Unable to create a key with name + value of default type");
 231         succeed_if(keyIsString(k1), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 232         succeed_if(strcmp(keyValue(k1), "singlevalue") == 0, "keyNew: Value not set correctly");
 233
 234         succeed_if(k2 != NULL, "keyNew: Unable to create a key with name + value of default type");
 235         succeed_if(keyIsString(k2), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 236         succeed_if(strcmp(keyValue(k2), "myvalue") == 0, "keyNew: Value not set correctly");
 237
 238         succeed_if(k3 != NULL, "keyNew: Unable to create a key with name + value of default type");
 239         succeed_if(keyIsString(k3), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 240         succeed_if(strcmp(keyValue(k3), "syskey") == 0, "keyNew: Value not set correctly");
 241
 242         succeed_if(keyDel(k1) == 0, "keyDel: Unable to delete key with name + value");
 243         succeed_if(keyDel(k2) == 0, "keyDel: Unable to delete key with name + value");
 244         succeed_if(keyDel(k3) == 0, "keyDel: Unable to delete key with name + value");
 245 }
 246
 247 void test_keyNewUser()
 248 {
 249         Key     *key;
 250         char array[] = "here is some data stored";
 251         char fullroot [MAX_PATH_LENGTH];
 252         char * getBack;
 253         Key *k1;
 254         Key *k2;
 255         Key *k3;
 256
 257         printf("Test user key creation\n");
 258
 259 #ifdef HAVE_SETENV
 260         setenv ("USER","hugo",1);
 261 #else
 262         putenv ("USER=hugo");
 263 #endif
 264         key = keyNew ("user/test/test", KEY_END);
 265         succeed_if( strcmp(keyOwner(key), "hugo") == 0, "keyNew: owner not set correctly");
 266         succeed_if( keyGetOwnerSize(key) == 5, "owner length not correct");
 267         keyGetFullName (key, fullroot, MAX_PATH_LENGTH);
 268         succeed_if( strcmp(keyOwner(key), "hugo") == 0, "keyNew: owner not set correctly");
 269         /* printf ("%s, %s, %s\n", keyName(key), keyBaseName(key), fullroot); */
 270         succeed_if(strcmp(keyName(key),"user/test/test") == 0, "Wrong keyname: keyName");
 271         succeed_if(strcmp(keyBaseName(key),"test") == 0, "Wrong keyname: keyBaseName");
 272         succeed_if(strcmp(fullroot,"user:hugo/test/test") == 0, "Wrong keyname: keyGetFullName");
 273         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + owner");
 274
 275 #ifdef HAVE_SETENV
 276         setenv ("KDB_USER","tommy",1);
 277 #else
 278         putenv("KDB_USER=tommy");
 279 #endif
 280         key = keyNew ("user/test/test", KEY_END);
 281         succeed_if( strcmp(keyOwner(key), "tommy") == 0, "keyNew: owner not set correctly");
 282         succeed_if( keyGetOwnerSize(key) == 6, "owner length not correct");
 283         keyGetFullName (key, fullroot, MAX_PATH_LENGTH);
 284         succeed_if( strcmp(keyOwner(key), "tommy") == 0, "keyNew: owner not set correctly");
 285         /* printf ("%s, %s, %s\n", keyName(key), keyBaseName(key), fullroot); */
 286         succeed_if(strcmp(keyName(key),"user/test/test") == 0, "Wrong keyname: keyName");
 287         succeed_if(strcmp(keyBaseName(key),"test") == 0, "Wrong keyname: keyBaseName");
 288         succeed_if(strcmp(fullroot,"user:tommy/test/test") == 0, "Wrong keyname: keyGetFullName");
 289         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + owner");
 290
 291         // Key with name + owner
 292         key = keyNew("user/test/test",
 293                         KEY_OWNER, "yl",
 294                         KEY_END);
 295         succeed_if(key != NULL, "keyNew: Unable to create a key with name + owner");
 296         succeed_if( strcmp(keyOwner(key), "yl") == 0, "keyNew: owner not set correctly");
 297         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + owner");
 298
 299         key = keyNew("user/valid/there",
 300                         KEY_TYPE, KEY_TYPE_BINARY,
 301                         KEY_SIZE, sizeof(array),
 302                         KEY_VALUE, array,
 303                         KEY_END);
 304         succeed_if(key != NULL, "keyNew: Unable to create a key with name + value of default type");
 305         succeed_if(keyIsBinary (key), "Could not set type to binary");
 306         succeed_if(keyGetValueSize(key) == sizeof(array), "Value size not correct");
 307         succeed_if(memcmp ((char *) keyValue(key), array, sizeof(array)) == 0, "could not get correct binary value");
 308         getBack = malloc (keyGetValueSize(key));
 309         keyGetBinary(key, getBack, keyGetValueSize(key));
 310         succeed_if(memcmp(getBack, array, sizeof(array)) == 0, "could not get correct value with keyGetBinary");
 311         free (getBack);
 312         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name + owner");
 313
 314         key = keyNew("user:y", KEY_END);
 315         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: System as basename");
 316         succeed_if (keyGetNameSize(key) == 5, "empty name size" );
 317         succeed_if (strcmp (keyOwner(key), "y") == 0, "Should be a name not length 0");
 318         succeed_if (keyGetOwnerSize(key) == 2, "owner y size" );
 319         keyDel (key);
 320
 321         succeed_if (key = keyNew("user:perfectowner", KEY_END), "could not create new key");
 322         succeed_if (keySetName(key, "user:perfectowner") == 5, "could not set to user with owner");
 323         succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
 324         succeed_if (strcmp (keyOwner(key), "perfectowner") == 0, "Owner not same as set");
 325         succeed_if (keyDel (key) == 0, "could not delete key");
 326
 327         // testing multiple values at once
 328         k1=keyNew("user/1",  KEY_VALUE, "singlevalue", KEY_END);
 329         k2=keyNew("user/2",   KEY_VALUE, "myvalue", KEY_END);
 330         k3=keyNew("user/3", KEY_VALUE, "syskey",  KEY_END);
 331         succeed_if(k1 != NULL, "keyNew: Unable to create a key with name + value of default type");
 332         succeed_if(keyIsString(k1), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 333         succeed_if(strcmp(keyValue(k1), "singlevalue") == 0, "keyNew: Value not set correctly");
 334
 335         succeed_if(k2 != NULL, "keyNew: Unable to create a key with name + value of default type");
 336         succeed_if(keyIsString(k2), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 337         succeed_if(strcmp(keyValue(k2), "myvalue") == 0, "keyNew: Value not set correctly");
 338
 339         succeed_if(k3 != NULL, "keyNew: Unable to create a key with name + value of default type");
 340         succeed_if(keyIsString(k3), "keyNew: Default key value isn't set to KEY_TYPE_STRING");
 341         succeed_if(strcmp(keyValue(k3), "syskey") == 0, "keyNew: Value not set correctly");
 342
 343         succeed_if(keyDel(k1) == 0, "keyDel: Unable to delete key with name + value");
 344         succeed_if(keyDel(k2) == 0, "keyDel: Unable to delete key with name + value");
 345         succeed_if(keyDel(k3) == 0, "keyDel: Unable to delete key with name + value");
 346
 347         k1 = keyNew ("invalid", KEY_END);
 348         succeed_if (k1 != 0, "should construct key even on invalid names");
 349         succeed_if (strcmp (keyName(k1), "") == 0, "no name should be set");
 350         succeed_if (keyGetNameSize(k1) == 1, "namesize");
 351         keyDel (k1);
 352 }
 353
 354 void test_keyReference()
 355 {
 356         printf("Test key reference\n");
 357
 358         Key *key = keyNew (KEY_END);
 359         Key *c = keyNew (KEY_END);
 360         Key *d;
 361         KeySet *ks1, *ks2;
 362         succeed_if (keyGetRef(key) == 0, "New created key reference");
 363
 364         succeed_if (keyIncRef (key) == 1, "keyIncRef return value");
 365         succeed_if (keyGetRef(key) == 1, "After keyIncRef key reference");
 366         succeed_if (keyIncRef (key) == 2, "keyIncRef return value");
 367         succeed_if (keyGetRef(key) == 2, "After keyIncRef key reference");
 368         succeed_if (keyIncRef (key) == 3, "keyIncRef return value");
 369         succeed_if (keyGetRef(key) == 3, "After keyIncRef key reference");
 370         succeed_if (keyIncRef (key) == 4, "keyIncRef return value");
 371         succeed_if (keyGetRef(key) == 4, "After keyIncRef key reference");
 372
 373         d = keyDup (key);
 374         succeed_if (keyGetRef(d) == 0, "After keyDup key reference");
 375         succeed_if (keyIncRef (d) == 1, "keyIncRef return value");
 376         succeed_if (keyGetRef(key) == 4, "Reference should not change");
 377         succeed_if (keyDecRef (d) == 0, "decrement key");
 378         succeed_if (keyDel(d) == 0, "last keyDel d, key exist");
 379
 380         keyCopy (c, key);
 381         succeed_if (keyGetRef(c) == 0, "After keyCopy key reference");
 382         succeed_if (keyIncRef (c) == 1, "keyIncRef return value");
 383         succeed_if (keyGetRef(key) == 4, "Reference should not change");
 384
 385         keyCopy (c, key);
 386         succeed_if (keyGetRef(c) == 1, "After keyCopy key reference");
 387         succeed_if (keyDecRef (c) == 0, "keyDecRef return value");
 388         succeed_if (keyGetRef(key) == 4, "Reference should not change");
 389
 390         succeed_if (keyIncRef (c) == 1, "keyIncRef return value");
 391         succeed_if (keyIncRef (c) == 2, "keyIncRef return value");
 392         keyCopy (c, key);
 393         succeed_if (keyGetRef(c) == 2, "After keyCopy key reference");
 394         succeed_if (keyDecRef (c) == 1, "keyDecRef return value");
 395         succeed_if (keyDecRef (c) == 0, "keyDecRef return value");
 396         succeed_if (keyDel (c) == 0, "could not delete copy");
 397
 398         succeed_if (keyGetRef(key) == 4, "After keyIncRef key reference");
 399         succeed_if (keyDecRef (key) == 3, "keyDel return value");
 400         succeed_if (keyDel (key) == 3, "should not do anything");
 401         succeed_if (keyGetRef(key) == 3, "After keyIncRef key reference");
 402         succeed_if (keyDecRef (key) == 2, "keyDel return value");
 403         succeed_if (keyDel (key) == 2, "should not do anything");
 404         succeed_if (keyGetRef(key) == 2, "After keyIncRef key reference");
 405         succeed_if (keyDecRef (key) == 1, "keyDel return value");
 406         succeed_if (keyDel (key) == 1, "should not do anything");
 407         succeed_if (keyGetRef(key) == 1, "Should have no more reference");
 408         succeed_if (keyDecRef (key) == 0, "last keyDel key, key exist");
 409         succeed_if (keyDel (key) == 0, "last keyDel key, key exist");
 410
 411         /* From examples in ksNew () */
 412         key = keyNew(0); // ref counter 0
 413         succeed_if (keyGetRef(key) == 0, "reference counter");
 414         keyIncRef(key); // ref counter of key 1
 415         succeed_if (keyGetRef(key) == 1, "reference counter");
 416         keyDel(key);    // has no effect
 417         succeed_if (keyGetRef(key) == 1, "reference counter");
 418         keyDecRef(key); // ref counter back to 0
 419         succeed_if (keyGetRef(key) == 0, "reference counter");
 420         keyDel(key);    // key is now deleted
 421
 422         ks1 = ksNew(0);
 423         ks2 = ksNew(0);
 424         key = keyNew(0); // ref counter 0
 425         succeed_if (keyGetRef(key) == 0, "reference counter");
 426         ksAppendKey(ks1, key); // ref counter of key 1
 427         succeed_if (keyGetRef(key) == 1, "reference counter");
 428         ksAppendKey(ks2, key); // ref counter of key 2
 429         succeed_if (keyGetRef(key) == 2, "reference counter");
 430         ksDel(ks1); // ref counter of key 1
 431         succeed_if (keyGetRef(key) == 1, "reference counter");
 432         ksDel(ks2); // key is now deleted
 433
 434         key = keyNew(0); // ref counter 0
 435         succeed_if (keyGetRef(key) == 0, "reference counter");
 436         keyIncRef(key); // ref counter of key 1
 437         succeed_if (keyGetRef(key) == 1, "reference counter");
 438         keyDel (key);   // has no effect
 439         succeed_if (keyGetRef(key) == 1, "reference counter");
 440         keyIncRef(key); // ref counter of key 2
 441         succeed_if (keyGetRef(key) == 2, "reference counter");
 442         keyDel (key);   // has no effect
 443         succeed_if (keyGetRef(key) == 2, "reference counter");
 444         keyDecRef(key); // ref counter of key 1
 445         succeed_if (keyGetRef(key) == 1, "reference counter");
 446         keyDel (key);   // has no effect
 447         succeed_if (keyGetRef(key) == 1, "reference counter");
 448         keyDecRef(key); // ref counter is now 0
 449         succeed_if (keyGetRef(key) == 0, "reference counter");
 450         keyDel (key); // key is now deleted
 451
 452         return;
 453
 454         /* This code needs very long to execute, especially on 64bit
 455          * systems. */
 456
 457         key = keyNew(0); // ref counter 0
 458         while (keyGetRef(key) < SSIZE_MAX) keyIncRef(key);
 459         succeed_if (keyGetRef(key) == SSIZE_MAX, "reference counter");
 460         succeed_if (keyIncRef(key) == SSIZE_MAX, "should stay at maximum");
 461         succeed_if (keyGetRef(key) == SSIZE_MAX, "reference counter");
 462         succeed_if (keyIncRef(key) == SSIZE_MAX, "should stay at maximum");
 463
 464         key->ksReference = 5;
 465         while (keyGetRef(key) > 0) keyDecRef(key);
 466         succeed_if (keyGetRef(key) == 0, "reference counter");
 467         succeed_if (keyDecRef(key) == 0, "should stay at minimum");
 468         succeed_if (keyGetRef(key) == 0, "reference counter");
 469         succeed_if (keyDecRef(key) == 0, "should stay at minimum");
 470         keyDel (key);
 471
 472 }
 473
 474 void test_keyType()
 475 {
 476         Key * key;
 477         char array [] = "test";
 478         int i;
 479
 480         printf("Test key type\n");
 481
 482         key = keyNew (KEY_END);
 483
 484         for (i=0; i<256; i++)
 485         {
 486                 keySetType (key, i);
 487                 succeed_if (keyGetType (key) == (i), "could not change to dir type to something between 0 and 255");
 488         }
 489
 490         keySetType (key, 0);
 491         succeed_if (keyGetType (key) == 0, "could not unset type");
 492
 493         succeed_if (keySetString (key, array) == 5, "size not correct");
 494         succeed_if (keyIsString (key), "could not change to string type");
 495         succeed_if (keyGetValueSize (key) == sizeof (array), "size is not correct");
 496
 497         succeed_if (keySetBinary (key, array, 4) == 4, "size not correct");
 498         succeed_if (keyIsBinary (key), "could not change to binary type");
 499         succeed_if (keyGetValueSize (key) == sizeof (array)-1, "size is not correct");
 500
 501         succeed_if (keySetString (key, array) == 5, "size not correct");
 502         succeed_if (keyIsString (key), "could not change to string type");
 503         succeed_if (keyGetValueSize (key) == sizeof (array), "size is not correct");
 504
 505         keyDel (key);
 506 }
 507
 508 void test_keyName()
 509 {
 510         Key     *key;
 511         size_t  size;
 512         char    *buf;
 513         char    ret [1000];
 514         int     i;
 515         char *getBack;
 516         char testName[] = "user/name";
 517         char testFullName[] = "user:max/name";
 518         char testBaseName[] = "name";
 519         char testOwner[] = "max";
 520
 521         Key * copy = keyNew (KEY_END);
 522
 523 #ifdef HAVE_CLEARENV
 524         clearenv();
 525 #else
 526         unsetenv("USER");
 527 #endif
 528
 529         printf ("Test Key Name\n");
 530
 531         key = keyNew (testName, KEY_END);
 532         succeed_if (keyGetName (0,ret,100) == -1, "null pointer");
 533         succeed_if (keyGetName (key,0,100) == -1, "string null pointer");
 534         succeed_if (keyGetName (key,ret,0) == -1, "length checking");
 535         for (i=1; i< sizeof(testName);i++)
 536         {
 537                 succeed_if (keyGetName (key,ret,i) == -1, "length checking too short");
 538         }
 539         for (i=sizeof(testName); i<sizeof(testName)*2; i++)
 540         {
 541                 succeed_if (keyGetName (key,ret,i) == sizeof(testName), "length checking longer");
 542         }
 543         succeed_if (keyGetName (key,ret, (size_t)-1) == -1, "maxSize exceeded");
 544         keyDel (key);
 545
 546         succeed_if (keyName(0) == 0, "null pointer");
 547
 548         key = keyNew (0);
 549         succeed_if (strcmp(keyName(key), "") == 0, "empty name");
 550         succeed_if (keyGetName (key,ret, 1000) == 1, "get empty name");
 551         succeed_if (strcmp(ret, "") == 0, "not empty name");
 552         succeed_if (keyGetName (key,ret, 0) == -1, "get empty name");
 553         keyDel (key);
 554
 555         succeed_if (keySetName(0,ret) == -1, "Null pointer");
 556
 557
 558
 559         printf ("Test Key Full Name\n");
 560
 561         key = keyNew (testFullName, KEY_END);
 562         succeed_if (keyGetFullName (0,ret,100) == -1, "null pointer");
 563         succeed_if (keyGetFullName (key,0,100) == -1, "string null pointer");
 564         succeed_if (keyGetFullName (key,ret,0) == -1, "length checking");
 565         for (i=1; i< sizeof(testFullName);i++)
 566         {
 567                 succeed_if (keyGetFullName (key,ret,i) == -1, "length checking too short");
 568         }
 569         for (i=sizeof(testFullName); i<sizeof(testFullName)*2; i++)
 570         {
 571                 succeed_if (keyGetFullName (key,ret,i) == sizeof(testFullName), "length checking longer");
 572         }
 573         succeed_if (keyGetFullName (key,ret, (size_t)-1) == -1, "maxSize exceeded");
 574         keyDel (key);
 575
 576         key = keyNew (0);
 577         succeed_if (keyIsUser(key) == 0, "empty user key?");
 578         succeed_if (keyIsSystem(key) == 0, "empty user key?");
 579         succeed_if (keyGetFullName (key,ret, 1000) == 1, "get empty name");
 580         succeed_if (strcmp(ret, "") == 0, "not empty name");
 581         succeed_if (keyGetFullName (key,ret, 0) == -1, "get empty name");
 582         keyDel (key);
 583
 584         succeed_if (keySetName(0,ret) == -1, "Null pointer");
 585
 586
 587
 588
 589         printf ("Test Key Base Name\n");
 590
 591         key = keyNew (testFullName, KEY_END);
 592         succeed_if (keyGetBaseName (0,ret,100) == -1, "null pointer");
 593         succeed_if (keyGetBaseName (key,0,100) == -1, "string null pointer");
 594         succeed_if (keyGetBaseName (key,ret,0) == -1, "length checking");
 595         for (i=1; i< sizeof(testBaseName);i++)
 596         {
 597                 succeed_if (keyGetBaseName (key,ret,i) == -1, "length checking too short");
 598         }
 599         for (i=sizeof(testBaseName); i<sizeof(testBaseName)*2; i++)
 600         {
 601                 succeed_if (keyGetBaseName (key,ret,i) == sizeof(testBaseName), "length checking longer");
 602         }
 603         succeed_if (keyGetBaseName (key,ret, (size_t)-1) == -1, "maxSize exceeded");
 604         keyDel (key);
 605
 606         succeed_if (keyBaseName(0) == 0, "null pointer");
 607
 608         key = keyNew (0);
 609         succeed_if (strcmp(keyBaseName(key), "") == 0, "empty name");
 610         succeed_if (keyIsUser(key) == 0, "empty user key?");
 611         succeed_if (keyIsSystem(key) == 0, "empty user key?");
 612         succeed_if (keyGetBaseName (key,ret, 1000) == 1, "get empty name");
 613         succeed_if (strcmp(ret, "") == 0, "not empty name");
 614         succeed_if (keyGetBaseName (key,ret, 0) == -1, "get empty name");
 615         keyDel (key);
 616
 617         succeed_if (keySetName(0,ret) == -1, "Null pointer");
 618
 619         key = keyNew ("user", KEY_END);
 620         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
 621         succeed_if (keyGetBaseName (key,ret,1) == 1, "GetBaseName for root key");
 622         succeed_if (strcmp (ret, "") == 0, "did not return correct basename");
 623         succeed_if (keyGetBaseName (key,ret,2) == 1, "GetBaseName for root key");
 624         succeed_if (strcmp (ret, "") == 0, "did not return correct basename");
 625         keyDel (key);
 626
 627         key = keyNew ("system", KEY_END);
 628         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
 629         succeed_if (keyGetBaseName (key,ret,1) == 1, "GetBaseName for root key");
 630         succeed_if (strcmp (ret, "") == 0, "did not return correct basename");
 631         succeed_if (keyGetBaseName (key,ret,2) == 1, "GetBaseName for root key");
 632         succeed_if (strcmp (ret, "") == 0, "did not return correct basename");
 633         keyDel (key);
 634
 635
 636
 637
 638
 639         printf ("Test Key Owner\n");
 640
 641         key = keyNew (testFullName, KEY_END);
 642         succeed_if (keyGetOwner (0,ret,100) == -1, "null pointer");
 643         succeed_if (keyGetOwner (key,0,100) == -1, "string null pointer");
 644         succeed_if (keyGetOwner (key,ret,0) == -1, "length checking");
 645         for (i=1; i< sizeof(testOwner);i++)
 646         {
 647                 succeed_if (keyGetOwner (key,ret,i) == -1, "length checking too short");
 648         }
 649         for (i=sizeof(testOwner); i<sizeof(testOwner)*2; i++)
 650         {
 651                 succeed_if (keyGetOwner (key,ret,i) == sizeof(testOwner), "length checking longer");
 652         }
 653         succeed_if (keyGetOwner (key,ret, (size_t)-1) == -1, "maxSize exceeded");
 654
 655         succeed_if (keySetOwner(key,0) == 1, "delete owner");
 656         succeed_if (keyGetOwner (key,ret,i) == 1, "length checking deleting");
 657         succeed_if (strcmp(ret, "") == 0, "not empty owner");
 658
 659         succeed_if (keySetOwner(key,testOwner) == sizeof(testOwner), "set owner");
 660         succeed_if (keyGetOwner (key,ret,i) == sizeof(testOwner), "length checking working");
 661         succeed_if (strcmp(ret, testOwner) == 0, "not empty owner");
 662
 663         succeed_if (keySetOwner(key,"") == 1, "delete owner");
 664         succeed_if (keyGetOwner (key,ret,i) == 1, "length checking deleting");
 665         succeed_if (strcmp(ret, "") == 0, "not empty owner");
 666
 667         succeed_if (keySetOwner(key,testOwner) == sizeof(testOwner), "set owner");
 668         succeed_if (keyGetOwner (key,ret,i) == sizeof(testOwner), "length checking working");
 669         succeed_if (strcmp(ret, testOwner) == 0, "not empty owner");
 670         keyDel (key);
 671
 672         succeed_if (keyOwner(0) == 0, "null pointer");
 673
 674         key = keyNew (0);
 675         succeed_if (strcmp(keyOwner(key), "") == 0, "empty owner");
 676         succeed_if (keyGetOwner (key,ret, 1000) == 1, "get empty owner");
 677         succeed_if (strcmp(ret, "") == 0, "not empty owner");
 678         succeed_if (keyGetOwner (key,ret, 0) == -1, "get empty owner");
 679         keyDel (key);
 680
 681         succeed_if (keySetOwner(0,"") == -1, "null pointer");
 682
 683
 684
 685
 686
 687         printf("Test Slashes in Key Name\n");
 688         key = keyNew(0);
 689         succeed_if (keyGetNameSize(key) == 1, "empty name size" );
 690         keyDel (key);
 691
 692         key = keyNew("", KEY_END);
 693         succeed_if (key != 0, "key should not be null!");
 694         succeed_if (strcmp (keyName(key), "") == 0, "keyName should be "" string");
 695         succeed_if (keyGetName(key,ret, 999) == 1, "keyGetName should return 1");
 696         succeed_if (strcmp (ret, "") == 0, "\\0 should be first character in array");
 697         succeed_if (keyGetNameSize(key) == 1, "empty name size" );
 698         keyDel (key);
 699
 700         key = keyNew (KEY_END);
 701         keySetName(key,"user");
 702         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: User as basename");
 703         succeed_if (keyGetNameSize(key) == 5, "empty name size" );
 704         succeed_if (keyGetOwnerSize(key) >= 1, "empty owner size");
 705
 706         keySetName(key,"system");
 707         succeed_if (strcmp (keyName(key), "system") == 0, "Name Problem: System as basename");
 708         succeed_if (keyGetNameSize(key) == 7, "empty name size" );
 709         succeed_if (keyGetOwnerSize(key) == 1, "empty owner size");
 710         keyDel (key);
 711
 712         key = keyNew (KEY_END);
 713         keySetName(key,"system");
 714         succeed_if (strcmp (keyName(key), "system") == 0, "Name Problem: System as basename");
 715         succeed_if (keyGetNameSize(key) == 7, "empty name size" );
 716         succeed_if (keyGetOwnerSize(key) == 1, "empty owner size");
 717
 718         keySetName(key,"user");
 719         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: User as basename");
 720         succeed_if (keyGetNameSize(key) == 5, "empty name size" );
 721         succeed_if (keyGetOwnerSize(key) == 1, "empty owner size");
 722         keyDel (key);
 723
 724         key = keyNew(0);
 725         succeed_if (keySetName(key,"user:") == 5, "setting user: generates error");
 726         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: System as basename");
 727         succeed_if (keyGetNameSize(key) == 5, "empty name size" );
 728         succeed_if (strcmp (keyOwner(key), "") == 0, "Should be a name not length 0");
 729         succeed_if (keyGetOwnerSize(key) == 1, "empty owner size" );
 730         keyDel (key);
 731
 732         key = keyNew(0);
 733         succeed_if (keySetName(key,"user:y") == 5, "setting user: generates error");
 734         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: System as basename");
 735         succeed_if (keyGetNameSize(key) == 5, "empty name size" );
 736         succeed_if (strcmp (keyOwner(key), "y") == 0, "Should be a name not length 0");
 737         succeed_if (keyGetOwnerSize(key) == 2, "owner y size" );
 738         keyDel (key);
 739
 740         key = keyNew(0);
 741         succeed_if (keySetName(key,"no") == -1, "no error code setting invalid name");
 742         succeed_if (strcmp (keyName(key), "") == 0, "Name Problem: System as basename");
 743         succeed_if (keyGetNameSize(key) == 1, "empty name size" );
 744         keyDel (key);
 745
 746         key = keyNew("user/noname", KEY_END);
 747         succeed_if(keyGetNameSize(key) == 12, "size not correct after keyNew");
 748         getBack = malloc (12);
 749         succeed_if(keyGetName(key, getBack, 12), "could not get name");
 750         succeed_if(strcmp(getBack, "user/noname") == 0, "did not get correct value back");
 751         free (getBack);
 752
 753         keySetName (key, "user/noname");
 754         succeed_if(keyGetNameSize(key) == 12, "size not correct after keySetName");
 755         getBack = malloc (12);
 756         succeed_if(keyGetName(key, getBack, 12), "could not get name");
 757         succeed_if(strcmp(getBack, "user/noname") == 0, "did not get correct value back");
 758         free (getBack);
 759
 760         keySetName (key, "no");
 761         succeed_if(keyGetNameSize(key) == 1, "size not correct after keySetName");
 762         getBack = malloc (1);
 763         succeed_if(keyGetName(key, getBack, 1), "could not get name");
 764         succeed_if(strcmp(getBack, "") == 0, "did not get correct value back");
 765         free (getBack);
 766         keyDel (key);
 767
 768         key = keyNew("user/noname", KEY_END);
 769         keySetName(key,"");
 770         succeed_if (strcmp (keyName(key), "") == 0, "keyName should be "" string");
 771         succeed_if (keyGetName(key,ret, 999) == 1, "keyGetName should return 1");
 772         succeed_if (strcmp (ret, "") == 0, "\\0 should be first character in array");
 773         succeed_if (keyGetNameSize(key) == 1, "empty name size" );
 774
 775         keySetName(key,"user//hidden");
 776         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Two slashes in name");
 777         succeed_if (keyGetNameSize(key) == 12, "name size minus slashes" );
 778
 779         keySetName(key,"user///hidden");
 780         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Three slashes in name");
 781         succeed_if (keyGetNameSize(key) == 12, "name size minus slashes" );
 782
 783         keySetName(key,"user////////////////////////////////////hidden");
 784         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Many slashes in name");
 785         succeed_if (keyGetNameSize(key) == 12, "name size minus slashes" );
 786
 787         printf("Test trailing Slashes in Key Name\n");
 788         keySetName(key,"user//hidden/");
 789         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Trailing Slashes");
 790         succeed_if (keyGetNameSize(key) == 12, "name size minus slashes" );
 791
 792         keySetName(key,"user//hidden//");
 793         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Trailing Slashes");
 794         succeed_if (keyGetNameSize(key) == 12, "name size minus slashes" );
 795
 796         keySetName(key,"user//hidden///////");
 797         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Trailing Slashes");
 798         succeed_if (keyGetNameSize(key) == 12, "name size minus slashes" );
 799
 800         keySetName(key,"user/");
 801         // printf ("Name: %s\n", keyName(key));
 802         succeed_if (strcmp (keyName(key), "user") == 0, "Trailing Slashes");
 803
 804         keySetName(key,"user/a");
 805         succeed_if (strcmp (keyName(key), "user/a") == 0, "Trailing Slashes: One letter problem");
 806
 807         keySetName(key,"user//");
 808         succeed_if (strcmp (keyName(key), "user") == 0, "Trailing Slashes");
 809
 810         keySetName(key,"user/////////");
 811         succeed_if (strcmp (keyName(key), "user") == 0, "Trailing Slashes");
 812
 813         printf("Test Dots in Key Name\n");
 814         keySetName(key,"user/hidden/.");
 815         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Name Problem: Dot as basename");
 816
 817         keySetName(key,"user/.");
 818         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: Dot in Middle");
 819
 820         keySetName(key,"user/./hidden");
 821         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Name Problem: Dot in Middle");
 822
 823         keySetName(key,"user/.valid/.");
 824         succeed_if (strcmp (keyName(key), "user/.valid") == 0, "Name Problem: Dot as basename (with comment)");
 825
 826         keySetName(key,"user/./.valid");
 827         succeed_if (strcmp (keyName(key), "user/.valid") == 0, "Name Problem: Dot in Middle (with comment)");
 828
 829         keySetName(key,"user/./.valid/.");
 830         succeed_if (strcmp (keyName(key), "user/.valid") == 0, "Name Problem: More dots");
 831
 832         keySetName(key,"user/././././.valid/././././.");
 833         succeed_if (strcmp (keyName(key), "user/.valid") == 0, "Name Problem: Much more dots");
 834
 835         printf("Test Double Dots in Key Name\n");
 836         keySetName(key,"user/hidden/parent/..");
 837         succeed_if (strcmp (keyName(key), "user/hidden") == 0, "Name Problem: Double Dot as basename");
 838
 839         keySetName(key,"user/hidden/..");
 840         // printf ("Name: %s\n", keyName(key));
 841         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: Double Dot as basename");
 842
 843         keySetName(key,"user/..");
 844         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: Can't go higher then user in hierachy");
 845
 846         keySetName(key,"user/hidden/../..");
 847         succeed_if (strcmp (keyName(key), "user") == 0, "Name Problem: Can't go higher then user in hierachy");
 848
 849         succeed_if (keySetName(key, "user///sw/../sw//././MyApp")==sizeof("user/sw/MyApp"), "could not set keySet example");
 850         succeed_if (strcmp (keyName(key), "user/sw/MyApp") == 0, "Example of keySet does not work");
 851         succeed_if (keyGetNameSize(key) == sizeof("user/sw/MyApp"), "incorrect length for keySet example");
 852
 853         printf("Test Mixed Dots and Slashes in Key Name\n");
 854         keySetName(key,"user/hidden/../.");
 855
 856         keyDel (key);
 857
 858
 859         printf("Test failure key creation\n");
 860
 861         key = keyNew ("invalid", KEY_END);
 862         succeed_if (key!=0, "null pointer for invalid name");
 863         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name");
 864
 865         key = keyNew("nonhere/valid/there", KEY_END);
 866         succeed_if (key != NULL, "keyNew did not accept wrong name");
 867         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name");
 868
 869         key = keyNew("nonhere:y/valid/there", KEY_END);
 870         succeed_if (key != NULL, "keyNew did not accept wrong name");
 871         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name");
 872
 873         key = keyNew ("user/validname", KEY_END);
 874         succeed_if(key != NULL, "keyNew: Unable to create a key with name");
 875         succeed_if(strcmp(keyName(key), "user/validname") == 0, "keyNew: Key's name setted incorrectly");
 876
 877         keySetName(key, "invalid");
 878         succeed_if (keyGetNameSize(key) == 1, "name size for invalid name");
 879         succeed_if(strcmp(keyName(key), "") == 0, "keyNew: Key's name setted incorrectly");
 880
 881         keySetName (key, "user/validname");
 882         succeed_if(strcmp(keyName(key), "user/validname") == 0, "keyNew: Key's name setted incorrectly");
 883
 884         keySetName(key, "");
 885         succeed_if (keyGetNameSize(key) == 1, "name size for invalid name");
 886         succeed_if(strcmp(keyName(key), "") == 0, "keyNew: Key's name setted incorrectly");
 887
 888         keySetName (key, "user/validname\\/t");
 889         succeed_if(strcmp(keyName(key), "user/validname\\/t") == 0, "keyNew: Key's name setted incorrectly");
 890
 891         keySetName(key, 0);
 892         succeed_if (keyGetNameSize(key) == 1, "name size for invalid name");
 893         succeed_if(strcmp(keyName(key), "") == 0, "keyNew: Key's name setted incorrectly");
 894
 895         keySetName (key, "user/validname\\");
 896         succeed_if(strcmp(keyName(key), "user/validname\\") == 0, "keyNew: Key's name setted incorrectly");
 897
 898         keySetName (key, "user/validname\\/");
 899         succeed_if(strcmp(keyName(key), "user/validname\\/") == 0, "keyNew: Key's name setted incorrectly");
 900         succeed_if(keyDel(key) == 0, "keyDel: Unable to delete key with name");
 901
 902 #ifdef HAVE_CLEARENV
 903         clearenv();
 904 #else
 905         unsetenv("USER");
 906         unsetenv("KDB_USER");
 907 #endif
 908
 909 #ifdef HAVE_SETENV
 910         setenv ("USER", "env1", 1);
 911 #else
 912         putenv ("USER=env1");
 913 #endif
 914
 915         printf("Test key's name manipulation\n");
 916         for(i = 0 ; tstKeyName[i].testName != NULL ; i++) {
 917                 key = keyNew(tstKeyName[i].keyName, KEY_END);
 918
 919                 /* keyName */
 920                 succeed_if( (strcmp(keyName(key), tstKeyName[i].expectedKeyName) == 0) , "keyName" );
 921
 922                 /* keyBaseName */
 923                 succeed_if( (strcmp(keyBaseName(key), tstKeyName[i].expectedBaseName) == 0), "keyBaseName" );
 924
 925                 /* keyGetFullRootNameSize */
 926                 size = keyGetFullRootNameSize(key);
 927                 succeed_if( (size == kdbiStrLen(tstKeyName[i].expectedFRootName)), "keyGetFullRootNameSize" );
 928
 929                 /* keyGetFullRootName */
 930                 buf = kdbiMalloc(size*sizeof(char));
 931                 keyGetFullRootName(key, buf, size);
 932                 // printf ("comp: %s - %s\n", buf, tstKeyName[i].expectedFRootName);
 933                 succeed_if( (strncmp(buf, tstKeyName[i].expectedFRootName, size) == 0), "keyGetFullRootName" );
 934                 free(buf);
 935
 936                 /* keyGetParentNameSize */
 937                 size = keyGetParentNameSize(key);
 938                 succeed_if( (size == kdbiStrLen(tstKeyName[i].expectedParentName)), "ketGetParentNameSize" );
 939
 940                 /* keyGetParentName */
 941                 size = keyGetParentNameSize(key)+1;
 942                 buf = kdbiMalloc(size*sizeof(char));
 943                 keyGetParentName(key, buf, size);
 944                 succeed_if( (strncmp(buf, tstKeyName[i].expectedParentName, size) == 0), "keyGetParentName" );
 945                 free(buf);
 946
 947                 /* keyGetBaseNameSize */
 948                 size = keyGetBaseNameSize(key);
 949                 succeed_if( (size == kdbiStrLen(tstKeyName[i].expectedBaseName)), "keyGetBaseNameSize" );
 950
 951                 /* keyGetBaseName */
 952                 size = keyGetBaseNameSize(key)+1;
 953                 buf = kdbiMalloc(size*sizeof(char));
 954                 keyGetBaseName(key, buf, size);
 955                 succeed_if( (strncmp(buf, tstKeyName[i].expectedBaseName, size) == 0), "keyGetBaseName" );
 956                 free(buf);
 957
 958                 /* keyGetNameSize */
 959                 size = keyGetNameSize(key);
 960                 succeed_if( (size == kdbiStrLen(tstKeyName[i].expectedKeyName)), "keyGetKeyNameSize" );
 961
 962                 /* keyGetName */
 963                 size = keyGetNameSize(key);
 964                 buf = kdbiMalloc(size*sizeof(char));
 965                 keyGetName(key, buf, size);
 966                 succeed_if( (strcmp(buf, tstKeyName[i].expectedKeyName) == 0), "keyGetName" );
 967                 free(buf);
 968
 969                 succeed_if (keyGetRef (copy) == 0, "reference of copy not correct");
 970                 keyCopy (copy, key);
 971                 succeed_if (compare_key (copy, key, 0) == 0, "keys are not equal after copy");
 972                 succeed_if (keyGetRef (copy) == 0, "reference of copy not correct");
 973
 974                 keyDel(key);
 975         }
 976         keyDel (copy);
 977 }
 978
 979
 980 void test_keyValue()
 981 {
 982         Key * key;
 983         char    ret [1000];
 984         int i;
 985         char testString[] = "teststring";
 986         char testBinary[] = "\0tes\1tbinary";
 987         testBinary[sizeof(testBinary)] = 'T';
 988
 989         printf("Test value of keys\n");
 990
 991         succeed_if (key = keyNew(0), "could not create new key");
 992         succeed_if (keyGetValueSize (key) == 1, "empty value size");
 993         succeed_if (keySetString (key,"perfectvalue") == 13, "could not set string");
 994         succeed_if (keyGetValueSize (key) == 13, "value size not correct");
 995         succeed_if (strcmp (keyValue(key), "perfectvalue") == 0, "String not same as set");
 996         succeed_if (keySetString (key,"perfectvalue") == 13, "could not re-set same string");
 997         succeed_if (strcmp (keyValue(key), "perfectvalue") == 0, "String not same as set");
 998         succeed_if (keySetString (key,"nearperfectvalue") == 17, "could not re-set other string");
 999         succeed_if (keyGetValueSize (key) == 17, "value size not correct");
1000         succeed_if (strcmp (keyValue(key), "nearperfectvalue") == 0, "String not same as set");
1001         succeed_if (keyGetString (key, ret, keyGetValueSize (key)>=999 ? 999 : keyGetValueSize (key))
1002                         == 17, "could not get string");
1003         succeed_if (strcmp (ret, "nearperfectvalue") == 0, "String not same as set");
1004         succeed_if (keyDel (key) == 0, "could not delete key");
1005
1006         succeed_if (key = keyNew(0), "could not create new key");
1007         succeed_if (strcmp (keyValue(key), "") == 0, "Empty value problem");
1008         succeed_if (keyGetValueSize(key) == 1, "Empty value size problem");
1009         succeed_if (keySetString (key,"") == 1, "could not set empty string");
1010         succeed_if (strcmp (keyValue(key), "") == 0, "Empty value problem");
1011         succeed_if (keyGetValueSize(key) == 1, "Empty value size problem");
1012         succeed_if (keyGetString(key, ret, 0) == -1, "Could not get empty value");
1013         succeed_if (keyGetString(key, ret, 1) == 1, "Could not get empty value");
1014         succeed_if (ret[0] == 0, "keyGetValue did not return empty value");
1015         succeed_if (keyDel (key) == 0, "could not delete key");
1016
1017         succeed_if (key = keyNew(0), "could not create new key");
1018         succeed_if (keySetString (key, "a long long string") == 19, "could not set string");
1019         succeed_if (keyGetString (key, ret, 6) == -1, "string not truncated");
1020         /*succeed_if (errno == KDB_ERR_TRUNC, "errno not set properly trunc");*/
1021         succeed_if (keyGetBinary (key, ret, 999) == -1, "binary not mismatch");
1022         /*succeed_if (errno == KDB_ERR_TYPEMISMATCH, "errno not set properly typemismatch");*/
1023         succeed_if (keyDel (key) == 0, "could not delete key");
1024
1025         succeed_if (key = keyNew(0), "could not create new key");
1026         succeed_if (keySetBinary (key, "a long long binary", 19) == 19, "could not set string");
1027         succeed_if (keyGetBinary (key, ret, 6) == -1, "binary not truncated");
1028         /*succeed_if (errno == KDB_ERR_TRUNC, "errno not set properly trunc");*/
1029         succeed_if (keyGetString (key, ret, 999) == -1, "string not mismatch");
1030         /*succeed_if (errno == KDB_ERR_TYPEMISMATCH, "errno not set properly typemismatch");*/
1031         succeed_if (keyDel (key) == 0, "could not delete key");
1032
1033         succeed_if (key = keyNew(0), "could not create new key");
1034         for (i=1; i<255; i++)
1035         {
1036                 ret[0] =  i; ret[1] = i; ret[2] = 0;
1037                 //output_key (key);
1038                 succeed_if (keySetString (key,ret) == 3, "could not set string");
1039                 succeed_if (strcmp (keyValue(key), ret) == 0, "String not same as set");
1040         }
1041         succeed_if (keyDel (key) == 0, "could not delete key");
1042
1043
1044
1045
1046         printf ("Test string of key\n");
1047
1048         succeed_if (keyValue(0) == 0, "null pointer");
1049         succeed_if (keyGetValueSize(0) == -1, "null pointer");
1050         succeed_if (keySetString(0,"") == -1, "null pointer");
1051
1052         key = keyNew(0);
1053         succeed_if (keyGetValueSize(key) == 1, "empty value size");
1054
1055         keySetString (key, testString);
1056         succeed_if (keyGetString (0,ret,100) == -1, "null pointer");
1057         succeed_if (keyGetString (key,0,100) == -1, "string null pointer");
1058         succeed_if (keyGetString (key,ret,0) == -1, "length checking");
1059
1060         for (i=1; i< sizeof(testString);i++)
1061         {
1062                 succeed_if (keyGetString (key,ret,i) == -1, "length checking too short");
1063         }
1064         for (i=sizeof(testString); i<sizeof(testString)*2; i++)
1065         {
1066                 succeed_if (keyGetString (key,ret,i) == sizeof(testString), "length checking longer");
1067         }
1068         succeed_if (keyGetString (key,ret, (size_t)-1) == -1, "maxSize exceeded");
1069
1070         succeed_if (keySetString(key,0) == 1, "delete string");
1071         succeed_if (keyGetString (key,ret,i) == 1, "length checking deleting");
1072         succeed_if (strcmp(ret, "") == 0, "not empty string");
1073
1074         succeed_if (keySetString(key,testString) == sizeof(testString), "set string");
1075         succeed_if (keyGetString (key,ret,i) == sizeof(testString), "length checking working");
1076         succeed_if (strcmp(ret, testString) == 0, "not empty string");
1077
1078         succeed_if (keySetString(key,"") == 1, "delete string");
1079         succeed_if (keyGetString (key,ret,i) == 1, "length checking deleting");
1080         succeed_if (strcmp(ret, "") == 0, "not empty string");
1081
1082         succeed_if (keySetString(key,testString) == sizeof(testString), "set string");
1083         succeed_if (keyGetString (key,ret,i) == sizeof(testString), "length checking working");
1084         succeed_if (strcmp(ret, testString) == 0, "not empty string");
1085
1086         succeed_if (keyGetValueSize(key) == sizeof(testString), "testString value size");
1087         succeed_if (strncmp(keyValue(key), testString, sizeof(testString)) == 0, "testString not same");
1088         keyDel (key);
1089
1090
1091
1092         printf ("Test binary of key\n");
1093
1094         succeed_if (keyValue(0) == 0, "null pointer");
1095         succeed_if (keyGetValueSize(0) == -1, "null pointer");
1096         succeed_if (keySetBinary(0,"",1) == -1, "null pointer");
1097
1098         key = keyNew(0);
1099         succeed_if (keySetBinary(key,"",0) == -1, "null size");
1100         succeed_if (keySetBinary(key,"b",0) == -1, "null size");
1101         succeed_if (keySetBinary(key,"",SIZE_MAX) == -1, "max size");
1102         succeed_if (keySetBinary(key,"b",SIZE_MAX) == -1, "max size");
1103         succeed_if (keyGetValueSize(key) == 1, "empty value size");
1104
1105         keySetBinary (key, testBinary, sizeof(testBinary));
1106         succeed_if (keyGetBinary (0,ret,100) == -1, "null pointer");
1107         succeed_if (keyGetBinary (key,0,100) == -1, "binary null pointer");
1108         succeed_if (keyGetBinary (key,ret,0) == -1, "length checking");
1109
1110         for (i=1; i< sizeof(testBinary);i++)
1111         {
1112                 succeed_if (keyGetBinary (key,ret,i) == -1, "length checking too short");
1113         }
1114         for (i=sizeof(testBinary); i<sizeof(testBinary)*2; i++)
1115         {
1116                 succeed_if (keyGetBinary (key,ret,i) == sizeof(testBinary), "length checking longer");
1117         }
1118         succeed_if (keyGetBinary (key,ret, (size_t)-1) == -1, "maxSize exceeded");
1119
1120         succeed_if (keySetBinary(key,0,0) == 0, "delete binary");
1121         succeed_if (keyGetBinary (key,ret,i) == 0, "length checking deleting");
1122
1123         succeed_if (keySetBinary(key,testBinary, sizeof(testBinary)) == sizeof(testBinary), "set binary");
1124         succeed_if (keyGetBinary (key,ret,i) == sizeof(testBinary), "length checking working");
1125         succeed_if (strcmp(ret, testBinary) == 0, "not empty binary");
1126
1127         succeed_if (keySetBinary(key,0,1) == 0, "delete binary");
1128         succeed_if (keyGetBinary (key,ret,i) == 0, "length checking deleting");
1129
1130         succeed_if (keySetBinary(key,testBinary, sizeof(testBinary)) == sizeof(testBinary), "set binary");
1131         succeed_if (keyGetBinary (key,ret,i) == sizeof(testBinary), "length checking working");
1132         succeed_if (strcmp(ret, testBinary) == 0, "not empty binary");
1133
1134         succeed_if (keySetBinary(key,"",1) == 1, "delete binary the string way");
1135         succeed_if (keyGetBinary (key,ret,i) == 1, "length checking deleting string way");
1136         succeed_if (strcmp(ret, "") == 0, "not empty binary the string way");
1137
1138         succeed_if (keySetBinary(key,testBinary, sizeof(testBinary)) == sizeof(testBinary), "set binary");
1139         succeed_if (keyGetBinary (key,ret,i) == sizeof(testBinary), "length checking working");
1140         succeed_if (strcmp(ret, testBinary) == 0, "not empty binary");
1141
1142         succeed_if (keyGetValueSize(key) == sizeof(testBinary), "testBinary value size");
1143         succeed_if (strncmp(keyValue(key), testBinary, sizeof(testBinary)) == 0, "testBinary not same");
1144         keyDel (key);
1145
1146 }
1147
1148 void test_keyBinary(void)
1149 {
1150         Key *key =0;
1151         char ret [1000];
1152         int i;
1153         char c;
1154         char binaryData[] = "\0binary \1\34data";
1155         binaryData[sizeof(binaryData)] = 'T';
1156
1157         printf ("Test binary special cases\n");
1158
1159         key = keyNew ("user/binary",
1160                 KEY_TYPE, KEY_TYPE_BINARY+1,
1161                 KEY_SIZE, sizeof(binaryData),
1162                 KEY_VALUE, binaryData,
1163                 KEY_END);
1164
1165         succeed_if (keyIsBinary(key) == 1, "should be binary");
1166         succeed_if (keyIsString(key) == 0, "should not be string");
1167         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1168         succeed_if (keyGetValueSize(key) == sizeof(binaryData), "size not correct");
1169         succeed_if (memcmp(binaryData, keyValue(key), sizeof(binaryData)) == 0, "memcmp");
1170         succeed_if (keyGetBinary(key, ret, 1000) == sizeof(binaryData), "could not get binary data");
1171         succeed_if (memcmp(binaryData, ret, sizeof(binaryData)) == 0, "memcmp");
1172         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1173
1174         keyDel (key);
1175
1176         key = keyNew(0);
1177         keySetType (key, KEY_TYPE_BINARY+1);
1178         keySetBinary (key, binaryData, sizeof(binaryData));
1179
1180         succeed_if (keyIsBinary(key) == 1, "should be binary");
1181         succeed_if (keyIsString(key) == 0, "should not be string");
1182         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1183         succeed_if (keyGetValueSize(key) == sizeof(binaryData), "size not correct");
1184         succeed_if (memcmp(binaryData, keyValue(key), sizeof(binaryData)) == 0, "memcmp");
1185         succeed_if (keyGetBinary(key, ret, 1000) == sizeof(binaryData), "could not get binary data");
1186         succeed_if (memcmp(binaryData, ret, sizeof(binaryData)) == 0, "memcmp");
1187         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1188
1189         keyDel (key);
1190
1191         key = keyNew(0);
1192         keySetType (key, KEY_TYPE_BINARY+1);
1193
1194         succeed_if (keyIsBinary(key) == 1, "should be binary");
1195         succeed_if (keyIsString(key) == 0, "should not be string");
1196         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1197         succeed_if (keyGetValueSize(key) == 0, "size not correct");
1198         succeed_if (keyValue(key) == 0, "should be null pointer");
1199         succeed_if (keyGetBinary(key, ret, 1000) == 0, "should write nothing because of no data");
1200         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1201
1202         keyDel (key);
1203
1204         key = keyNew(0);
1205         keySetBinary(key, 0, 0);
1206         keySetType (key, KEY_TYPE_BINARY+1);
1207
1208         succeed_if (keyIsBinary(key) == 1, "should be binary");
1209         succeed_if (keyIsString(key) == 0, "should not be string");
1210         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1211         succeed_if (keyGetValueSize(key) == 0, "size not correct");
1212         succeed_if (keyValue(key) == 0, "should be null pointer");
1213         succeed_if (keyGetBinary(key, ret, 1000) == 0, "should write nothing because of no data");
1214         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1215
1216         keyDel (key);
1217
1218         key = keyNew(0);
1219         keySetBinary(key, 0, 1);
1220         keySetType (key, KEY_TYPE_BINARY+1);
1221
1222         succeed_if (keyIsBinary(key) == 1, "should be binary");
1223         succeed_if (keyIsString(key) == 0, "should not be string");
1224         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1225         succeed_if (keyGetValueSize(key) == 0, "size not correct");
1226         succeed_if (keyValue(key) == 0, "should be null pointer");
1227         succeed_if (keyGetBinary(key, ret, 1000) == 0, "should write nothing because of no data");
1228         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1229
1230         keyDel (key);
1231
1232         key = keyNew(0);
1233         keySetBinary(key, "", 1);
1234         succeed_if (keySetBinary(key, 0, SIZE_MAX) == -1, "should do nothing and fail");
1235         succeed_if (keySetBinary(key, 0, SSIZE_MAX) == 0, "should free data");
1236         keySetType (key, KEY_TYPE_BINARY+1);
1237
1238         succeed_if (keyIsBinary(key) == 1, "should be binary");
1239         succeed_if (keyIsString(key) == 0, "should not be string");
1240         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1241         succeed_if (keyGetValueSize(key) == 0, "size not correct");
1242         succeed_if (keyValue(key) == 0, "should be null pointer");
1243         succeed_if (keyGetBinary(key, ret, 1000) == 0, "should write nothing because of no data");
1244         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1245
1246         keyDel (key);
1247
1248         key = keyNew(0);
1249         keySetBinary(key, "", 1);
1250         keySetType (key, KEY_TYPE_BINARY+1);
1251
1252         succeed_if (keyIsBinary(key) == 1, "should be binary");
1253         succeed_if (keyIsString(key) == 0, "should not be string");
1254         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1255         succeed_if (keyGetValueSize(key) == 1, "size not correct");
1256         succeed_if (memcmp(binaryData, keyValue(key), 1) == 0, "memcmp");
1257         succeed_if (keyGetBinary(key, ret, 1000) == 1, "could not get binary data");
1258         succeed_if (memcmp(binaryData, ret, 1) == 0, "memcmp");
1259         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1260
1261         keyDel (key);
1262
1263         key = keyNew(0);
1264         i = 23;
1265         keySetType (key, KEY_TYPE_BINARY+1);
1266         keySetBinary (key, (void*)&i, sizeof(i));
1267
1268         succeed_if (keyIsBinary(key) == 1, "should be binary");
1269         succeed_if (keyIsString(key) == 0, "should not be string");
1270         succeed_if (keyGetType(key) == KEY_TYPE_BINARY+1, "forgot its type");
1271         succeed_if (keyGetValueSize(key) == sizeof(i), "size not correct");
1272         succeed_if (memcmp((void*)&i, keyValue(key), sizeof(i)) == 0, "memcmp");
1273         succeed_if (keyGetBinary(key, ret, 1000) == sizeof(i), "could not get binary data");
1274         succeed_if (memcmp((void*)&i, ret, sizeof(i)) == 0, "memcmp");
1275         succeed_if (keyGetString(key, ret, 1000) == -1, "should be type mismatch");
1276
1277         i = *(int*)keyValue(key);
1278         succeed_if (i==23, "incorrect int");
1279
1280         keyDel (key);
1281
1282 }
1283
1284 void test_keyComment()
1285 {
1286         Key * key;
1287         char    ret [1000];
1288         int i;
1289         char testComment [] = "testcomment";
1290
1291         printf("Test comment of key\n");
1292
1293         succeed_if (key = keyNew(0), "could not create new key");
1294         succeed_if (keyGetCommentSize (key) == 1, "empty comment size");
1295         succeed_if (keySetComment (key,"perfectcomment") == 15, "could not set comment");
1296         succeed_if (keyGetCommentSize (key) == 15, "comment size not correct");
1297         succeed_if (strcmp (keyComment(key), "perfectcomment") == 0, "Comment not same as set");
1298         succeed_if (keySetComment (key,"perfectcomment") == 15, "could not re-set same comment");
1299         succeed_if (strcmp (keyComment(key), "perfectcomment") == 0, "Comment not same as set");
1300         succeed_if (keySetComment (key,"nearperfectcomment") == 19, "could not re-set other comment");
1301         succeed_if (keyGetCommentSize (key) == 19, "comment size not correct");
1302         succeed_if (strcmp (keyComment(key), "nearperfectcomment") == 0, "Comment not same as set");
1303         succeed_if (keyGetComment (key, ret, keyGetCommentSize (key)>=999 ? 999 : keyGetCommentSize (key))
1304                         == 19, "could not get comment");
1305         succeed_if (strcmp (ret, "nearperfectcomment") == 0, "Comment not same as set");
1306         succeed_if (keyDel (key) == 0, "could not delete key");
1307
1308         succeed_if (key = keyNew(0), "could not create new key");
1309         succeed_if (strcmp (keyComment(key), "") == 0, "Empty comment problem");
1310         succeed_if (keyGetCommentSize(key) == 1, "Empty comment size problem");
1311         succeed_if (keySetComment (key,"") == 0, "could not set comment");
1312         succeed_if (strcmp (keyComment(key), "") == 0, "Empty comment problem");
1313         succeed_if (keyGetCommentSize(key) == 1, "Empty comment size problem");
1314         succeed_if (keyGetComment(key, ret, 0) == -1, "Could not get empty comment");
1315         succeed_if (keyGetComment(key, ret, 1) == 1, "Could not get empty comment");
1316         succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
1317         succeed_if (keyDel (key) == 0, "could not delete key");
1318
1319         succeed_if (key = keyNew(0), "could not create new key");
1320         for (i=1; i<255; i++)
1321         {
1322                 ret[0] = i; ret[1] = i; ret[2] = 0;
1323                 succeed_if (keySetComment (key,ret) == 3, "could not set comment");
1324                 // output_key (key);
1325                 succeed_if (strcmp (keyComment(key), ret) == 0, "Comment not same as set");
1326         }
1327         succeed_if (keyDel (key) == 0, "could not delete key");
1328
1329
1330
1331         printf ("Test comment of key 2\n");
1332
1333         succeed_if (keyComment(0) == 0, "null pointer");
1334         succeed_if (keyGetCommentSize(0) == -1, "null pointer");
1335         succeed_if (keySetComment(0,"") == -1, "null pointer");
1336
1337         key = keyNew(0);
1338         succeed_if (keyGetCommentSize(key) == 1, "empty comment size");
1339
1340         keySetComment (key, testComment);
1341         succeed_if (keyGetComment (0,ret,100) == -1, "null pointer");
1342         succeed_if (keyGetComment (key,0,100) == -1, "comment null pointer");
1343         succeed_if (keyGetComment (key,ret,0) == -1, "length checking");
1344
1345         for (i=1; i< sizeof(testComment);i++)
1346         {
1347                 succeed_if (keyGetComment (key,ret,i) == -1, "length checking too short");
1348         }
1349         for (i=sizeof(testComment); i<sizeof(testComment)*2; i++)
1350         {
1351                 succeed_if (keyGetComment (key,ret,i) == sizeof(testComment), "length checking longer");
1352         }
1353         succeed_if (keyGetComment (key,ret, (size_t)-1) == -1, "maxSize exceeded");
1354
1355         succeed_if (keySetComment(key,0) == 1, "delete comment");
1356         succeed_if (keyGetComment (key,ret,i) == 1, "length checking deleting");
1357         succeed_if (strcmp(ret, "") == 0, "not empty comment");
1358
1359         succeed_if (keySetComment(key,testComment) == sizeof(testComment), "set comment");
1360         succeed_if (keyGetComment (key,ret,i) == sizeof(testComment), "length checking working");
1361         succeed_if (strcmp(ret, testComment) == 0, "not empty comment");
1362
1363         succeed_if (keySetComment(key,"") == 1, "delete comment");
1364         succeed_if (keyGetComment (key,ret,i) == 1, "length checking deleting");
1365         succeed_if (strcmp(ret, "") == 0, "not empty comment");
1366
1367         succeed_if (keySetComment(key,testComment) == sizeof(testComment), "set comment");
1368         succeed_if (keyGetComment (key,ret,i) == sizeof(testComment), "length checking working");
1369         succeed_if (strcmp(ret, testComment) == 0, "not empty comment");
1370
1371         succeed_if (keyGetCommentSize(key) == sizeof(testComment), "testComment comment size");
1372         succeed_if (strncmp(keyComment(key), testComment, sizeof(testComment)) == 0, "testComment not same");
1373         keyDel (key);
1374
1375 }
1376
1377 void test_keyOwner()
1378 {
1379         Key * key;
1380         char    ret [1000];
1381         int i;
1382         printf("Test owner of keys\n");
1383         succeed_if (key = keyNew(0), "could not create new key");
1384         succeed_if (keyGetOwnerSize (key) == 1, "empty owner size");
1385         succeed_if (keySetOwner (key,"perfectowner") == 13, "could not set owner");
1386         succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
1387         succeed_if (strcmp (keyOwner(key), "perfectowner") == 0, "Owner not same as set");
1388         succeed_if (keySetOwner (key,"perfectowner") == 13, "could not re-set same owner");
1389         succeed_if (strcmp (keyOwner(key), "perfectowner") == 0, "Owner not same as set");
1390         succeed_if (keySetOwner (key,"nearperfectowner") == 17, "could not re-set other owner");
1391         succeed_if (keyGetOwnerSize (key) == 17, "owner size not correct");
1392         succeed_if (strcmp (keyOwner(key), "nearperfectowner") == 0, "Owner not same as set");
1393         succeed_if (keyGetOwner (key, ret, keyGetOwnerSize (key)>=999 ? 999 : keyGetOwnerSize (key))
1394                         == 17, "could not get owner");
1395         succeed_if (strcmp (ret, "nearperfectowner") == 0, "Owner not same as set");
1396         succeed_if (keyDel (key) == 0, "could not delete key");
1397
1398         succeed_if (key = keyNew(0), "could not create new key");
1399         succeed_if (keySetName(key, "user:perfectowner") == 5, "could not set to user with owner");
1400         succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
1401         succeed_if (strcmp (keyOwner(key), "perfectowner") == 0, "Owner not same as set");
1402         succeed_if (keyDel (key) == 0, "could not delete key");
1403
1404         succeed_if (key = keyNew(0), "could not create new key");
1405         succeed_if (strcmp (keyOwner(key), "") == 0, "Empty owner problem");
1406         succeed_if (keyGetOwnerSize(key) == 1, "Empty owner size problem");
1407         succeed_if (keySetOwner (key,"") == 1, "could not set owner");
1408         succeed_if (strcmp (keyOwner(key), "") == 0, "Empty owner problem");
1409         succeed_if (keyGetOwnerSize(key) == 1, "Empty owner size problem");
1410         succeed_if (keyGetOwner(key, ret, 0) == -1, "Could not get empty owner");
1411         succeed_if (keyGetOwner(key, ret, 1) == 1, "Could not get empty owner");
1412         succeed_if (ret[0] == 0, "keyGetOwner did not return empty owner");
1413         succeed_if (keyDel (key) == 0, "could not delete key");
1414
1415         succeed_if (key = keyNew(0), "could not create new key");
1416         for (i=1; i<255; i++)
1417         {
1418                 ret[0] = i; ret[1] = i; ret[2] = 0;
1419                 succeed_if (keySetOwner (key,ret) == 3, "could not set owner");
1420                 // output_key (key);
1421                 succeed_if (strcmp (keyOwner(key), ret) == 0, "Owner not same as set");
1422         }
1423         succeed_if (keyDel (key) == 0, "could not delete key");
1424 }
1425
1426 void test_keyInactive ()
1427 {
1428         Key * key = keyNew(0);
1429
1430         succeed_if (keyIsInactive(0) == -1, "NULL pointer");
1431         succeed_if (keyIsInactive(key) == -1, "Key has no name");
1432
1433         printf("Test of active and inactive keys\n");
1434         keySetName(key,"user/valid");
1435         succeed_if (!keyIsInactive(key), "Key should not be inactive");
1436
1437         keySetName(key,"user/.hidden/valid");
1438         succeed_if (!keyIsInactive(key), "Key should not be inactive");
1439
1440         keySetName(key,"user/.hidden/€valid");
1441         succeed_if (!keyIsInactive(key), "Key should not be inactive");
1442
1443         keySetName(key,"user/hidden");
1444         succeed_if (!keyIsInactive(key), "Key should not be inactive");
1445
1446         keySetName(key,"user/.hidden");
1447         succeed_if (keyIsInactive(key), "Key should be inactive");
1448
1449         keySetName(key,"user/.valid/.hidden");
1450         succeed_if (keyIsInactive(key), "Key should be inactive");
1451
1452         keySetName(key,"user/.valid/.:hidden");
1453         succeed_if (keyIsInactive(key), "Key should be inactive");
1454
1455         keySetName(key,"user/.valid/.€hidden");
1456         succeed_if (keyIsInactive(key), "Key should be inactive");
1457
1458         keySetName(key,"user/.HiddenStringKey");
1459         succeed_if (keyIsInactive(key), "Key should be inactive");
1460
1461         keySetName(key,"user/.HiddenDirectoryKey");
1462         succeed_if (keyIsInactive(key), "Key should be inactive");
1463
1464         keySetName(key,"user/tests/file8xdLVS/filesys/.HiddenStringKey");
1465         succeed_if (keyIsInactive(key), "Key should be inactive");
1466         keyDel (key);
1467 }
1468
1469 void test_keyBelow()
1470 {
1471         Key * key1 = keyNew(0);
1472         Key * key2 = keyNew(0);
1473
1474         printf("Test of relative positions of keys\n");
1475
1476         succeed_if (keyIsBelow(key1,0) == -1, "NULL pointer");
1477         succeed_if (keyIsBelow(0,0) == -1, "NULL pointer");
1478         succeed_if (keyIsBelow(0,key1) == -1, "NULL pointer");
1479
1480         succeed_if (keyIsDirectBelow(key1,0) == -1, "NULL pointer");
1481         succeed_if (keyIsDirectBelow(0,0) == -1, "NULL pointer");
1482         succeed_if (keyIsDirectBelow(0,key1) == -1, "NULL pointer");
1483
1484         keySetName(key1,"user/valid");
1485         keySetName(key2,"user/valid");
1486         succeed_if (!keyIsBelow(key1,key2), "Key should not be below");
1487         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1488
1489         keySetName(key1,"user/valid");
1490         keySetName(key2,"user/valid/");
1491         succeed_if (!keyIsBelow(key1,key2), "Key should not be below");
1492         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1493
1494         keySetName(key1,"user/valid");
1495         keySetName(key2,"user/valid/below");
1496         succeed_if (keyIsBelow(key1,key2), "Key should be below");
1497         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1498
1499         keySetName(key1,"user/valid");
1500         keySetName(key2,"user/valid/b");
1501         succeed_if (keyIsBelow(key1,key2), "Key should be below");
1502         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1503
1504         keySetName(key1,"user/valid");
1505         keySetName(key2,"user/valid/b");
1506         succeed_if (keyIsBelow(key1,key2), "Key should be below");
1507         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1508
1509         keySetName(key1,"user/valid");
1510         keySetName(key2,"user/valid/b/e");
1511         succeed_if (keyIsBelow(key1,key2), "Key should be below");
1512         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1513
1514         keySetName(key1,"user/valide");
1515         keySetName(key2,"user/valid/e");
1516         succeed_if (!keyIsBelow(key1,key2), "Key should not be below");
1517         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1518
1519         keySetName(key1,"user/valid/b");
1520         keySetName(key2,"user/valid/e");
1521         succeed_if (!keyIsBelow(key1,key2), "Key should not be below");
1522         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1523
1524         keySetName(key1,"user/valide");
1525         keySetName(key2,"user/valid/valide");
1526         succeed_if (!keyIsBelow(key1,key2), "Key should not be below");
1527         succeed_if (!keyIsBelow(key2,key1), "Key should not be below");
1528
1529         keySetName(key1,"user/valid");
1530         keySetName(key2,"user/valid/valide");
1531         succeed_if (keyIsDirectBelow(key1,key2), "Key should be below");
1532         succeed_if (!keyIsDirectBelow(key2,key1), "Key should not be below");
1533
1534         keySetName(key1,"user/valid");
1535         keySetName(key2,"user/valid/non/valid");
1536         succeed_if (!keyIsDirectBelow(key1,key2), "Key should not be below");
1537         succeed_if (!keyIsDirectBelow(key2,key1), "Key should not be below");
1538
1539         keySetName(key1,"user/valid/a");
1540         keySetName(key2,"user/valid/b");
1541         succeed_if (!keyIsDirectBelow(key1,key2), "Key should not be below");
1542         succeed_if (!keyIsDirectBelow(key2,key1), "Key should not be below");
1543
1544         keySetName(key1,"user/valid");
1545         keySetName(key2,"user/valid");
1546         succeed_if (!keyIsDirectBelow(key1,key2), "Key should not be below");
1547         succeed_if (!keyIsDirectBelow(key2,key1), "Key should not be below");
1548
1549         keySetName(key1,"user/valid/a/b");
1550         keySetName(key2,"user/valid");
1551         succeed_if (!keyIsDirectBelow(key1,key2), "Key should not be below");
1552         succeed_if (!keyIsDirectBelow(key2,key1), "Key should not be below");
1553
1554         keySetName(key1,"user/valid/a");
1555         keySetName(key2,"user/valid");
1556         succeed_if (!keyIsDirectBelow(key1,key2), "Key should not be below");
1557         succeed_if (keyIsDirectBelow(key2,key1), "Key should be below");
1558
1559
1560         keyDel (key1);
1561         keyDel (key2);
1562 }
1563
1564 void test_keyDup()
1565 {
1566         Key     *orig, *copy;
1567
1568         printf("Test key duplication\n");
1569
1570         // Create test key
1571         orig = keyNew("user:yl/foo/bar",
1572                         KEY_TYPE, KEY_TYPE_BINARY,
1573                         KEY_SIZE, 6,
1574                         KEY_VALUE, "foobar",
1575                         KEY_COMMENT, "mycomment",
1576                         KEY_UID, 123,
1577                         KEY_GID, 456,
1578                         KEY_MODE, 0644,
1579                         KEY_END);
1580
1581
1582
1583         // Dup the key
1584         succeed_if( (copy = keyDup(orig)) != 0, "keyDup failed");
1585         succeed_if (keyGetATime(orig) == keyGetATime(copy), "ATime should be same");
1586         succeed_if (keyGetCTime(orig) == keyGetCTime(copy), "CTime should be same");
1587         succeed_if (keyGetMTime(orig) == keyGetMTime(copy), "MTime should be same");
1588         succeed_if (keyGetRef(orig) == 0, "orig ref counter should be 0");
1589         succeed_if (keyGetRef(copy) == 0, "copy ref counter should be 0");
1590         keyDel(orig); // everything independent from original!
1591
1592         // Check the duplication
1593         succeed_if( strcmp(keyName(copy), "user/foo/bar") == 0, "keyDup: key name copy error");
1594         succeed_if( strcmp(keyOwner(copy), "yl") == 0, "keyDup: key name owner copy error");
1595         succeed_if( strncmp(keyValue(copy), "foobar", 6) == 0, "keyDup: key value copy error");
1596         succeed_if( strcmp(keyComment(copy), "mycomment") == 0, "keyDup: key comment copy error");
1597         succeed_if( keyGetUID(copy) == 123, "keyDup: key UID copy error");
1598         succeed_if( keyGetGID(copy) == 456, "keyDup: key GID copy error");
1599         succeed_if( keyGetMode(copy) == 0644, "keyDup: key mode copy error");
1600         succeed_if( keyGetType(copy) & (KEY_TYPE_BINARY), "keyDup: key type copy error");
1601
1602         keyDel(copy);
1603
1604         orig = keyNew (0);
1605         keySetName (orig, "invalid");
1606
1607         succeed_if ( (copy = keyDup(orig)) != 0, "keyDup failed");
1608         succeed_if ( strcmp(keyName(orig), "") == 0, "orig name should be empty");
1609         succeed_if ( strcmp(keyName(copy), "") == 0, "copy name should be empty");
1610         succeed_if (keyGetNameSize(orig) == 1, "orig name size");
1611         succeed_if (keyGetNameSize(copy) == 1, "orig name size");
1612         succeed_if ( strcmp(keyOwner(orig), "") == 0, "orig name should be empty");
1613         succeed_if ( strcmp(keyOwner(copy), "") == 0, "copy name should be empty");
1614         succeed_if (keyGetOwnerSize(orig) == 1, "orig name size");
1615         succeed_if (keyGetOwnerSize(copy) == 1, "copy name size");
1616         succeed_if (keyGetType(orig) == KEY_TYPE_UNDEFINED, "orig key type");
1617         succeed_if (keyGetType(copy) == KEY_TYPE_UNDEFINED, "copy key type");
1618         succeed_if (keyGetATime(orig) == keyGetATime(copy), "ATime should be same");
1619         succeed_if (keyGetCTime(orig) == keyGetCTime(copy), "CTime should be same");
1620         succeed_if (keyGetMTime(orig) == keyGetMTime(copy), "MTime should be same");
1621         succeed_if (keyGetRef(orig) == 0, "orig ref counter should be 0");
1622         succeed_if (keyGetRef(copy) == 0, "copy ref counter should be 0");
1623
1624         keyDel (orig);
1625         keyDel (copy);
1626 }
1627
1628 void test_keyCopy()
1629 {
1630         Key     *orig, *copy;
1631
1632         printf("Test key copy\n");
1633
1634         // Create test key
1635         orig = keyNew("user:yl/foo/bar",
1636                         KEY_TYPE, KEY_TYPE_BINARY,
1637                         KEY_SIZE, 6,
1638                         KEY_VALUE, "foobar",
1639                         KEY_COMMENT, "mycomment",
1640                         KEY_UID, 123,
1641                         KEY_GID, 456,
1642                         KEY_MODE, 0644,
1643                         KEY_END);
1644
1645
1646
1647         // Copy the key
1648         copy = keyNew(0);
1649         succeed_if( keyCopy(copy, orig) == 1, "keyCopy failed");
1650         succeed_if (keyGetATime(orig) == keyGetATime(copy), "ATime should be same");
1651         succeed_if (keyGetCTime(orig) == keyGetCTime(copy), "CTime should be same");
1652         succeed_if (keyGetMTime(orig) == keyGetMTime(copy), "MTime should be same");
1653         succeed_if (keyGetRef(orig) == 0, "orig ref counter should be 0");
1654         succeed_if (keyGetRef(copy) == 0, "copy ref counter should be 0");
1655         keyDel(orig); // everything independent from original!
1656
1657         // Check the duplication
1658         succeed_if( strcmp(keyName(copy), "user/foo/bar") == 0, "keyCopy: key name copy error");
1659         succeed_if( strcmp(keyOwner(copy), "yl") == 0, "keyCopy: key name owner copy error");
1660         succeed_if( strncmp(keyValue(copy), "foobar", 6) == 0, "keyCopy: key value copy error");
1661         succeed_if( strcmp(keyComment(copy), "mycomment") == 0, "keyCopy: key comment copy error");
1662         succeed_if( keyGetUID(copy) == 123, "keyCopy: key UID copy error");
1663         succeed_if( keyGetGID(copy) == 456, "keyCopy: key GID copy error");
1664         succeed_if( keyGetMode(copy) == 0644, "keyCopy: key mode copy error");
1665         succeed_if( keyGetType(copy) & (KEY_TYPE_BINARY), "keyCopy: key type copy error");
1666
1667         orig = keyNew(0);
1668         succeed_if (keyCopy(copy, 0) == 0, "make the key copy fresh");
1669
1670         succeed_if (compare_key (orig, copy, 0) == 0, "keyCopy did not make the key fresh");
1671         keyDel (orig);
1672
1673         keyDel(copy);
1674
1675         orig = keyNew (0);
1676         keySetName (orig, "invalid");
1677
1678         copy = keyNew(0);
1679         succeed_if( keyCopy(copy, orig) == 1, "keyCopy failed");
1680         succeed_if ( strcmp(keyName(orig), "") == 0, "orig name should be empty");
1681         succeed_if ( strcmp(keyName(copy), "") == 0, "copy name should be empty");
1682         succeed_if (keyGetNameSize(orig) == 1, "orig name size");
1683         succeed_if (keyGetNameSize(copy) == 1, "orig name size");
1684         succeed_if ( strcmp(keyOwner(orig), "") == 0, "orig name should be empty");
1685         succeed_if ( strcmp(keyOwner(copy), "") == 0, "copy name should be empty");
1686         succeed_if (keyGetOwnerSize(orig) == 1, "orig name size");
1687         succeed_if (keyGetOwnerSize(copy) == 1, "copy name size");
1688         succeed_if (keyGetType(orig) == KEY_TYPE_UNDEFINED, "orig key type");
1689         succeed_if (keyGetType(copy) == KEY_TYPE_UNDEFINED, "copy key type");
1690         succeed_if (keyGetATime(orig) == keyGetATime(copy), "ATime should be same");
1691         succeed_if (keyGetCTime(orig) == keyGetCTime(copy), "CTime should be same");
1692         succeed_if (keyGetMTime(orig) == keyGetMTime(copy), "MTime should be same");
1693         succeed_if (keyGetRef(orig) == 0, "orig ref counter should be 0");
1694         succeed_if (keyGetRef(copy) == 0, "copy ref counter should be 0");
1695
1696         keyDel (orig);
1697         keyDel (copy);
1698 }
1699
1700 void test_keyDir (void)
1701 {
1702         int i;
1703         Key * key = keyNew ("user", KEY_END);
1704
1705         printf ("Test directory keys\n");
1706
1707         succeed_if (keyGetMode(key) == 0664, "new key not 0664 by default");
1708         succeed_if (keyIsDir (key) == 0, "new key should not be directory by default");
1709
1710         succeed_if (keySetMode(key, 0644) == 0, "could not set to 0644");
1711         succeed_if (keyIsDir (key) == 0, "0644 should not be directory");
1712         succeed_if (keyGetMode(key) == 0644, "key is not 0644, but was set");
1713
1714         succeed_if (keySetDir (key) == 0, "could not set directory key");
1715         succeed_if (keyIsDir (key) == 1, "should be directory after keySetDir");
1716         succeed_if (keyGetMode(key) == 0755, "key is not 0644, but was set");
1717
1718         for (i = 0; i <= 0777; i++)
1719         {
1720                 succeed_if (keySetMode(key, i) == 0, "could not set to 0000 <= i <= 0777");
1721                 succeed_if (keyGetMode(key) == i, "key is not correct 0000 <= i <= 0777");
1722
1723                 if (/*getuid() == keyGetUID (key) &&*/ (keyGetMode (key) & 0100))
1724                 {
1725                         succeed_if (keyIsDir (key) == 1, "should be directory because of executable and uid match");
1726                 } else if (/*getuid() != keyGetUID (key) && getgid() == keyGetGID (key) &&*/ (keyGetMode (key) & 0010))
1727                 {
1728                         succeed_if (keyIsDir (key) == 1, "should be directory because of executable and gid match");
1729                 } else if (/*getuid() != keyGetUID (key) && getgid() != keyGetGID (key) &&*/ (keyGetMode (key) & 0001))
1730                 {
1731                         succeed_if (keyIsDir (key) == 1, "should be directory because of executable and other match");
1732                 } else {
1733                         succeed_if (keyIsDir (key) == 0, "should not be directory");
1734                 }
1735
1736                 succeed_if (keySetDir (key) == 0, "could not set directory key");
1737                 succeed_if (keyIsDir (key) == 1, "should be directory after keySetDir");
1738         }
1739         keyDel (key);
1740
1741         key = keyNew ("user", KEY_DIR, KEY_END);
1742         succeed_if (keyGetMode(key) == 0775, "new key with KEY_DIR not 0775 by default");
1743         succeed_if (keyIsDir (key) == 1, "new key with KEY_DIR should be directory by default");
1744
1745         succeed_if (keySetMode(key, 0644) == 0, "could not set to 0644");
1746         succeed_if (keyIsDir (key) == 0, "0644 should not be directory");
1747         succeed_if (keyGetMode(key) == 0644, "key is not 0644, but was set");
1748
1749         succeed_if (keySetDir (key) == 0, "could not set directory key");
1750         succeed_if (keyIsDir (key) == 1, "should be directory after keySetDir");
1751         succeed_if (keyGetMode(key) == 0755, "key is not 0644, but was set");
1752         keyDel (key);
1753
1754         key = keyNew ("user/s", KEY_DIR, KEY_MODE, 0444, KEY_END);
1755         succeed_if (keyGetMode(key) == 0444, "0444 set by keyNew");
1756         succeed_if (keyIsDir (key) == 0, "0444 should be directory");
1757         keyDel (key);
1758
1759         key = keyNew ("user/s", KEY_MODE, 0444, KEY_DIR, KEY_END);
1760         succeed_if (keyGetMode(key) == 0555, "0555 set by keyNew");
1761         succeed_if (keyIsDir (key) == 1, "0555 should be directory");
1762         keyDel (key);
1763 }
1764
1765 void test_keyTime()
1766 {
1767         Key * key = keyNew (KEY_END);
1768         time_t now = time(0);
1769         time_t past= now - 60*60*24*356 * 10;
1770         time_t future = now + 60*60*24*356 * 10;
1771         /*
1772         time_t far_future = now + 60L*60L*24L*356L * 100L;
1773         */
1774
1775         printf ("Test key time\n");
1776
1777         succeed_if (keyGetATime(0) == (size_t)-1, "null pointer check");
1778         succeed_if (keyGetMTime(0) == (size_t)-1, "null pointer check");
1779         succeed_if (keyGetCTime(0) == (size_t)-1, "null pointer check");
1780
1781         succeed_if (keySetATime(0,0) == -1, "null pointer check");
1782         succeed_if (keySetMTime(0,0) == -1, "null pointer check");
1783         succeed_if (keySetCTime(0,0) == -1, "null pointer check");
1784
1785         succeed_if (keyGetATime(key) == 0, "new initialized atime not 0");
1786         succeed_if (keyGetMTime(key) == 0, "new initialized mtime not 0");
1787         succeed_if (keyGetCTime(key) == 0, "new initialized ctime not 0");
1788
1789         succeed_if (keySetATime (key, now) == 0, "could not set atime");
1790         succeed_if (keySetMTime (key, now) == 0, "could not set mtime");
1791         succeed_if (keySetCTime (key, now) == 0, "could not set ctime");
1792
1793         succeed_if (keyGetATime(key) == now, "new initialized atime not 0");
1794         succeed_if (keyGetMTime(key) == now, "new initialized mtime not 0");
1795         succeed_if (keyGetCTime(key) == now, "new initialized ctime not 0");
1796
1797
1798         succeed_if (keySetATime (key, past) == 0, "could not set atime");
1799         succeed_if (keySetMTime (key, past) == 0, "could not set mtime");
1800         succeed_if (keySetCTime (key, past) == 0, "could not set ctime");
1801
1802         succeed_if (keyGetATime(key) == past, "new initialized atime not 0");
1803         succeed_if (keyGetMTime(key) == past, "new initialized mtime not 0");
1804         succeed_if (keyGetCTime(key) == past, "new initialized ctime not 0");
1805
1806
1807         succeed_if (keySetATime (key, future) == 0, "could not set atime");
1808         succeed_if (keySetMTime (key, future) == 0, "could not set mtime");
1809         succeed_if (keySetCTime (key, future) == 0, "could not set ctime");
1810
1811         succeed_if (keyGetATime(key) == future, "new initialized atime not 0");
1812         succeed_if (keyGetMTime(key) == future, "new initialized mtime not 0");
1813         succeed_if (keyGetCTime(key) == future, "new initialized ctime not 0");
1814
1815 /*
1816         succeed_if (keySetATime (key, far_future) == 0, "could not set atime");
1817         succeed_if (keySetMTime (key, far_future) == 0, "could not set mtime");
1818         succeed_if (keySetCTime (key, far_future) == 0, "could not set ctime");
1819
1820         succeed_if (keyGetATime(key) == far_future, "new initialized atime not 0");
1821         succeed_if (keyGetMTime(key) == far_future, "new initialized mtime not 0");
1822         succeed_if (keyGetCTime(key) == far_future, "new initialized ctime not 0");
1823
1824         warn_if_fail (keyGetATime(key) > 0, "time_t not 64 bit, 2038 problem");
1825         warn_if_fail (keyGetMTime(key) > 0, "time_t not 64 bit, 2038 problem");
1826         warn_if_fail (keyGetCTime(key) > 0, "time_t not 64 bit, 2038 problem");
1827 */
1828
1829         keyDel (key);
1830 }
1831
1832 void test_keyMeta(void)
1833 {
1834         Key *key=0;
1835
1836         succeed_if (keyStat (key) == -1, "stat null pointer");
1837         succeed_if (keyNeedStat(key) == -1, "could not stat null pointer");
1838         succeed_if(keyGetUID(key) == (uid_t)-1, "uid null pointer");
1839         succeed_if(keyGetGID(key) == (gid_t)-1, "gid null pointer");
1840         succeed_if(keyGetMode(key) == (mode_t)-1, "mode null pointer");
1841
1842
1843         key = keyNew (0);
1844
1845         succeed_if (keyNeedStat(key) == 0, "fresh key does not need stat");
1846         succeed_if (keyStat(key) == 1, "could not stat key");
1847         succeed_if (keyNeedStat(key) == 1, "could not stat key");
1848         keyDel (key);
1849
1850         key = keyNew ("user/stat", KEY_STAT, KEY_END);
1851         succeed_if (keyNeedStat(key) == 1, "fresh key need stat");
1852         succeed_if (keyStat(key) == 1, "could not stat key");
1853         succeed_if (keyNeedStat(key) == 1, "could not stat key");
1854         keyDel (key);
1855
1856         key=0;
1857         succeed_if (keyRemove (key) == -1, "remove null pointer");
1858         succeed_if (keyNeedRemove(key) == -1, "could not remove key");
1859         succeed_if (keyNeedSync(key) == -1, "key needs sync");
1860         key = keyNew (0);
1861         succeed_if (keyNeedRemove(key) == 0, "fresh key does not need remove");
1862         succeed_if (keyNeedSync(key) == 0, "fresh key needs sync");
1863         succeed_if (keyRemove(key) == 1, "could not remove key");
1864         succeed_if (keyNeedRemove(key) == 1, "could not remove key");
1865         succeed_if (keyNeedSync(key) == 1, "need sync after remove");
1866         keyDel (key);
1867
1868         key = keyNew ("user/remove", KEY_REMOVE, KEY_END);
1869         succeed_if (keyNeedRemove(key) == 1, "fresh key need remove");
1870         succeed_if (keyNeedSync(key) == 1, "need sync after remove");
1871         succeed_if (keyRemove(key) == 1, "could not remove key");
1872         succeed_if (keyNeedRemove(key) == 1, "could not remove key");
1873         succeed_if (keyNeedSync(key) == 1, "need sync after remove");
1874         keyDel (key);
1875
1876         succeed_if (keyNeedSync(0) == -1, "keyNeedSync(0)");
1877         succeed_if (keyNeedStat(0) == -1, "keyNeedStat(0)");
1878         succeed_if (keyNeedRemove(0) == -1, "keyNeedRemove(0)");
1879
1880         key = keyNew(0);
1881         succeed_if (keyNeedSync(key) == 0, "keyNew(0) should not need sync");
1882         succeed_if (keySetName(key,"invalid") == -1, "invalid name should fail");
1883         succeed_if (keyNeedSync(key) == 0, "keyNew(0) should not need sync");
1884         keyDel (key);
1885
1886         key = keyNew(0);
1887         succeed_if (keyNeedSync(key) == 0, "should not need sync");
1888         keySetUID(key,20);
1889         succeed_if (keyNeedSync(key) == 1, "should need sync");
1890         keyDel (key);
1891
1892         key = keyNew(0);
1893         succeed_if(keyGetUID(key) == (uid_t)-1, "uid not set to nobody");
1894         succeed_if(keyGetGID(key) == (gid_t)-1, "gid not set to nobody");
1895
1896         succeed_if(keySetUID(key,20) == 0, "could not set uid");
1897         succeed_if(keySetGID(key,21) == 0, "could not set uid");
1898
1899         succeed_if(keyGetUID(key) == 20, "uid not set to 20");
1900         succeed_if(keyGetGID(key) == 21, "gid not set to 21");
1901
1902         succeed_if(keySetUID(key,(uid_t)-1) == 0, "could not set uid");
1903         succeed_if(keySetGID(key,(gid_t)-1) == 0, "could not set uid");
1904
1905         succeed_if(keyGetUID(key) == (uid_t)-1, "uid not set to nobody");
1906         succeed_if(keyGetGID(key) == (gid_t)-1, "gid not set to nobody");
1907
1908         succeed_if(keySetUID(key,0) == 0, "could not set uid");
1909         succeed_if(keySetGID(key,0) == 0, "could not set uid");
1910
1911         succeed_if(keyGetUID(key) == 0, "uid not set to 20");
1912         succeed_if(keyGetGID(key) == 0, "gid not set to 21");
1913         keyDel (key);
1914
1915         key = keyNew(0);
1916         succeed_if(keyGetMode(key) == KEY_DEF_MODE, "new key does not have default mode");
1917         succeed_if(keySetDir(key) == 0, "could not set dir");
1918         succeed_if(keyGetMode(key) == KEY_DEF_MODE | KEY_DEF_DIR, "directory key");
1919         keyDel (key);
1920
1921         key = keyNew("user/dir", KEY_DIR, KEY_END);
1922         succeed_if(keyGetMode(key) == KEY_DEF_MODE | KEY_DEF_DIR, "directory key");
1923         succeed_if(keySetDir(key) == 0, "could not set dir");
1924         succeed_if(keyGetMode(key) == KEY_DEF_MODE | KEY_DEF_DIR, "directory key");
1925         keyDel (key);
1926 }
1927
1928 void test_keyHelpers()
1929 {
1930         char *name="user/abc/defghi/jkl";
1931         char *p;
1932         size_t size=0;
1933         int level=0;
1934         char buffer[20];
1935
1936         Key *key=keyNew("system/parent/base",KEY_END);
1937         char *parentName;
1938         size_t parentSize;
1939         Key *k1, *k2;
1940
1941         printf ("Test key helpers\n");
1942
1943         /* copied out of example from keyNameGetOneLevel
1944          Lets define a key name with a lot of repeating '/' and escaped '/'
1945          char *keyName="user////abc/def\\/ghi////jkl///";*/
1946
1947         p=name;
1948         while (*(p=keyNameGetOneLevel(p+size,&size))) {
1949                 level++;
1950
1951                 strncpy(buffer,p,size);
1952                 buffer[size]=0;
1953
1954                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
1955                 switch (level)
1956                 {
1957                         case 1: succeed_if (strcmp (buffer, "user") == 0, "keyNameGetOneLevel not correct"); break;
1958                         case 2: succeed_if (strcmp (buffer, "abc") == 0, "keyNameGetOneLevel not correct"); break;
1959                         case 3: succeed_if (strcmp (buffer, "defghi") == 0, "keyNameGetOneLevel not correct"); break;
1960                         case 4: succeed_if (strcmp (buffer, "jkl") == 0, "keyNameGetOneLevel not correct"); break;
1961                         default: succeed_if (0, "should not reach case statement");
1962                 }
1963         }
1964
1965         /* with escaped sequence:*/
1966         name="user////abc/def\\/ghi////jkl///";
1967         size=0;
1968         level=0;
1969
1970         p=name;
1971         while (*(p=keyNameGetOneLevel(p+size,&size))) {
1972                 level++;
1973
1974                 strncpy(buffer,p,size);
1975                 buffer[size]=0;
1976
1977                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
1978                 switch (level)
1979                 {
1980                         case 1: succeed_if (strcmp (buffer, "user") == 0, "keyNameGetOneLevel not correct");
1981                                 succeed_if (size == 4, "wrong size returned"); break;
1982                         case 2: succeed_if (strcmp (buffer, "abc") == 0, "keyNameGetOneLevel not correct");
1983                                 succeed_if (size == 3, "wrong size returned"); break;
1984                         case 3: succeed_if (strcmp (buffer, "def\\/ghi") == 0, "keyNameGetOneLevel not correct");
1985                                 succeed_if (size == 8, "wrong size returned"); break;
1986                         case 4: succeed_if (strcmp (buffer, "jkl") == 0, "keyNameGetOneLevel not correct");
1987                                 succeed_if (size == 3, "wrong size returned"); break;
1988                         default: succeed_if (0, "should not reach case statement");
1989                 }
1990         }
1991
1992         /* with escaped sequence at the end:*/
1993         name="user////abc/def\\/ghi////jkl\\/\\/";
1994         size=0;
1995         level=0;
1996
1997         p=name;
1998         while (*(p=keyNameGetOneLevel(p+size,&size))) {
1999                 level++;
2000
2001                 strncpy(buffer,p,size);
2002                 buffer[size]=0;
2003
2004                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
2005                 switch (level)
2006                 {
2007                         case 1: succeed_if (strcmp (buffer, "user") == 0, "keyNameGetOneLevel not correct");
2008                                 succeed_if (size == 4, "wrong size returned"); break;
2009                         case 2: succeed_if (strcmp (buffer, "abc") == 0, "keyNameGetOneLevel not correct");
2010                                 succeed_if (size == 3, "wrong size returned"); break;
2011                         case 3: succeed_if (strcmp (buffer, "def\\/ghi") == 0, "keyNameGetOneLevel not correct");
2012                                 succeed_if (size == 8, "wrong size returned"); break;
2013                         case 4: succeed_if (strcmp (buffer, "jkl\\/\\/") == 0, "keyNameGetOneLevel not correct");
2014                                 succeed_if (size == 7, "wrong size returned"); break;
2015                         default: succeed_if (0, "should not reach case statement");
2016                 }
2017         }
2018
2019
2020         parentSize=keyGetParentNameSize(key);
2021         parentName=malloc(parentSize);
2022         keyGetParentName(key,parentName,parentSize);
2023         succeed_if (strcmp (parentName, "system/parent") == 0, "parentName error");
2024         free (parentName);
2025         keyDel (key);
2026
2027         succeed_if (keyAddBaseName (0, "s") == -1, "null pointer saftey");
2028
2029         k1 = keyNew ("user/dir1/dir2", KEY_END);
2030         succeed_if (keyAddBaseName (k1, 0) == 15, "Could not add nothing to basename");
2031         succeed_if (strcmp (keyName(k1), "user/dir1/dir2") == 0, "added basename not correct");
2032         succeed_if (keyAddBaseName (k1, "") == 15, "Could not add nothing to basename");
2033         succeed_if (strcmp (keyName(k1), "user/dir1/dir2") == 0, "added basename not correct");
2034         succeed_if (keyAddBaseName (k1, "mykey") == 21, "Could not add basename");
2035         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey") == 0, "added basename not correct");
2036         succeed_if (keyGetNameSize(k1) == 21, "Name size not correct");
2037         succeed_if (keyAddBaseName (k1, "mykey") == 27, "Could not add basename");
2038         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey/mykey") == 0, "added basename not correct");
2039         succeed_if (keyGetNameSize(k1) == 27, "Name size not correct");
2040         succeed_if (keyAddBaseName (k1, "a") == 29, "Could not add basename");
2041         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey/mykey/a") == 0, "added basename not correct");
2042         succeed_if (keyGetNameSize(k1) == 29, "Name size not correct");
2043         keyDel (k1);
2044
2045         k1 = keyNew ("user/dir1/dir2", KEY_END);
2046         succeed_if (keyAddBaseName (k1, "mykey/mykey/a") == 29, "Could not add basename");
2047         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey/mykey/a") == 0, "added basename not correct");
2048         succeed_if (keyGetNameSize(k1) == 29, "Name size not correct");
2049         keyDel (k1);
2050
2051         k1 = keyNew ("user/////dir1//////dir2", KEY_END);
2052         succeed_if (keyAddBaseName (k1, "mykey/////mykey////a") == 29, "Could not add basename");
2053         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey/mykey/a") == 0, "added basename not correct");
2054         succeed_if (keyGetNameSize(k1) == 29, "Name size not correct");
2055         keyDel (k1);
2056
2057         k1 = keyNew ("user/dir1/////dir2////", KEY_END);
2058         succeed_if (keyAddBaseName (k1, "////mykey////mykey/a") == 29, "Could not add basename");
2059         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey/mykey/a") == 0, "added basename not correct");
2060         succeed_if (keyGetNameSize(k1) == 29, "Name size not correct");
2061         keyDel (k1);
2062
2063         k1 = keyNew ("user/dir1/dir2", KEY_END);
2064         succeed_if (keyAddBaseName (k1, "mykey/mykey////a///") == 29, "Could not add basename");
2065         succeed_if (strcmp (keyName(k1), "user/dir1/dir2/mykey/mykey/a") == 0, "added basename not correct");
2066         succeed_if (keyGetNameSize(k1) == 29, "Name size not correct");
2067         keyDel (k1);
2068
2069         k2 = keyNew (KEY_END);
2070         succeed_if (keyAddBaseName (k2, "no") == -1, "Could not add basename");
2071         succeed_if (strcmp (keyName(k2), "") == 0, "added basename not correct");
2072         succeed_if (keyGetNameSize(k2) == 1, "Name size not correct");
2073         keyDel (k2);
2074
2075         k2 = keyNew (KEY_END);
2076         succeed_if (keyAddBaseName (k2, "user") == 5, "Could not add basename");
2077         succeed_if (strcmp (keyName(k2), "user") == 0, "added basename not correct");
2078         succeed_if (keyGetNameSize(k2) == 5, "Name size not correct");
2079         keyDel (k2);
2080
2081         k2 = keyNew ("user/dir1/dir2/mykey/mykey/a", KEY_END);
2082         succeed_if (keySetBaseName (k2, "mykey") == 33, "Could not add basename");
2083         succeed_if (strcmp (keyName(k2), "user/dir1/dir2/mykey/mykey/mykey") == 0, "added basename not correct");
2084         succeed_if (keyGetNameSize(k2) == 33, "Name size not correct");
2085         succeed_if (keySetBaseName (k2, "einva") == 33, "Could not add basename");
2086         succeed_if (strcmp (keyName(k2), "user/dir1/dir2/mykey/mykey/einva") == 0, "added basename not correct");
2087         succeed_if (keyGetNameSize(k2) == 33, "Name size not correct");
2088         succeed_if (keySetBaseName (k2, "chang") == 33, "Could not add basename");
2089         succeed_if (strcmp (keyName(k2), "user/dir1/dir2/mykey/mykey/chang") == 0, "added basename not correct");
2090         succeed_if (keySetBaseName (k2, "change") == 34, "Could not add basename");
2091         succeed_if (keyGetNameSize(k2) == 34, "Name size not correct");
2092         succeed_if (strcmp (keyName(k2), "user/dir1/dir2/mykey/mykey/change") == 0, "added basename not correct");
2093         keyDel (k2);
2094
2095         k2 = keyNew ("user/dir1/a", KEY_END);
2096         succeed_if (keySetBaseName (k2, "") == 10, "Could not add basename");
2097         succeed_if (strcmp (keyName(k2), "user/dir1") == 0, "added basename not correct");
2098         succeed_if (keyGetNameSize(k2) == 10, "Name size not correct");
2099         keyDel (k2);
2100
2101         k2 = keyNew ("user/dir1/a", KEY_END);
2102         succeed_if (keySetBaseName (k2, "some/more") == 20, "Could not add basename");
2103         succeed_if (strcmp (keyName(k2), "user/dir1/some/more") == 0, "added basename not correct");
2104         succeed_if (keyGetNameSize(k2) == 20, "Name size not correct");
2105         keyDel (k2);
2106
2107         k2 = keyNew ("user/dir1/a", KEY_END);
2108         succeed_if (keySetBaseName (k2, "some////more") == 20, "Could not add basename");
2109         succeed_if (strcmp (keyName(k2), "user/dir1/some/more") == 0, "added basename not correct");
2110         succeed_if (keyGetNameSize(k2) == 20, "Name size not correct");
2111         keyDel (k2);
2112
2113         k2 = keyNew ("user/dir1/a", KEY_END);
2114         succeed_if (keySetBaseName (k2, "some////more///") == 20, "Could not add basename");
2115         succeed_if (strcmp (keyName(k2), "user/dir1/some/more") == 0, "added basename not correct");
2116         succeed_if (keyGetNameSize(k2) == 20, "Name size not correct");
2117         keyDel (k2);
2118
2119         k2 = keyNew ("user/dir1/a", KEY_END);
2120         succeed_if (keySetBaseName (k2, "///some////more") == 20, "Could not add basename");
2121         succeed_if (strcmp (keyName(k2), "user/dir1/some/more") == 0, "added basename not correct");
2122         succeed_if (keyGetNameSize(k2) == 20, "Name size not correct");
2123         keyDel (k2);
2124
2125         k2 = keyNew ("user", KEY_END);
2126         succeed_if (keySetBaseName (k2, "user") == 5, "Could not add basename");
2127         succeed_if (strcmp (keyName(k2), "user") == 0, "added basename not correct");
2128         succeed_if (keyGetNameSize(k2) == 5, "Name size not correct");
2129         keyDel (k2);
2130
2131         k2 = keyNew ("system", KEY_END);
2132         succeed_if (keySetBaseName (k2, "user") == 5, "Could not add basename");
2133         succeed_if (strcmp (keyName(k2), "user") == 0, "added basename not correct");
2134         succeed_if (keyGetNameSize(k2) == 5, "Name size not correct");
2135         keyDel (k2);
2136
2137         k2 = keyNew ("user", KEY_END);
2138         succeed_if (keySetBaseName (k2, "system") == 7, "Could not add basename");
2139         succeed_if (strcmp (keyName(k2), "system") == 0, "added basename not correct");
2140         succeed_if (keyGetNameSize(k2) == 7, "Name size not correct");
2141         keyDel (k2);
2142
2143         k2 = keyNew ("system", KEY_END);
2144         succeed_if (keySetBaseName (k2, "system") == 7, "Could not add basename");
2145         succeed_if (strcmp (keyName(k2), "system") == 0, "added basename not correct");
2146         succeed_if (keyGetNameSize(k2) == 7, "Name size not correct");
2147         keyDel (k2);
2148
2149         k2 = keyNew ("user", KEY_END);
2150         succeed_if (keySetBaseName (k2, "no") == -1, "Could not add basename");
2151         succeed_if (strcmp (keyName(k2), "") == 0, "added basename not correct");
2152         succeed_if (keyGetNameSize(k2) == 1, "Name size not correct");
2153         keyDel (k2);
2154
2155         k2 = keyNew ("system", KEY_END);
2156         succeed_if (keySetBaseName (k2, "no") == -1, "Could not add basename");
2157         succeed_if (strcmp (keyName(k2), "") == 0, "added basename not correct");
2158         succeed_if (keyGetNameSize(k2) == 1, "Name size not correct");
2159         keyDel (k2);
2160 }
2161
2162
2163 void test_keyNamespace()
2164 {
2165         Key *key;
2166
2167         printf ("Test namespaces\n");
2168
2169         key = keyNew (KEY_END);
2170         succeed_if (keyNameGetNamespace (keyName(key)) == 0, "empty namespace not 0");
2171         succeed_if (keyGetNamespace (key) == 0, "empty namespace not 0");
2172         succeed_if (keyNameIsSystem (keyName(key)) == 0, "empty name is not system");
2173         succeed_if (keyIsSystem (key) == 0, "empty key is not system");
2174         succeed_if (keyNameIsUser (keyName(key)) == 0, "empty name is not user");
2175         succeed_if (keyIsUser (key) == 0, "empty key is not user");
2176         keyDel (key);
2177
2178         key = keyNew ("user", KEY_END);
2179         succeed_if (keyNameGetNamespace (keyName(key)) == KEY_NS_USER, "user namespace not KEY_NS_USER");
2180         succeed_if (keyGetNamespace (key) == KEY_NS_USER, "user namespace not KEY_NS_USER");
2181         succeed_if (keyNameIsSystem (keyName(key)) == 0, "user name is not system");
2182         succeed_if (keyIsSystem (key) == 0, "user key is not system");
2183         succeed_if (keyNameIsUser (keyName(key)) == 1, "user name is not user");
2184         succeed_if (keyIsUser (key) == 1, "user key is not user");
2185         keyDel (key);
2186
2187         key = keyNew ("user/key", KEY_END);
2188         succeed_if (keyNameGetNamespace (keyName(key)) == KEY_NS_USER, "user namespace not KEY_NS_USER");
2189         succeed_if (keyGetNamespace (key) == KEY_NS_USER, "user namespace not KEY_NS_USER");
2190         succeed_if (keyNameIsSystem (keyName(key)) == 0, "user name is not system");
2191         succeed_if (keyIsSystem (key) == 0, "user key is not system");
2192         succeed_if (keyNameIsUser (keyName(key)) == 1, "user name is not user");
2193         succeed_if (keyIsUser (key) == 1, "user key is not user");
2194         keyDel (key);
2195
2196         key = keyNew ("user:owner/key", KEY_END);
2197         succeed_if (keyNameGetNamespace (keyName(key)) == KEY_NS_USER, "user namespace not KEY_NS_USER");
2198         succeed_if (keyGetNamespace (key) == KEY_NS_USER, "user namespace not KEY_NS_USER");
2199         succeed_if (keyNameIsSystem (keyName(key)) == 0, "user name is not system");
2200         succeed_if (keyIsSystem (key) == 0, "user key is not system");
2201         succeed_if (keyNameIsUser (keyName(key)) == 1, "user name is not user");
2202         succeed_if (keyIsUser (key) == 1, "user key is not user");
2203         keyDel (key);
2204
2205         key = keyNew ("system", KEY_END);
2206         succeed_if (keyNameGetNamespace (keyName(key)) == KEY_NS_SYSTEM, "system namespace not KEY_NS_SYSTEM");
2207         succeed_if (keyGetNamespace (key) == KEY_NS_SYSTEM, "system namespace not KEY_NS_SYSTEM");
2208         succeed_if (keyNameIsSystem (keyName(key)) == 1, "system name is not system");
2209         succeed_if (keyIsSystem (key) == 1, "system key is not system");
2210         succeed_if (keyNameIsUser (keyName(key)) == 0, "system name is not system");
2211         succeed_if (keyIsUser (key) == 0, "system key is not system");
2212         keyDel (key);
2213
2214         key = keyNew ("system/key", KEY_END);
2215         succeed_if (keyNameGetNamespace (keyName(key)) == KEY_NS_SYSTEM, "system namespace not KEY_NS_SYSTEM");
2216         succeed_if (keyGetNamespace (key) == KEY_NS_SYSTEM, "system namespace not KEY_NS_SYSTEM");
2217         succeed_if (keyNameIsSystem (keyName(key)) == 1, "system name is not system");
2218         succeed_if (keyIsSystem (key) == 1, "system key is not system");
2219         succeed_if (keyNameIsUser (keyName(key)) == 0, "system name is not system");
2220         succeed_if (keyIsUser (key) == 0, "system key is not system");
2221         keyDel (key);
2222 }
2223
2224
2225 int main()
2226 {
2227         printf("KEY  STRUCT  TESTS\n");
2228         printf("==================\n\n");
2229
2230         init ();
2231         test_keyComparing();
2232         test_keyNewSystem();
2233         test_keyNewUser();
2234         test_keyReference();
2235         test_keyType();
2236         test_keyName();
2237         test_keyValue();
2238         test_keyBinary();
2239         test_keyComment();
2240         test_keyOwner();
2241         test_keyInactive();
2242         test_keyBelow();
2243         test_keyDup();
2244         test_keyCopy();
2245         test_keyDir();
2246         test_keyTime();
2247         test_keyMeta();
2248         test_keyHelpers();
2249         test_keyNamespace();
2250
2251         printf("\ntest_key RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
2252
2253         return nbError;
2254 }