LCOV - code coverage report
Current view: top level - tests/abi - testabi_key.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 1877 1879 99.9 %
Date: 2019-09-12 12:28:41 Functions: 26 27 96.3 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <tests.h>
      10             : 
      11             : #define NUMBER_OF_NAMESPACES 6
      12             : 
      13             : char * namespaces[] = { "/", "spec", "proc", "dir", "user", "system", 0 };
      14             : 
      15             : struct test
      16             : {
      17             :         char * testName;
      18             :         char * keyName;
      19             : 
      20             :         char * expectedKeyName;
      21             :         char * expectedBaseName;
      22             :         char * expectedFRootName;
      23             : };
      24             : 
      25             : struct test tstKeyName[] = {
      26             :         { "Normal key", "system/foo/bar", "system/foo/bar", "bar", "system" },
      27             : 
      28             :         {
      29             :                 "Key containing redundant & trailing separator", "system//foo//bar//", "system/foo/bar", /* keyName   */
      30             :                 "bar",                                                                                         /* keyBaseName */
      31             :                 "system",                                                                              /* keyGetFullRootName  */
      32             :         },
      33             : 
      34             :         {
      35             :                 "Normal user key", "user/key", "user/key", /* keyName     */
      36             :                 "key",                                           /* keyBaseName       */
      37             :                 "user",                                          /* keyGetFullRootName        */
      38             :         },
      39             : 
      40             :         {
      41             :                 "Normal user key with owner", "user:owner/key", "user/key", /* keyName    */
      42             :                 "key",                                                            /* keyBaseName      */
      43             :                 "user:owner",                                             /* keyGetFullRootName       */
      44             :         },
      45             : 
      46             :         {
      47             :                 "Depth user key with owner", "user:owner/folder/long/base/dir/key", "user/folder/long/base/dir/key", /* keyName   */
      48             :                 "key",                                                                                                     /* keyBaseName     */
      49             :                 "user:owner", /* keyGetFullRootName   */
      50             :         },
      51             : 
      52             : #ifdef COMPAT
      53             :         {
      54             :                 "Key containing escaped separator", "user:yl///foo\\///bar\\/foo_bar\\", "user/foo\\//bar\\/foo_bar\\", /* keyName        */
      55             :                 "bar/foo_bar\\",                                                                                      /* keyBaseName  */
      56             :                 "user:yl", /* keyGetFullRootName      */
      57             :         },
      58             : #endif
      59             : 
      60             :         {
      61             :                 "Key containing escaped separator at the end", "user:yl///foo\\///bar\\/foo_bar\\/",
      62             :                 "user/foo\\//bar\\/foo_bar\\/", /* keyName    */
      63             :                 "bar/foo_bar/",                       /* keyBaseName  */
      64             :                 "user:yl",                    /* keyGetFullRootName   */
      65             :         },
      66             : 
      67             :         {
      68             :                 "Key with empty part", "user///%", "user/%", /* keyName   */
      69             :                 "",                                        /* keyBaseName     */
      70             :                 "",                                        /* keyGetFullRootName      */
      71             : 
      72             :         },
      73             : 
      74             :         {
      75             :                 "Key with escaped %", "user///\\%", "user/\\%", /* keyName        */
      76             :                 "%",                                          /* keyBaseName  */
      77             :                 "",                                           /* keyGetFullRootName   */
      78             : 
      79             :         },
      80             : 
      81             :         {
      82             :                 "Key with multi escaped %", "user///\\\\%", "user/\\\\%", /* keyName      */
      83             :                 "\\%",                                                          /* keyBaseName        */
      84             :                 "",                                                     /* keyGetFullRootName         */
      85             : 
      86             :         },
      87             : 
      88             :         {
      89             :                 NULL, NULL, NULL, /* keyName    */
      90             :                 NULL,             /* keyBaseName        */
      91             :                 NULL,             /* keyGetFullRootName         */
      92             :         }
      93             : };
      94             : 
      95           2 : static void test_keyNewSpecial (void)
      96             : {
      97           2 :         printf ("Test special key creation\n");
      98             : 
      99           2 :         Key * k = keyNew (0);
     100           2 :         succeed_if_same_string (keyName (k), "");
     101           2 :         keyDel (k);
     102             : 
     103           2 :         k = keyNew (0, KEY_END); //  might break, useless arguments?
     104           2 :         succeed_if_same_string (keyName (k), "");
     105           2 :         keyDel (k);
     106             : 
     107           2 :         k = keyNew ("", KEY_END);
     108           2 :         succeed_if_same_string (keyName (k), "");
     109           2 :         keyDel (k);
     110             : 
     111           2 :         k = keyNew ("invalid", KEY_END);
     112           2 :         succeed_if_same_string (keyName (k), "");
     113           2 :         keyDel (k);
     114             : 
     115             : 
     116           2 :         k = keyNew ("other invalid", KEY_END);
     117           2 :         succeed_if_same_string (keyName (k), "");
     118           2 :         keyDel (k);
     119             : 
     120           2 :         k = keyNew ("system spaces", KEY_END);
     121           2 :         succeed_if_same_string (keyName (k), "");
     122           2 :         keyDel (k);
     123             : 
     124           2 :         k = keyNew ("system/bin", KEY_BINARY, KEY_VALUE, "a 2d\0b", KEY_END);
     125           2 :         succeed_if_same_string (keyValue (k), "a 2d");
     126           2 :         succeed_if (keyGetValueSize (k) == sizeof ("a 2d"), "no KEY_SIZE given, so bin is truncated");
     127           2 :         succeed_if (keyIsBinary (k), "not a binary key");
     128           2 :         keyDel (k);
     129           2 : }
     130             : 
     131           2 : static void test_keyNewSystem (void)
     132             : {
     133             :         Key * key;
     134           2 :         char array[] = "here is some data stored";
     135             :         Key * k1;
     136             :         Key * k2;
     137             :         Key * k3;
     138             :         char * getBack;
     139             : 
     140           2 :         printf ("Test system key creation\n");
     141             : 
     142             :         // Empty key
     143           2 :         key = keyNew (0);
     144           2 :         succeed_if (key != NULL, "keyNew: Unable to create a new empty key");
     145           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete empty key");
     146             : 
     147             :         // Key with name
     148           2 :         key = keyNew ("system/sw/test", KEY_END);
     149           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name");
     150           2 :         succeed_if_same_string (keyName (key), "system/sw/test");
     151           2 :         keyCopy (key, 0);
     152           2 :         succeed_if_same_string (keyName (key), "");
     153           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
     154             : 
     155             :         // Key with name
     156           2 :         key = keyNew ("system/sw/test", KEY_END);
     157           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name");
     158           2 :         succeed_if_same_string (keyName (key), "system/sw/test");
     159           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
     160             : 
     161             :         // Key with name + value
     162           2 :         key = keyNew ("system/sw/test", KEY_VALUE, "test", KEY_END);
     163           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name + value of default type");
     164           2 :         succeed_if_same_string (keyValue (key), "test");
     165           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + value");
     166           2 :         key = keyNew ("system/valid/there", KEY_BINARY, KEY_SIZE, sizeof (array), KEY_VALUE, array, KEY_END);
     167           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name + value of default type");
     168           2 :         succeed_if (keyIsBinary (key), "Could not set type to binary");
     169           2 :         succeed_if (keyGetValueSize (key) == sizeof (array), "Value size not correct");
     170           2 :         succeed_if (memcmp ((char *) keyValue (key), array, sizeof (array)) == 0, "could not get correct binary value");
     171           2 :         getBack = elektraMalloc (keyGetValueSize (key));
     172           2 :         keyGetBinary (key, getBack, keyGetValueSize (key));
     173           2 :         succeed_if (memcmp (getBack, array, sizeof (array)) == 0, "could not get correct value with keyGetBinary");
     174           2 :         elektraFree (getBack);
     175           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
     176             : 
     177           2 :         key = keyNew ("system", KEY_END);
     178           2 :         succeed_if_same_string (keyName (key), "system");
     179           2 :         succeed_if (keyGetNameSize (key) == 7, "empty name size");
     180           2 :         succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner not null");
     181           2 :         keyDel (key);
     182             : 
     183           2 :         key = keyNew ("user/abc", KEY_OWNER, "huhu", KEY_END);
     184           2 :         succeed_if_same_string (keyName (key), "user/abc");
     185           2 :         succeed_if (keyGetNameSize (key) == 9, "empty name size");
     186           2 :         succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "huhu");
     187           2 :         keyDel (key);
     188             : 
     189           2 :         key = keyNew ("user:lost/abc", KEY_OWNER, "huhu", KEY_END);
     190           2 :         succeed_if_same_string (keyName (key), "user/abc");
     191           2 :         succeed_if (keyGetNameSize (key) == 9, "empty name size");
     192           2 :         succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "huhu");
     193           2 :         keyDel (key);
     194             : 
     195           2 :         key = keyNew ("user:huhu/abc", KEY_END);
     196           2 :         succeed_if_same_string (keyName (key), "user/abc");
     197           2 :         succeed_if (keyGetNameSize (key) == 9, "empty name size");
     198           2 :         succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "huhu");
     199           2 :         keyDel (key);
     200             : 
     201             :         // testing multiple values at once
     202           2 :         k1 = keyNew ("system/1", KEY_VALUE, "singlevalue", KEY_END);
     203           2 :         k2 = keyNew ("system/2", KEY_VALUE, "myvalue", KEY_END);
     204           2 :         k3 = keyNew ("system/3", KEY_VALUE, "syskey", KEY_END);
     205           2 :         succeed_if (k1 != NULL, "keyNew: Unable to create a key with name + value of default type");
     206           2 :         succeed_if (keyIsString (k1), "keyNew: Default key value isn't set to string");
     207           2 :         succeed_if_same_string (keyValue (k1), "singlevalue");
     208             : 
     209           2 :         succeed_if (k2 != NULL, "keyNew: Unable to create a key with name + value of default type");
     210           2 :         succeed_if (keyIsString (k2), "keyNew: Default key value isn't set to string");
     211           2 :         succeed_if_same_string (keyValue (k2), "myvalue");
     212             : 
     213           2 :         succeed_if (k3 != NULL, "keyNew: Unable to create a key with name + value of default type");
     214           2 :         succeed_if (keyIsString (k3), "keyNew: Default key value isn't set to string");
     215           2 :         succeed_if_same_string (keyValue (k3), "syskey");
     216             : 
     217           2 :         succeed_if (keyDel (k1) == 0, "keyDel: Unable to delete key with name + value");
     218           2 :         succeed_if (keyDel (k2) == 0, "keyDel: Unable to delete key with name + value");
     219           2 :         succeed_if (keyDel (k3) == 0, "keyDel: Unable to delete key with name + value");
     220           2 : }
     221             : 
     222           2 : static void test_keyNewUser (void)
     223             : {
     224             :         Key * k1;
     225             :         Key * k2;
     226             :         Key * k3;
     227             : 
     228           2 :         printf ("Test user key creation\n");
     229             :         // testing multiple values at once
     230           2 :         k1 = keyNew ("user/1", KEY_VALUE, "singlevalue", KEY_END);
     231           2 :         k2 = keyNew ("user/2", KEY_VALUE, "myvalue", KEY_END);
     232           2 :         k3 = keyNew ("user/3", KEY_VALUE, "syskey", KEY_END);
     233           2 :         succeed_if (k1 != NULL, "keyNew: Unable to create a key with name + value of default type");
     234           2 :         succeed_if (keyIsString (k1), "keyNew: Default key value isn't set to string");
     235           2 :         succeed_if_same_string (keyValue (k1), "singlevalue");
     236             : 
     237           2 :         succeed_if (k2 != NULL, "keyNew: Unable to create a key with name + value of default type");
     238           2 :         succeed_if (keyIsString (k2), "keyNew: Default key value isn't set to string");
     239           2 :         succeed_if_same_string (keyValue (k2), "myvalue");
     240             : 
     241           2 :         succeed_if (k3 != NULL, "keyNew: Unable to create a key with name + value of default type");
     242           2 :         succeed_if (keyIsString (k3), "keyNew: Default key value isn't set to string");
     243           2 :         succeed_if_same_string (keyValue (k3), "syskey");
     244             : 
     245           2 :         succeed_if (keyDel (k1) == 0, "keyDel: Unable to delete key with name + value");
     246           2 :         succeed_if (keyDel (k2) == 0, "keyDel: Unable to delete key with name + value");
     247           2 :         succeed_if (keyDel (k3) == 0, "keyDel: Unable to delete key with name + value");
     248             : 
     249           2 :         k1 = keyNew ("invalid", KEY_END);
     250           2 :         succeed_if (k1 != 0, "should construct key even on invalid names");
     251           2 :         succeed_if_same_string (keyName (k1), "");
     252           2 :         succeed_if (keyGetNameSize (k1) == 1, "namesize");
     253           2 :         keyDel (k1);
     254           2 : }
     255             : 
     256           2 : static void test_keyReference (void)
     257             : {
     258           2 :         printf ("Test key reference\n");
     259             : 
     260           2 :         Key * key = keyNew ("user/key", KEY_END);
     261           2 :         Key * c = keyNew ("user/c", KEY_END);
     262             :         Key * d;
     263             :         KeySet *ks1, *ks2;
     264           2 :         succeed_if (keyGetRef (key) == 0, "New created key reference");
     265             : 
     266           2 :         succeed_if (keyIncRef (key) == 1, "keyIncRef return value");
     267           2 :         succeed_if (keyGetRef (key) == 1, "After keyIncRef key reference");
     268           2 :         succeed_if (keyIncRef (key) == 2, "keyIncRef return value");
     269           2 :         succeed_if (keyGetRef (key) == 2, "After keyIncRef key reference");
     270           2 :         succeed_if (keyIncRef (key) == 3, "keyIncRef return value");
     271           2 :         succeed_if (keyGetRef (key) == 3, "After keyIncRef key reference");
     272           2 :         succeed_if (keyIncRef (key) == 4, "keyIncRef return value");
     273           2 :         succeed_if (keyGetRef (key) == 4, "After keyIncRef key reference");
     274             : 
     275           2 :         d = keyDup (key);
     276           2 :         succeed_if (keyGetRef (d) == 0, "After keyDup key reference");
     277           2 :         succeed_if (keyIncRef (d) == 1, "keyIncRef return value");
     278           2 :         succeed_if (keyGetRef (key) == 4, "Reference should not change");
     279           2 :         succeed_if (keyDecRef (d) == 0, "decrement key");
     280           2 :         succeed_if (keyDel (d) == 0, "last keyDel d, key exist");
     281             : 
     282           2 :         keyCopy (c, key);
     283           2 :         succeed_if (keyGetRef (c) == 0, "After keyCopy key reference");
     284           2 :         succeed_if (keyIncRef (c) == 1, "keyIncRef return value");
     285           2 :         succeed_if (keyGetRef (key) == 4, "Reference should not change");
     286             : 
     287           2 :         keyCopy (c, key);
     288           2 :         succeed_if (keyGetRef (c) == 1, "After keyCopy key reference");
     289           2 :         succeed_if (keyDecRef (c) == 0, "keyDecRef return value");
     290           2 :         succeed_if (keyGetRef (key) == 4, "Reference should not change");
     291             : 
     292           2 :         succeed_if (keyIncRef (c) == 1, "keyIncRef return value");
     293           2 :         succeed_if (keyIncRef (c) == 2, "keyIncRef return value");
     294           2 :         keyCopy (c, key);
     295           2 :         succeed_if (keyGetRef (c) == 2, "After keyCopy key reference");
     296           2 :         succeed_if (keyDecRef (c) == 1, "keyDecRef return value");
     297           2 :         succeed_if (keyDecRef (c) == 0, "keyDecRef return value");
     298           2 :         succeed_if (keyDel (c) == 0, "could not delete copy");
     299             : 
     300           2 :         succeed_if (keyGetRef (key) == 4, "After keyIncRef key reference");
     301           2 :         succeed_if (keyDecRef (key) == 3, "keyDel return value");
     302           2 :         succeed_if (keyDel (key) == 3, "should not do anything");
     303           2 :         succeed_if (keyGetRef (key) == 3, "After keyIncRef key reference");
     304           2 :         succeed_if (keyDecRef (key) == 2, "keyDel return value");
     305           2 :         succeed_if (keyDel (key) == 2, "should not do anything");
     306           2 :         succeed_if (keyGetRef (key) == 2, "After keyIncRef key reference");
     307           2 :         succeed_if (keyDecRef (key) == 1, "keyDel return value");
     308           2 :         succeed_if (keyDel (key) == 1, "should not do anything");
     309           2 :         succeed_if (keyGetRef (key) == 1, "Should have no more reference");
     310           2 :         succeed_if (keyDecRef (key) == 0, "last keyDel key, key exist");
     311           2 :         succeed_if (keyDel (key) == 0, "last keyDel key, key exist");
     312             : 
     313             :         /* From examples in ksNew () */
     314           2 :         key = keyNew (0); // ref counter 0
     315           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
     316           2 :         keyIncRef (key); // ref counter of key 1
     317           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     318           2 :         keyDel (key); // has no effect
     319           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     320           2 :         keyDecRef (key); // ref counter back to 0
     321           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
     322           2 :         keyDel (key); // key is now deleted
     323             : 
     324           2 :         ks1 = ksNew (0, KS_END);
     325           2 :         ks2 = ksNew (0, KS_END);
     326           2 :         key = keyNew ("user/key", KEY_END); // ref counter 0
     327           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
     328           2 :         ksAppendKey (ks1, key); // ref counter of key 1
     329           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     330           2 :         ksAppendKey (ks2, key); // ref counter of key 2
     331           2 :         succeed_if (keyGetRef (key) == 2, "reference counter");
     332           2 :         ksDel (ks1); // ref counter of key 1
     333           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     334           2 :         ksDel (ks2); // key is now deleted
     335             : 
     336           2 :         key = keyNew (0); // ref counter 0
     337           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
     338           2 :         keyIncRef (key); // ref counter of key 1
     339           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     340           2 :         keyDel (key); // has no effect
     341           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     342           2 :         keyIncRef (key); // ref counter of key 2
     343           2 :         succeed_if (keyGetRef (key) == 2, "reference counter");
     344           2 :         keyDel (key); // has no effect
     345           2 :         succeed_if (keyGetRef (key) == 2, "reference counter");
     346           2 :         keyDecRef (key); // ref counter of key 1
     347           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     348           2 :         keyDel (key); // has no effect
     349           2 :         succeed_if (keyGetRef (key) == 1, "reference counter");
     350           2 :         keyDecRef (key); // ref counter is now 0
     351           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
     352           2 :         keyDel (key); // key is now deleted
     353             : 
     354           2 :         Key * k = keyNew ("system/proper_name", KEY_END); // ref counter = 0
     355           2 :         succeed_if (keyGetRef (k) == 0, "ref should be zero");
     356           2 :         KeySet * ks = ksNew (1, k, KS_END);
     357           2 :         succeed_if (keyGetRef (k) == 1, "ref should be one");
     358           2 :         succeed_if (keyDel (k) == 1, "key will not be deleted, because its in the keyset");
     359           2 :         succeed_if (keyGetRef (k) == 1, "ref should be one");
     360           2 :         succeed_if (ksDel (ks) == 0, "could not del"); // now the key will be deleted
     361             : 
     362             :         return;
     363             : 
     364             :         /* This code needs very long to execute, especially on 64bit
     365             :          * systems. */
     366             : 
     367             :         key = keyNew (0); // ref counter 0
     368             :         while (keyGetRef (key) < SSIZE_MAX)
     369             :                 keyIncRef (key);
     370             :         succeed_if (keyGetRef (key) == SSIZE_MAX, "reference counter");
     371             :         succeed_if (keyIncRef (key) == SSIZE_MAX, "should stay at maximum");
     372             :         succeed_if (keyGetRef (key) == SSIZE_MAX, "reference counter");
     373             :         succeed_if (keyIncRef (key) == SSIZE_MAX, "should stay at maximum");
     374             :         keyDel (key);
     375             : }
     376             : 
     377           2 : static void test_keyName (void)
     378             : {
     379             :         Key * key;
     380             :         char ret[1000];
     381             :         size_t i;
     382           2 :         char testName[] = "user/name";
     383           2 :         char testFullName[] = "user:max/name";
     384             :         char testBaseName[] = "name";
     385             : 
     386             : #ifdef HAVE_CLEARENV
     387           2 :         clearenv ();
     388             : #else
     389             :         unsetenv ("USER");
     390             : #endif
     391             : 
     392           2 :         printf ("Test Key Name\n");
     393             : 
     394           2 :         key = keyNew (testName, KEY_END);
     395           2 :         succeed_if (keyGetName (0, ret, 100) == -1, "null pointer");
     396           2 :         succeed_if (keyGetName (key, 0, 100) == -1, "string null pointer");
     397           2 :         succeed_if (keyGetName (key, ret, 0) == -1, "length checking");
     398          18 :         for (i = 1; i < sizeof (testName); i++)
     399             :         {
     400          18 :                 succeed_if (keyGetName (key, ret, i) == -1, "length checking too short");
     401             :         }
     402          20 :         for (i = sizeof (testName); i < sizeof (testName) * 2; i++)
     403             :         {
     404          20 :                 succeed_if (keyGetName (key, ret, i) == sizeof (testName), "length checking longer");
     405             :         }
     406           2 :         succeed_if (keyGetName (key, ret, (size_t) -1) == -1, "maxSize exceeded");
     407           2 :         keyDel (key);
     408             : 
     409           2 :         succeed_if (keyName (0) == 0, "null pointer");
     410             : 
     411           2 :         key = keyNew (0);
     412           2 :         succeed_if_same_string (keyName (key), "");
     413           2 :         succeed_if (keyGetName (key, ret, 1000) == 1, "get empty name");
     414           2 :         succeed_if_same_string (ret, "");
     415           2 :         succeed_if (keyGetName (key, ret, 0) == -1, "get empty name");
     416           2 :         keyDel (key);
     417             : 
     418           2 :         succeed_if (keySetName (0, ret) == -1, "Null pointer");
     419             : 
     420             : 
     421           2 :         printf ("Test Key Full Name\n");
     422             : 
     423           2 :         key = keyNew (testFullName, KEY_END);
     424           2 :         succeed_if (keyGetFullName (0, ret, 100) == -1, "null pointer");
     425           2 :         succeed_if (keyGetFullName (key, 0, 100) == -1, "string null pointer");
     426           2 :         succeed_if (keyGetFullName (key, ret, 0) == -1, "length checking");
     427          26 :         for (i = 1; i < sizeof (testFullName); i++)
     428             :         {
     429          26 :                 succeed_if (keyGetFullName (key, ret, i) == -1, "length checking too short");
     430             :         }
     431          28 :         for (i = sizeof (testFullName); i < sizeof (testFullName) * 2; i++)
     432             :         {
     433          28 :                 succeed_if (keyGetFullName (key, ret, i) == sizeof (testFullName), "length checking longer");
     434             :         }
     435           2 :         succeed_if (keyGetFullName (key, ret, (size_t) -1) == -1, "maxSize exceeded");
     436           2 :         keyDel (key);
     437             : 
     438           2 :         key = keyNew (0);
     439           2 :         succeed_if (keyGetFullName (key, ret, 1000) == 1, "get empty name");
     440           2 :         succeed_if_same_string (ret, "");
     441           2 :         succeed_if (keyGetFullName (key, ret, 0) == -1, "get empty name");
     442           2 :         keyDel (key);
     443             : 
     444           2 :         succeed_if (keySetName (0, ret) == -1, "Null pointer");
     445             : 
     446             : 
     447           2 :         printf ("Test Key Base Name\n");
     448             : 
     449           2 :         key = keyNew (testFullName, KEY_END);
     450           2 :         succeed_if (keyGetBaseName (0, ret, 100) == -1, "null pointer");
     451           2 :         succeed_if (keyGetBaseName (key, 0, 100) == -1, "string null pointer");
     452           2 :         succeed_if (keyGetBaseName (key, ret, 0) == -1, "length checking");
     453           8 :         for (i = 1; i < sizeof (testBaseName); i++)
     454             :         {
     455           8 :                 succeed_if (keyGetBaseName (key, ret, i) == -1, "length checking too short");
     456             :         }
     457          10 :         for (i = sizeof (testBaseName); i < sizeof (testBaseName) * 2; i++)
     458             :         {
     459          10 :                 succeed_if (keyGetBaseName (key, ret, i) == sizeof (testBaseName), "length checking longer");
     460             :         }
     461           2 :         succeed_if (keyGetBaseName (key, ret, (size_t) -1) == -1, "maxSize exceeded");
     462           2 :         keyDel (key);
     463             : 
     464           2 :         succeed_if (keyBaseName (0) == 0, "null pointer");
     465             : 
     466           2 :         key = keyNew (0);
     467           2 :         succeed_if_same_string (keyBaseName (key), "");
     468           2 :         succeed_if (keyGetBaseName (key, ret, 1000) == 1, "get empty name");
     469           2 :         succeed_if_same_string (ret, "");
     470           2 :         succeed_if (keyGetBaseName (key, ret, 0) == -1, "get empty name");
     471           2 :         keyDel (key);
     472             : 
     473           2 :         succeed_if (keySetName (0, ret) == -1, "Null pointer");
     474             : 
     475           2 :         key = keyNew ("user", KEY_END);
     476           2 :         succeed_if_same_string (keyName (key), "user");
     477           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     478           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     479           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     480           2 :         succeed_if_same_string (ret, "");
     481           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     482           2 :         succeed_if_same_string (ret, "");
     483           2 :         keyDel (key);
     484             : 
     485           2 :         key = keyNew ("user/", KEY_END);
     486           2 :         succeed_if_same_string (keyName (key), "user");
     487           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     488           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     489           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     490           2 :         succeed_if_same_string (ret, "");
     491           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     492           2 :         succeed_if_same_string (ret, "");
     493           2 :         keyDel (key);
     494             : 
     495           2 :         key = keyNew ("user//", KEY_END);
     496           2 :         succeed_if_same_string (keyName (key), "user");
     497           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     498           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     499           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     500           2 :         succeed_if_same_string (ret, "");
     501           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     502           2 :         succeed_if_same_string (ret, "");
     503           2 :         keyDel (key);
     504             : 
     505           2 :         key = keyNew ("system", KEY_END);
     506           2 :         succeed_if_same_string (keyName (key), "system");
     507           2 :         succeed_if (keyGetNameSize (key) == 7, "name length checking");
     508           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     509           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     510           2 :         succeed_if_same_string (ret, "");
     511           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     512           2 :         succeed_if_same_string (ret, "");
     513           2 :         keyDel (key);
     514             : 
     515           2 :         key = keyNew ("system/", KEY_END);
     516           2 :         succeed_if_same_string (keyName (key), "system");
     517           2 :         succeed_if (keyGetNameSize (key) == 7, "name length checking");
     518           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     519           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     520           2 :         succeed_if_same_string (ret, "");
     521           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     522           2 :         succeed_if_same_string (ret, "");
     523           2 :         keyDel (key);
     524             : 
     525           2 :         key = keyNew ("dir", KEY_END);
     526           2 :         succeed_if_same_string (keyName (key), "dir");
     527           2 :         succeed_if (keyGetNameSize (key) == 4, "name length checking");
     528           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     529           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     530           2 :         succeed_if_same_string (ret, "");
     531           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     532           2 :         succeed_if_same_string (ret, "");
     533           2 :         keyDel (key);
     534             : 
     535           2 :         key = keyNew ("dir/", KEY_END);
     536           2 :         succeed_if_same_string (keyName (key), "dir");
     537           2 :         succeed_if (keyGetNameSize (key) == 4, "name length checking");
     538           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     539           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     540           2 :         succeed_if_same_string (ret, "");
     541           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     542           2 :         succeed_if_same_string (ret, "");
     543           2 :         keyDel (key);
     544             : 
     545           2 :         key = keyNew ("proc", KEY_END);
     546           2 :         succeed_if_same_string (keyName (key), "proc");
     547           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     548           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     549           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     550           2 :         succeed_if_same_string (ret, "");
     551           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     552           2 :         succeed_if_same_string (ret, "");
     553           2 :         keyDel (key);
     554             : 
     555           2 :         key = keyNew ("proc/", KEY_END);
     556           2 :         succeed_if_same_string (keyName (key), "proc");
     557           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     558           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     559           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     560           2 :         succeed_if_same_string (ret, "");
     561           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     562           2 :         succeed_if_same_string (ret, "");
     563           2 :         keyDel (key);
     564             : 
     565           2 :         key = keyNew ("spec", KEY_END);
     566           2 :         succeed_if_same_string (keyName (key), "spec");
     567           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     568           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     569           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     570           2 :         succeed_if_same_string (ret, "");
     571           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     572           2 :         succeed_if_same_string (ret, "");
     573           2 :         keyDel (key);
     574             : 
     575           2 :         key = keyNew ("spec/", KEY_END);
     576           2 :         succeed_if_same_string (keyName (key), "spec");
     577           2 :         succeed_if (keyGetNameSize (key) == 5, "name length checking");
     578           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     579           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     580           2 :         succeed_if_same_string (ret, "");
     581           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     582           2 :         succeed_if_same_string (ret, "");
     583           2 :         keyDel (key);
     584             : 
     585           2 :         key = keyNew ("/", KEY_END);
     586           2 :         succeed_if_same_string (keyName (key), "/");
     587           2 :         succeed_if (keyGetNameSize (key) == 2, "name length checking");
     588           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     589           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     590           2 :         succeed_if_same_string (ret, "");
     591           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     592           2 :         succeed_if_same_string (ret, "");
     593           2 :         keyDel (key);
     594             : 
     595           2 :         key = keyNew ("//", KEY_END);
     596           2 :         succeed_if_same_string (keyName (key), "/");
     597           2 :         succeed_if (keyGetNameSize (key) == 2, "name length checking");
     598           2 :         succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
     599           2 :         succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
     600           2 :         succeed_if_same_string (ret, "");
     601           2 :         succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
     602           2 :         succeed_if_same_string (ret, "");
     603           2 :         keyDel (key);
     604           2 : }
     605             : 
     606             : 
     607           2 : static void test_keyNameSlashes (void)
     608             : {
     609           2 :         printf ("Test Slashes in Key Name\n");
     610             :         char * buf;
     611             :         char * getBack;
     612             :         char ret[1000];
     613           2 :         Key * key = 0;
     614             :         int i;
     615             : 
     616             : 
     617           2 :         key = keyNew (0);
     618           2 :         succeed_if (keyGetNameSize (key) == 1, "empty name size");
     619           2 :         keyDel (key);
     620             : 
     621           2 :         key = keyNew ("", KEY_END);
     622           2 :         succeed_if (key != 0, "key should not be null!");
     623           2 :         succeed_if_same_string (keyName (key), "");
     624           2 :         succeed_if (keyGetName (key, ret, 999) == 1, "keyGetName should return 1");
     625           2 :         succeed_if_same_string (ret, "");
     626           2 :         succeed_if (keyGetNameSize (key) == 1, "empty name size");
     627           2 :         keyDel (key);
     628             : 
     629           2 :         key = keyNew (0);
     630           2 :         keySetName (key, "user");
     631           2 :         succeed_if_same_string (keyName (key), "user");
     632           2 :         succeed_if (keyGetNameSize (key) == 5, "empty name size");
     633             : 
     634           2 :         keySetName (key, "system");
     635           2 :         succeed_if_same_string (keyName (key), "system");
     636           2 :         succeed_if (keyGetNameSize (key) == 7, "empty name size");
     637           2 :         keyDel (key);
     638             : 
     639           2 :         key = keyNew (0);
     640           2 :         keySetName (key, "system");
     641           2 :         succeed_if_same_string (keyName (key), "system");
     642           2 :         succeed_if (keyGetNameSize (key) == 7, "empty name size");
     643             : 
     644           2 :         keySetName (key, "user");
     645           2 :         succeed_if_same_string (keyName (key), "user");
     646           2 :         succeed_if (keyGetNameSize (key) == 5, "empty name size");
     647           2 :         keyDel (key);
     648             : 
     649           2 :         key = keyNew (0);
     650           2 :         succeed_if (keySetName (key, "user:") == 5, "setting user: generates error");
     651           2 :         succeed_if_same_string (keyName (key), "user");
     652           2 :         succeed_if (keyGetNameSize (key) == 5, "empty name size");
     653           2 :         keyDel (key);
     654             : 
     655           2 :         key = keyNew (0);
     656           2 :         succeed_if (keySetName (key, "user:y") == 5, "setting user: generates error");
     657           2 :         succeed_if_same_string (keyName (key), "user");
     658           2 :         succeed_if (keyGetNameSize (key) == 5, "empty name size");
     659           2 :         keyDel (key);
     660             : 
     661           2 :         key = keyNew (0);
     662           2 :         succeed_if (keySetName (key, "no") == -1, "no error code setting invalid name");
     663           2 :         succeed_if_same_string (keyName (key), "");
     664           2 :         succeed_if (keyGetNameSize (key) == 1, "empty name size");
     665           2 :         keyDel (key);
     666             : 
     667           2 :         key = keyNew ("user/noname", KEY_END);
     668           2 :         succeed_if (keyGetNameSize (key) == 12, "size not correct after keyNew");
     669           2 :         getBack = elektraMalloc (12);
     670           2 :         succeed_if (keyGetName (key, getBack, 12), "could not get name");
     671           2 :         succeed_if_same_string (getBack, "user/noname");
     672           2 :         elektraFree (getBack);
     673             : 
     674           2 :         keySetName (key, "user/noname");
     675           2 :         succeed_if (keyGetNameSize (key) == 12, "size not correct after keySetName");
     676           2 :         getBack = elektraMalloc (12);
     677           2 :         succeed_if (keyGetName (key, getBack, 12), "could not get name");
     678           2 :         succeed_if_same_string (getBack, "user/noname");
     679           2 :         elektraFree (getBack);
     680             : 
     681           2 :         keySetName (key, "no");
     682           2 :         succeed_if (keyGetNameSize (key) == 1, "size not correct after keySetName");
     683           2 :         getBack = elektraMalloc (1);
     684           2 :         succeed_if (keyGetName (key, getBack, 1), "could not get name");
     685           2 :         succeed_if_same_string (getBack, "");
     686           2 :         elektraFree (getBack);
     687           2 :         keyDel (key);
     688             : 
     689           2 :         key = keyNew ("user/noname", KEY_END);
     690           2 :         keySetName (key, "");
     691           2 :         succeed_if_same_string (keyName (key), "");
     692           2 :         succeed_if (keyGetName (key, ret, 999) == 1, "keyGetName should return 1");
     693           2 :         succeed_if_same_string (ret, "");
     694           2 :         succeed_if (keyGetNameSize (key) == 1, "empty name size");
     695             : 
     696           2 :         keySetName (key, "user//hidden");
     697           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     698           2 :         succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
     699             : 
     700           2 :         keySetName (key, "user///hidden");
     701           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     702           2 :         succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
     703             : 
     704           2 :         keySetName (key, "user////////////////////////////////////hidden");
     705           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     706           2 :         succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
     707             : 
     708           2 :         printf ("Test trailing Slashes in Key Name\n");
     709           2 :         keySetName (key, "user//hidden/");
     710           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     711           2 :         succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
     712             : 
     713           2 :         keySetName (key, "user//hidden//");
     714           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     715           2 :         succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
     716             : 
     717           2 :         keySetName (key, "user//hidden///////");
     718           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     719           2 :         succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
     720             : 
     721           2 :         keySetName (key, "user");
     722           2 :         succeed_if_same_string (keyName (key), "user");
     723             : 
     724           2 :         keySetName (key, "user/");
     725           2 :         succeed_if_same_string (keyName (key), "user");
     726             : 
     727           2 :         keySetName (key, "user/a");
     728           2 :         succeed_if_same_string (keyName (key), "user/a");
     729             : 
     730           2 :         keySetName (key, "user//");
     731           2 :         succeed_if_same_string (keyName (key), "user");
     732             : 
     733           2 :         keySetName (key, "user/////////");
     734           2 :         succeed_if_same_string (keyName (key), "user");
     735             : 
     736           2 :         printf ("Test Dots in Key Name\n");
     737           2 :         keySetName (key, "user/hidden/.");
     738           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     739             : 
     740           2 :         keySetName (key, "user/.");
     741           2 :         succeed_if_same_string (keyName (key), "user");
     742             : 
     743           2 :         keySetName (key, "user/./hidden");
     744           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     745             : 
     746           2 :         keySetName (key, "user/.valid/.");
     747           2 :         succeed_if_same_string (keyName (key), "user/.valid");
     748             : 
     749           2 :         keySetName (key, "user/./.valid");
     750           2 :         succeed_if_same_string (keyName (key), "user/.valid");
     751             : 
     752           2 :         keySetName (key, "user/./.valid/.");
     753           2 :         succeed_if_same_string (keyName (key), "user/.valid");
     754             : 
     755           2 :         keySetName (key, "user/././././.valid/././././.");
     756           2 :         succeed_if_same_string (keyName (key), "user/.valid");
     757             : 
     758           2 :         printf ("Test Double Dots in Key Name\n");
     759           2 :         keySetName (key, "user/hidden/parent/..");
     760           2 :         succeed_if_same_string (keyName (key), "user/hidden");
     761             : 
     762           2 :         keySetName (key, "user/hidden/..");
     763           2 :         succeed_if_same_string (keyName (key), "user");
     764             : 
     765           2 :         keySetName (key, "user/..");
     766           2 :         succeed_if_same_string (keyName (key), "user");
     767             : 
     768           2 :         keySetName (key, "user/hidden/../..");
     769             :         // printf ("Name: %s\n", keyName(key));
     770           2 :         succeed_if_same_string (keyName (key), "user");
     771             : 
     772           2 :         succeed_if (keySetName (key, "user///sw/../sw//././MyApp") == sizeof ("user/sw/MyApp"), "could not set keySet example");
     773             :         // printf("%s %d\n", keyName(key), keyGetNameSize(key));
     774           2 :         succeed_if_same_string (keyName (key), "user/sw/MyApp");
     775           2 :         succeed_if (keyGetNameSize (key) == sizeof ("user/sw/MyApp"), "incorrect length for keySet example");
     776             : 
     777           2 :         printf ("Test Mixed Dots and Slashes in Key Name\n");
     778           2 :         keySetName (key, "user/hidden/../.");
     779             : 
     780           2 :         keyDel (key);
     781             : 
     782             : 
     783           2 :         printf ("Test failure key creation\n");
     784             : 
     785           2 :         key = keyNew ("invalid", KEY_END);
     786           2 :         succeed_if (key != 0, "null pointer for invalid name");
     787           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
     788             : 
     789           2 :         key = keyNew ("nonhere/valid/there", KEY_END);
     790           2 :         succeed_if (key != NULL, "keyNew did not accept wrong name");
     791           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
     792             : 
     793           2 :         key = keyNew ("nonhere:y/valid/there", KEY_END);
     794           2 :         succeed_if (key != NULL, "keyNew did not accept wrong name");
     795           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
     796             : 
     797           2 :         key = keyNew ("user/validname", KEY_END);
     798           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name");
     799           2 :         succeed_if_same_string (keyName (key), "user/validname");
     800             : 
     801           2 :         keySetName (key, "invalid");
     802           2 :         succeed_if (keyGetNameSize (key) == 1, "name size for invalid name");
     803           2 :         succeed_if_same_string (keyName (key), "");
     804             : 
     805           2 :         keySetName (key, "user/validname");
     806           2 :         succeed_if_same_string (keyName (key), "user/validname");
     807             : 
     808           2 :         keySetName (key, "");
     809           2 :         succeed_if (keyGetNameSize (key) == 1, "name size for invalid name");
     810           2 :         succeed_if_same_string (keyName (key), "");
     811             : 
     812           2 :         keySetName (key, "user/validname\\/t");
     813           2 :         succeed_if_same_string (keyName (key), "user/validname\\/t");
     814             : 
     815           2 :         keySetName (key, 0);
     816           2 :         succeed_if (keyGetNameSize (key) == 1, "name size for invalid name");
     817           2 :         succeed_if_same_string (keyName (key), "");
     818             : 
     819             : #ifdef COMPAT
     820             :         keySetName (key, "user/validname\\");
     821             :         succeed_if_same_string (keyName (key), "user/validname\\");
     822             : #endif
     823             : 
     824           2 :         keySetName (key, "user/validname\\/");
     825           2 :         succeed_if_same_string (keyName (key), "user/validname\\/");
     826           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
     827             : 
     828           2 :         printf ("Test key's name manipulation\n");
     829             : 
     830           2 :         Key * copy = keyNew (0);
     831             : 
     832          20 :         for (i = 0; tstKeyName[i].testName != NULL; i++)
     833             :         {
     834          18 :                 key = keyNew (tstKeyName[i].keyName, KEY_END);
     835             : 
     836          18 :                 succeed_if (keyGetRef (copy) == 0, "reference of copy not correct");
     837          18 :                 keyCopy (copy, key);
     838          18 :                 succeed_if (keyGetRef (copy) == 0, "reference of copy not correct");
     839             : 
     840          18 :                 Key * dup = keyDup (key);
     841          18 :                 succeed_if (keyGetRef (dup) == 0, "reference of dup not correct");
     842             : 
     843          18 :                 compare_key (copy, key);
     844          18 :                 compare_key (copy, dup);
     845          18 :                 compare_key (dup, key);
     846             : 
     847             :                 /* keyName */
     848          18 :                 succeed_if_same_string (keyName (key), tstKeyName[i].expectedKeyName);
     849          18 :                 succeed_if_same_string (keyName (copy), tstKeyName[i].expectedKeyName);
     850          18 :                 succeed_if_same_string (keyName (dup), tstKeyName[i].expectedKeyName);
     851             : 
     852             :                 /* keyBaseName */
     853          18 :                 succeed_if_same_string (keyBaseName (key), tstKeyName[i].expectedBaseName);
     854          18 :                 succeed_if_same_string (keyBaseName (copy), tstKeyName[i].expectedBaseName);
     855          18 :                 succeed_if_same_string (keyBaseName (dup), tstKeyName[i].expectedBaseName);
     856             : 
     857             :                 /* keyGetBaseNameSize */
     858          18 :                 size_t size = keyGetBaseNameSize (key);
     859          18 :                 succeed_if ((size == strlen (tstKeyName[i].expectedBaseName) + 1), "keyGetBaseNameSize");
     860             : 
     861             :                 /* keyGetBaseName */
     862          18 :                 size = keyGetBaseNameSize (key) + 1;
     863          18 :                 buf = elektraMalloc (size * sizeof (char));
     864          18 :                 keyGetBaseName (key, buf, size);
     865          18 :                 succeed_if_same_string (buf, tstKeyName[i].expectedBaseName);
     866          18 :                 elektraFree (buf);
     867             : 
     868             :                 /* keyGetNameSize */
     869          18 :                 size = keyGetNameSize (key);
     870          18 :                 succeed_if ((size == strlen (tstKeyName[i].expectedKeyName) + 1), "keyGetKeyNameSize");
     871             : 
     872             :                 /* keyGetName */
     873          18 :                 size = keyGetNameSize (key);
     874          18 :                 buf = elektraMalloc (size * sizeof (char));
     875          18 :                 keyGetName (key, buf, size);
     876          18 :                 succeed_if_same_string (buf, tstKeyName[i].expectedKeyName);
     877          18 :                 elektraFree (buf);
     878             : 
     879          18 :                 keyDel (key);
     880          18 :                 keyDel (dup);
     881             :         }
     882           2 :         keyDel (copy);
     883           2 : }
     884             : 
     885             : 
     886           2 : static void test_keyValue (void)
     887             : {
     888             :         Key * key;
     889             :         char ret[1000];
     890             :         size_t i;
     891           2 :         char testString[] = "teststring";
     892           2 :         char testBinary[] = "\0tes\1tbinary";
     893           2 :         testBinary[sizeof (testBinary) - 1] = 'T';
     894             : 
     895           2 :         printf ("Test value of keys\n");
     896             : 
     897           2 :         succeed_if (key = keyNew (0), "could not create new key");
     898           2 :         succeed_if (keyGetValueSize (key) == 1, "empty value size");
     899           2 :         succeed_if (keySetString (key, "perfectvalue") == 13, "could not set string");
     900           2 :         succeed_if (keyGetValueSize (key) == 13, "value size not correct");
     901           2 :         succeed_if_same_string (keyValue (key), "perfectvalue");
     902           2 :         succeed_if (keySetString (key, "perfectvalue") == 13, "could not re-set same string");
     903           2 :         succeed_if_same_string (keyValue (key), "perfectvalue");
     904           2 :         succeed_if (keySetString (key, "nearperfectvalue") == 17, "could not re-set other string");
     905           2 :         succeed_if (keyGetValueSize (key) == 17, "value size not correct");
     906           2 :         succeed_if_same_string (keyValue (key), "nearperfectvalue");
     907           2 :         succeed_if (keyGetString (key, ret, keyGetValueSize (key) >= 999 ? 999 : keyGetValueSize (key)) == 17, "could not get string");
     908           2 :         succeed_if_same_string (ret, "nearperfectvalue");
     909           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     910             : 
     911           2 :         succeed_if (key = keyNew (0), "could not create new key");
     912           2 :         succeed_if_same_string (keyValue (key), "");
     913           2 :         succeed_if (keyGetValueSize (key) == 1, "Empty value size problem");
     914           2 :         succeed_if (keySetString (key, "") == 1, "could not set empty string");
     915           2 :         succeed_if_same_string (keyValue (key), "");
     916           2 :         succeed_if (keyGetValueSize (key) == 1, "Empty value size problem");
     917           2 :         succeed_if (keyGetString (key, ret, 0) == -1, "Could not get empty value");
     918           2 :         succeed_if (keyGetString (key, ret, 1) == 1, "Could not get empty value");
     919           2 :         succeed_if (ret[0] == 0, "keyGetValue did not return empty value");
     920           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     921             : 
     922           2 :         succeed_if (key = keyNew (0), "could not create new key");
     923           2 :         succeed_if (keySetString (key, "a long long string") == 19, "could not set string");
     924           2 :         succeed_if (keyGetString (key, ret, 6) == -1, "string not truncated");
     925           2 :         succeed_if (keyGetBinary (key, ret, 999) == -1, "binary not mismatch");
     926           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     927             : 
     928           2 :         succeed_if (key = keyNew (0), "could not create new key");
     929           2 :         succeed_if (keySetBinary (key, "a", 1) == 1, "could not set binary");
     930           2 :         succeed_if (keyIsString (key) == 0, "is not a string");
     931           2 :         succeed_if (keyIsBinary (key) == 1, "is not a string");
     932           2 :         succeed_if (keyGetBinary (key, ret, 1) == 1, "binary not truncated");
     933           2 :         succeed_if (!strncmp (ret, "a", 1), "binary value wrong");
     934           2 :         succeed_if (keyGetString (key, ret, 999) == -1, "string not mismatch");
     935           2 :         succeed_if (keySetString (key, 0) == 1, "wrong error code for SetString");
     936           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     937             : 
     938           2 :         succeed_if (key = keyNew (0), "could not create new key");
     939           2 :         succeed_if (keySetBinary (key, NULL, 0) == 0, "could not set null binary");
     940           2 :         succeed_if (keyIsString (key) == 0, "is not a string");
     941           2 :         succeed_if (keyIsBinary (key) == 1, "is not a string");
     942           2 :         succeed_if (keyGetValueSize (key) == 0, "Empty value size problem");
     943           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     944             : 
     945           2 :         succeed_if (key = keyNew (0), "could not create new key");
     946           2 :         succeed_if (keySetString (key, "") == 1, "could not set empty string");
     947           2 :         succeed_if (keyIsString (key) == 1, "is not a string");
     948           2 :         succeed_if (keyIsBinary (key) == 0, "is a binary");
     949           2 :         succeed_if (keyGetValueSize (key) == 1, "Empty value size problem");
     950           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     951             : 
     952           2 :         succeed_if (key = keyNew (0), "could not create new key");
     953           2 :         succeed_if (keySetBinary (key, "a long long binary", 19) == 19, "could not set string");
     954           2 :         succeed_if (keyIsString (key) == 0, "is not a string");
     955           2 :         succeed_if (keyIsBinary (key) == 1, "is not a string");
     956           2 :         succeed_if (keyGetBinary (key, ret, 6) == -1, "binary not truncated");
     957           2 :         succeed_if (keyGetBinary (key, ret, 19) == 19, "could not get binary");
     958           2 :         succeed_if (!strncmp (ret, "a long long binary", 19), "binary value wrong");
     959           2 :         succeed_if (keyGetString (key, ret, 999) == -1, "string not mismatch");
     960           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     961             : 
     962           2 :         succeed_if (key = keyNew (0), "could not create new key");
     963         508 :         for (i = 1; i < 255; i++)
     964             :         {
     965         508 :                 ret[0] = i;
     966         508 :                 ret[1] = i;
     967         508 :                 ret[2] = 0;
     968             :                 // output_key (key);
     969         508 :                 succeed_if (keySetString (key, ret) == 3, "could not set string");
     970         508 :                 succeed_if_same_string (keyValue (key), ret);
     971             :         }
     972           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     973             : 
     974             : 
     975           2 :         succeed_if (key = keyNew (0), "could not create new key");
     976         510 :         for (i = 0; i < 255; i++)
     977             :         {
     978         510 :                 ret[0] = i;
     979         510 :                 ret[1] = 255 - i;
     980         510 :                 ret[2] = i;
     981             :                 // output_key (key);
     982         510 :                 succeed_if (keySetBinary (key, ret, 3) == 3, "could not set string");
     983         510 :                 succeed_if (memcmp (keyValue (key), ret, 3) == 0, "String not same as set");
     984             :         }
     985           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     986             : 
     987             : 
     988           2 :         printf ("Test string of key\n");
     989             : 
     990           2 :         succeed_if (keyValue (0) == 0, "null pointer");
     991           2 :         succeed_if (keyGetValueSize (0) == -1, "null pointer");
     992           2 :         succeed_if (keySetString (0, "") == -1, "null pointer");
     993             : 
     994           2 :         key = keyNew (0);
     995           2 :         succeed_if (keyGetValueSize (key) == 1, "empty value size");
     996             : 
     997           2 :         keySetString (key, testString);
     998           2 :         succeed_if (keyGetString (0, ret, 100) == -1, "null pointer");
     999           2 :         succeed_if (keyGetString (key, 0, 100) == -1, "string null pointer");
    1000           2 :         succeed_if (keyGetString (key, ret, 0) == -1, "length checking");
    1001             : 
    1002          20 :         for (i = 1; i < sizeof (testString); i++)
    1003             :         {
    1004          20 :                 succeed_if (keyGetString (key, ret, i) == -1, "length checking too short");
    1005             :         }
    1006          22 :         for (i = sizeof (testString); i < sizeof (testString) * 2; i++)
    1007             :         {
    1008          22 :                 succeed_if (keyGetString (key, ret, i) == sizeof (testString), "length checking longer");
    1009             :         }
    1010           2 :         succeed_if (keyGetString (key, ret, (size_t) -1) == -1, "maxSize exceeded");
    1011             : 
    1012           2 :         succeed_if (keySetString (key, 0) == 1, "delete string");
    1013           2 :         succeed_if (keyGetString (key, ret, i) == 1, "length checking deleting");
    1014           2 :         succeed_if_same_string (ret, "");
    1015             : 
    1016           2 :         succeed_if (keySetString (key, testString) == sizeof (testString), "set string");
    1017           2 :         succeed_if (keyGetString (key, ret, i) == sizeof (testString), "length checking working");
    1018           2 :         succeed_if_same_string (ret, testString);
    1019             : 
    1020           2 :         succeed_if (keySetString (key, "") == 1, "delete string");
    1021           2 :         succeed_if (keyGetString (key, ret, i) == 1, "length checking deleting");
    1022           2 :         succeed_if_same_string (ret, "");
    1023             : 
    1024           2 :         succeed_if (keySetString (key, testString) == sizeof (testString), "set string");
    1025           2 :         succeed_if (keyGetString (key, ret, i) == sizeof (testString), "length checking working");
    1026           2 :         succeed_if_same_string (ret, testString);
    1027             : 
    1028           2 :         succeed_if (keyGetValueSize (key) == sizeof (testString), "testString value size");
    1029           2 :         succeed_if (strncmp (keyValue (key), testString, sizeof (testString)) == 0, "testString not same");
    1030           2 :         keyDel (key);
    1031             : 
    1032             : 
    1033           2 :         printf ("Test binary of key\n");
    1034             : 
    1035           2 :         succeed_if (keyValue (0) == 0, "null pointer");
    1036           2 :         succeed_if (keyGetValueSize (0) == -1, "null pointer");
    1037           2 :         succeed_if (keySetBinary (0, "", 1) == -1, "null pointer");
    1038             : 
    1039           2 :         key = keyNew (0);
    1040           2 :         succeed_if (keySetBinary (key, "", 0) == -1, "null size");
    1041           2 :         succeed_if (keySetBinary (key, "b", 0) == -1, "null size");
    1042           2 :         succeed_if (keySetBinary (key, "", SIZE_MAX) == -1, "max size");
    1043           2 :         succeed_if (keySetBinary (key, "b", SIZE_MAX) == -1, "max size");
    1044           2 :         succeed_if (keyGetValueSize (key) == 1, "empty value size");
    1045             : 
    1046           2 :         keySetBinary (key, testBinary, sizeof (testBinary));
    1047           2 :         succeed_if (keyGetBinary (0, ret, 100) == -1, "null pointer");
    1048           2 :         succeed_if (keyGetBinary (key, 0, 100) == -1, "binary null pointer");
    1049           2 :         succeed_if (keyGetBinary (key, ret, 0) == -1, "length checking");
    1050             : 
    1051          24 :         for (i = 1; i < sizeof (testBinary); i++)
    1052             :         {
    1053          24 :                 succeed_if (keyGetBinary (key, ret, i) == -1, "length checking too short");
    1054             :         }
    1055          26 :         for (i = sizeof (testBinary); i < sizeof (testBinary) * 2; i++)
    1056             :         {
    1057          26 :                 succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking longer");
    1058             :         }
    1059           2 :         succeed_if (keyGetBinary (key, ret, (size_t) -1) == -1, "maxSize exceeded");
    1060             : 
    1061           2 :         succeed_if (keySetBinary (key, 0, 0) == 0, "delete binary");
    1062           2 :         succeed_if (keyGetBinary (key, ret, i) == 0, "length checking deleting");
    1063             : 
    1064           2 :         succeed_if (keySetBinary (key, testBinary, sizeof (testBinary)) == sizeof (testBinary), "set binary");
    1065           2 :         succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking working");
    1066           2 :         succeed_if_same_string (ret, testBinary);
    1067             : 
    1068           2 :         succeed_if (keySetBinary (key, 0, 1) == 0, "delete binary");
    1069           2 :         succeed_if (keyGetBinary (key, ret, i) == 0, "length checking deleting");
    1070             : 
    1071           2 :         succeed_if (keySetBinary (key, testBinary, sizeof (testBinary)) == sizeof (testBinary), "set binary");
    1072           2 :         succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking working");
    1073           2 :         succeed_if_same_string (ret, testBinary);
    1074             : 
    1075           2 :         succeed_if (keySetBinary (key, "", 1) == 1, "delete binary the string way");
    1076           2 :         succeed_if (keyGetBinary (key, ret, i) == 1, "length checking deleting string way");
    1077           2 :         succeed_if_same_string (ret, "");
    1078             : 
    1079           2 :         succeed_if (keySetBinary (key, testBinary, sizeof (testBinary)) == sizeof (testBinary), "set binary");
    1080           2 :         succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking working");
    1081           2 :         succeed_if_same_string (ret, testBinary);
    1082             : 
    1083           2 :         succeed_if (keyGetValueSize (key) == sizeof (testBinary), "testBinary value size");
    1084           2 :         succeed_if (strncmp (keyValue (key), testBinary, sizeof (testBinary)) == 0, "testBinary not same");
    1085           2 :         keyDel (key);
    1086           2 : }
    1087             : 
    1088           2 : static void test_keyBinary (void)
    1089             : {
    1090           2 :         Key * key = 0;
    1091             :         char ret[1000];
    1092             :         int i;
    1093           2 :         char binaryData[] = "\0binary \1\34data";
    1094           2 :         binaryData[sizeof (binaryData) - 1] = 'T';
    1095             : 
    1096           2 :         printf ("Test binary special cases\n");
    1097             : 
    1098           2 :         key = keyNew ("user/binary", KEY_BINARY, KEY_END);
    1099             : 
    1100           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1101           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1102           2 :         succeed_if (keyGetValueSize (key) == 0, "size not correct");
    1103           2 :         succeed_if (keyValue (key) == 0, "should be null key");
    1104           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1105             : 
    1106           2 :         keyDel (key);
    1107             : 
    1108           2 :         key = keyNew ("user/binary", KEY_BINARY, KEY_SIZE, sizeof (binaryData), KEY_VALUE, binaryData, KEY_END);
    1109             : 
    1110           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1111           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1112           2 :         succeed_if (keyGetValueSize (key) == sizeof (binaryData), "size not correct");
    1113           2 :         succeed_if (memcmp (binaryData, keyValue (key), sizeof (binaryData)) == 0, "memcmp");
    1114           2 :         succeed_if (keyGetBinary (key, ret, 1000) == sizeof (binaryData), "could not get binary data");
    1115           2 :         succeed_if (memcmp (binaryData, ret, sizeof (binaryData)) == 0, "memcmp");
    1116           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1117             : 
    1118           2 :         keyDel (key);
    1119             : 
    1120           2 :         key = keyNew (0);
    1121           2 :         keySetBinary (key, binaryData, sizeof (binaryData));
    1122             : 
    1123           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1124           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1125           2 :         succeed_if (keyGetValueSize (key) == sizeof (binaryData), "size not correct");
    1126           2 :         succeed_if (memcmp (binaryData, keyValue (key), sizeof (binaryData)) == 0, "memcmp");
    1127           2 :         succeed_if (keyGetBinary (key, ret, 1000) == sizeof (binaryData), "could not get binary data");
    1128           2 :         succeed_if (memcmp (binaryData, ret, sizeof (binaryData)) == 0, "memcmp");
    1129           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1130             : 
    1131           2 :         keyDel (key);
    1132             : 
    1133           2 :         key = keyNew (0);
    1134           2 :         keySetBinary (key, 0, 0);
    1135             : 
    1136           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1137           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1138           2 :         succeed_if (keyGetValueSize (key) == 0, "size not correct");
    1139           2 :         succeed_if (keyValue (key) == 0, "should be null pointer");
    1140           2 :         succeed_if (keyGetBinary (key, ret, 1000) == 0, "should write nothing because of no data");
    1141           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1142             : 
    1143           2 :         keyDel (key);
    1144             : 
    1145           2 :         key = keyNew (0);
    1146           2 :         keySetBinary (key, 0, 1);
    1147             : 
    1148           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1149           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1150           2 :         succeed_if (keyGetValueSize (key) == 0, "size not correct");
    1151           2 :         succeed_if (keyValue (key) == 0, "should be null pointer");
    1152           2 :         succeed_if (keyGetBinary (key, ret, 1000) == 0, "should write nothing because of no data");
    1153           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1154             : 
    1155           2 :         keyDel (key);
    1156             : 
    1157           2 :         key = keyNew (0);
    1158           2 :         keySetBinary (key, "", 1);
    1159           2 :         succeed_if (keySetBinary (key, 0, SIZE_MAX) == -1, "should do nothing and fail");
    1160           2 :         succeed_if (keySetBinary (key, 0, SSIZE_MAX) == 0, "should free data");
    1161             : 
    1162           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1163           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1164           2 :         succeed_if (keyGetValueSize (key) == 0, "size not correct");
    1165           2 :         succeed_if (keyValue (key) == 0, "should be null pointer");
    1166           2 :         succeed_if (keyGetBinary (key, ret, 1000) == 0, "should write nothing because of no data");
    1167           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1168             : 
    1169           2 :         keyDel (key);
    1170             : 
    1171           2 :         key = keyNew (0);
    1172           2 :         keySetBinary (key, "", 1);
    1173             : 
    1174           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1175           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1176           2 :         succeed_if (keyGetValueSize (key) == 1, "size not correct");
    1177           2 :         succeed_if (memcmp (binaryData, keyValue (key), 1) == 0, "memcmp");
    1178           2 :         succeed_if (keyGetBinary (key, ret, 1000) == 1, "could not get binary data");
    1179           2 :         succeed_if (memcmp (binaryData, ret, 1) == 0, "memcmp");
    1180           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1181             : 
    1182           2 :         keyDel (key);
    1183             : 
    1184           2 :         key = keyNew (0);
    1185           2 :         i = 23;
    1186           2 :         keySetBinary (key, (void *) &i, sizeof (i));
    1187             : 
    1188           2 :         succeed_if (keyIsBinary (key) == 1, "should be binary");
    1189           2 :         succeed_if (keyIsString (key) == 0, "should not be string");
    1190           2 :         succeed_if (keyGetValueSize (key) == sizeof (i), "size not correct");
    1191           2 :         succeed_if (memcmp ((void *) &i, keyValue (key), sizeof (i)) == 0, "memcmp");
    1192           2 :         succeed_if (keyGetBinary (key, ret, 1000) == sizeof (i), "could not get binary data");
    1193           2 :         succeed_if (memcmp ((void *) &i, ret, sizeof (i)) == 0, "memcmp");
    1194           2 :         succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
    1195             : 
    1196           2 :         i = *(int *) keyValue (key);
    1197           2 :         succeed_if (i == 23, "incorrect int");
    1198             : 
    1199           2 :         keyDel (key);
    1200           2 : }
    1201             : 
    1202           2 : static void test_keyInactive (void)
    1203             : {
    1204           2 :         Key * key = keyNew (0);
    1205             : 
    1206           2 :         succeed_if (keyIsInactive (0) == -1, "NULL pointer");
    1207           2 :         succeed_if (keyIsInactive (key) == -1, "Key has no name");
    1208             : 
    1209           2 :         printf ("Test of active and inactive keys\n");
    1210           2 :         keySetName (key, "user/valid");
    1211           2 :         succeed_if (!keyIsInactive (key), "Key should not be inactive");
    1212             : 
    1213           2 :         keySetName (key, "user/.hidden/valid");
    1214           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1215             : 
    1216           2 :         keySetName (key, "user/.hidden/€valid");
    1217           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1218             : 
    1219           2 :         keySetName (key, "user/..hidden/valid");
    1220           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1221             : 
    1222           2 :         keySetName (key, "user/hidden");
    1223           2 :         succeed_if (!keyIsInactive (key), "Key should not be inactive");
    1224             : 
    1225           2 :         keySetName (key, "user/.hidden");
    1226           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1227             : 
    1228           2 :         keySetName (key, "user/.valid/.hidden");
    1229           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1230             : 
    1231           2 :         keySetName (key, "user/.valid/.:hidden");
    1232           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1233             : 
    1234           2 :         keySetName (key, "user/.valid/.€hidden");
    1235           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1236             : 
    1237           2 :         keySetName (key, "user/.HiddenStringKey");
    1238           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1239             : 
    1240           2 :         keySetName (key, "user/.HiddenDirectoryKey");
    1241           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1242             : 
    1243           2 :         keySetName (key, "user/.HiddenDirectoryKey/StringKey");
    1244           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1245             : 
    1246           2 :         keySetName (key, "user/tests/file8xdLVS/filesys/.HiddenStringKey");
    1247           2 :         succeed_if (keyIsInactive (key), "Key should be inactive");
    1248             : 
    1249           2 :         keySetName (key, "user/.hidden/nothidden/hierarchy");
    1250           2 :         succeed_if (keyIsInactive (key) == 1, "Key should be inactive");
    1251             : 
    1252           2 :         keySetName (key, "user/.hidden/nothidden/hierarchy");
    1253           2 :         succeed_if (keyIsInactive (key) == 1, "Key should be inactive");
    1254           2 :         keyDel (key);
    1255           2 : }
    1256             : 
    1257           2 : static void test_keyBelow (void)
    1258             : {
    1259           2 :         Key * key1 = keyNew (0);
    1260           2 :         Key * key2 = keyNew (0);
    1261             : 
    1262           2 :         printf ("Test of relative positions of keys\n");
    1263             : 
    1264           2 :         succeed_if (keyIsBelow (key1, 0) == -1, "NULL pointer");
    1265           2 :         succeed_if (keyIsBelow (0, 0) == -1, "NULL pointer");
    1266           2 :         succeed_if (keyIsBelow (0, key1) == -1, "NULL pointer");
    1267             : 
    1268           2 :         succeed_if (keyIsDirectBelow (key1, 0) == -1, "NULL pointer");
    1269           2 :         succeed_if (keyIsDirectBelow (0, 0) == -1, "NULL pointer");
    1270           2 :         succeed_if (keyIsDirectBelow (0, key1) == -1, "NULL pointer");
    1271             : 
    1272           2 :         keySetName (key1, "user/valid");
    1273           2 :         keySetName (key2, "user/valid");
    1274           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1275           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1276             : 
    1277           2 :         keySetName (key1, "user/valid");
    1278           2 :         keySetName (key2, "user/valid/");
    1279           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1280           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1281             : 
    1282           2 :         keySetName (key1, "user/valid");
    1283           2 :         keySetName (key2, "user/valid/below");
    1284           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1285           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1286             : 
    1287           2 :         keySetName (key1, "user/valid");
    1288           2 :         keySetName (key2, "user/valid/b");
    1289           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1290           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1291             : 
    1292           2 :         keySetName (key1, "user/valid");
    1293           2 :         keySetName (key2, "user/valid/b");
    1294           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1295           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1296             : 
    1297           2 :         keySetName (key1, "user/valid");
    1298           2 :         keySetName (key2, "user/valid/b/e");
    1299           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1300           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1301             : 
    1302           2 :         keySetName (key1, "/valid");
    1303           2 :         keySetName (key2, "/valid/b/e");
    1304           2 :         succeed_if (keyIsBelow (key1, key2), "cascading Key should be below");
    1305           2 :         succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
    1306             : 
    1307           2 :         keySetName (key1, "/");
    1308           2 :         keySetName (key2, "/valid/b/e");
    1309           2 :         succeed_if (keyIsBelow (key1, key2), "cascading Key should be below");
    1310           2 :         succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
    1311             : 
    1312           2 :         keySetName (key1, "/");
    1313           2 :         keySetName (key2, "/v");
    1314           2 :         succeed_if (keyIsBelow (key1, key2), "cascading Key should be below");
    1315           2 :         succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
    1316             : 
    1317           2 :         keySetName (key1, "user");
    1318           2 :         keySetName (key2, "user");
    1319           2 :         succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
    1320           2 :         succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
    1321             : 
    1322           2 :         keySetName (key1, "dir");
    1323           2 :         keySetName (key2, "dir");
    1324           2 :         succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
    1325           2 :         succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
    1326             : 
    1327           2 :         keySetName (key1, "/");
    1328           2 :         keySetName (key2, "dir");
    1329           2 :         succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
    1330           2 :         succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
    1331             : 
    1332           2 :         keySetName (key1, "/");
    1333           2 :         keySetName (key2, "system");
    1334           2 :         succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
    1335           2 :         succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
    1336             : 
    1337           2 :         keySetName (key1, "user/a");
    1338           2 :         keySetName (key2, "user/a");
    1339           2 :         succeed_if (!keyIsBelow (key1, key2), "cascading Key should not be below");
    1340           2 :         succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
    1341             : 
    1342           2 :         keySetName (key1, "/");
    1343           2 :         keySetName (key2, "/");
    1344           2 :         succeed_if (!keyIsBelow (key1, key2), "cascading Key should not be below");
    1345           2 :         succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
    1346             : 
    1347           2 :         keySetName (key1, "user/valide");
    1348           2 :         keySetName (key2, "user/valid/e");
    1349           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1350           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1351             : 
    1352           2 :         keySetName (key1, "user/valid/b");
    1353           2 :         keySetName (key2, "user/valid/e");
    1354           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1355           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1356             : 
    1357           2 :         keySetName (key1, "user/valide");
    1358           2 :         keySetName (key2, "user/valid/valide");
    1359           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1360           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1361             : 
    1362           2 :         keySetName (key1, "system/infos");
    1363           2 :         keySetName (key2, "/infos/constants");
    1364           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1365           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1366             : 
    1367           2 :         keySetName (key1, "/");
    1368           2 :         keySetName (key2, "/infos/constants");
    1369           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1370           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1371             : 
    1372           2 :         keySetName (key1, "system");
    1373           2 :         keySetName (key2, "/infos/constants");
    1374           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1375           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1376             : 
    1377           2 :         keySetName (key1, "/infos");
    1378           2 :         keySetName (key2, "system/infos/constants");
    1379           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1380           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1381             : 
    1382           2 :         keySetName (key1, "system/infos/constants");
    1383           2 :         keySetName (key2, "/infos/constants/syste");
    1384           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1385           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1386             : 
    1387           2 :         keySetName (key1, "/");
    1388           2 :         keySetName (key2, "system/infos/constants");
    1389           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1390           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1391             : 
    1392           2 :         keySetName (key1, "/infos");
    1393           2 :         keySetName (key2, "/infos/constants");
    1394           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1395           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1396             : 
    1397           2 :         keySetName (key1, "/");
    1398           2 :         keySetName (key2, "system/infos/constants/version/version");
    1399           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1400           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1401             : 
    1402           2 :         keySetName (key1, "user/valid");
    1403           2 :         keySetName (key2, "user/valid\\/e");
    1404           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1405           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1406             : 
    1407           2 :         keySetName (key1, "user/valid\\/");
    1408           2 :         keySetName (key2, "user/valid/e");
    1409           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
    1410           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1411             : 
    1412           2 :         keySetName (key1, "/valid\\/");
    1413           2 :         keySetName (key2, "user/valid\\//valid");
    1414           2 :         succeed_if (keyIsBelow (key1, key2), "Key should be below");
    1415           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1416             : 
    1417           2 :         keySetName (key1, "/a/b/c");
    1418           2 :         keySetName (key2, "/a/b/d");
    1419           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should be below");
    1420           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1421             : 
    1422           2 :         keySetName (key1, "/a");
    1423           2 :         keySetName (key2, "/b");
    1424           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should be below");
    1425           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1426             : 
    1427           2 :         keySetName (key1, "/valid\\/");
    1428           2 :         keySetName (key2, "user/valid\\/valid");
    1429           2 :         succeed_if (!keyIsBelow (key1, key2), "Key should be below");
    1430           2 :         succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
    1431             : 
    1432             : 
    1433           2 :         keySetName (key1, "user/valid");
    1434           2 :         keySetName (key2, "user/valid/valide");
    1435           2 :         succeed_if (keyIsDirectBelow (key1, key2), "Key should be below");
    1436           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1437             : 
    1438           2 :         keySetName (key1, "user/valid");
    1439           2 :         keySetName (key2, "user/valid/non/valid");
    1440           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1441           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1442             : 
    1443           2 :         keySetName (key1, "user/valid/a");
    1444           2 :         keySetName (key2, "user/valid/b");
    1445           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1446           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1447             : 
    1448           2 :         keySetName (key1, "user/valid\\/");
    1449           2 :         keySetName (key2, "user/valid\\a");
    1450           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1451           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1452             : 
    1453           2 :         keySetName (key1, "user/valid\\/");
    1454           2 :         keySetName (key2, "user/valid\\/a");
    1455           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1456           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1457             : 
    1458           2 :         keySetName (key1, "user/valid\\/");
    1459           2 :         keySetName (key2, "user/valid\\/");
    1460           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1461           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1462             : 
    1463           2 :         keySetName (key1, "user/valid\\/");
    1464           2 :         keySetName (key2, "user/valid\\/a");
    1465           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1466           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1467             : 
    1468           2 :         keySetName (key1, "user/valid\\"); // this is an invalid name, so this situation cannot happen!
    1469           2 :         succeed_if_same_string (keyName (key1), "");
    1470           2 :         keySetName (key2, "user/valid\\/a");
    1471           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1472           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1473             : 
    1474           2 :         keySetName (key1, "user/valid\\/");
    1475           2 :         keySetName (key2, "user/valid\\/\\/");
    1476           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1477           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1478             : 
    1479           2 :         keySetName (key1, "user/valid\\/");
    1480           2 :         keySetName (key2, "user/valid\\/ab");
    1481           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1482           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1483             : 
    1484           2 :         keySetName (key1, "user/valid");
    1485           2 :         keySetName (key2, "user/valid");
    1486           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1487           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1488             : 
    1489           2 :         keySetName (key1, "user/valid/a/b");
    1490           2 :         keySetName (key2, "user/valid");
    1491           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1492           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1493             : 
    1494           2 :         keySetName (key1, "user/valid/a");
    1495           2 :         keySetName (key2, "user/valid");
    1496           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1497           2 :         succeed_if (keyIsDirectBelow (key2, key1), "Key should be below");
    1498             : 
    1499           2 :         keySetName (key1, "user/tests/ini-section-write");
    1500           2 :         keySetName (key2, "user/tests/ini-section-write/akey\\/looking\\/like\\/sections");
    1501           2 :         succeed_if (keyIsDirectBelow (key1, key2), "looking like sections not recognised");
    1502           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1503             : 
    1504           2 :         keySetName (key1, "user/valid");
    1505           2 :         keySetName (key2, "/valid/valide");
    1506           2 :         succeed_if (keyIsDirectBelow (key1, key2), "Key should be below");
    1507           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1508             : 
    1509           2 :         keySetName (key1, "user/valid");
    1510           2 :         keySetName (key2, "/valid/non/valid");
    1511           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1512           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1513             : 
    1514           2 :         keySetName (key1, "/valid");
    1515           2 :         keySetName (key2, "user/valid/valide");
    1516           2 :         succeed_if (keyIsDirectBelow (key1, key2), "Key should be below");
    1517           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1518             : 
    1519           2 :         keySetName (key1, "/valid");
    1520           2 :         keySetName (key2, "user/valid/non/valid");
    1521           2 :         succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
    1522           2 :         succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
    1523             : 
    1524             : 
    1525           2 :         keyDel (key1);
    1526           2 :         keyDel (key2);
    1527           2 : }
    1528             : 
    1529           2 : static void test_keyDup (void)
    1530             : {
    1531             :         Key *orig, *copy;
    1532             : 
    1533           2 :         printf ("Test key duplication\n");
    1534             : 
    1535           2 :         succeed_if (keyDup (0) == 0, "could not duplicate null");
    1536             : 
    1537             :         // Create test key
    1538           2 :         orig = keyNew ("user:yl/foo/bar", KEY_BINARY, KEY_SIZE, 6, KEY_VALUE, "foobar", KEY_COMMENT, "mycomment", KEY_UID, 123, KEY_GID,
    1539             :                        456, KEY_MODE, 0644, KEY_END);
    1540             : 
    1541             : 
    1542             :         // Dup the key
    1543           2 :         succeed_if ((copy = keyDup (orig)) != 0, "keyDup failed");
    1544           2 :         compare_key (orig, copy);
    1545           2 :         keyDel (orig); // everything independent from original!
    1546             : 
    1547             :         // Check the duplication
    1548           2 :         succeed_if_same_string (keyName (copy), "user/foo/bar");
    1549           2 :         succeed_if (strncmp (keyValue (copy), "foobar", 6) == 0, "keyDup: key value copy error");
    1550           2 :         succeed_if (keyIsBinary (copy), "keyDup: key type copy error");
    1551             : 
    1552             :         // Dup the key again
    1553             :         Key * ccopy;
    1554           2 :         succeed_if ((ccopy = keyDup (copy)) != 0, "keyDup failed");
    1555           2 :         compare_key (copy, ccopy);
    1556           2 :         keyDel (copy); // everything independent from original!
    1557             : 
    1558           2 :         succeed_if_same_string (keyName (ccopy), "user/foo/bar");
    1559           2 :         succeed_if (strncmp (keyValue (ccopy), "foobar", 6) == 0, "keyDup: key value ccopy error");
    1560           2 :         succeed_if (keyIsBinary (ccopy), "keyDup: key type ccopy error");
    1561             : 
    1562           2 :         keyDel (ccopy);
    1563             : 
    1564           2 :         orig = keyNew (0);
    1565           2 :         keySetName (orig, "invalid");
    1566             : 
    1567           2 :         succeed_if ((copy = keyDup (orig)) != 0, "keyDup failed");
    1568           2 :         succeed_if_same_string (keyName (orig), "");
    1569           2 :         succeed_if_same_string (keyName (copy), "");
    1570           2 :         succeed_if (keyGetNameSize (orig) == 1, "orig name size");
    1571           2 :         succeed_if (keyGetNameSize (copy) == 1, "orig name size");
    1572           2 :         succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
    1573           2 :         succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
    1574             : 
    1575           2 :         keyDel (orig);
    1576           2 :         keyDel (copy);
    1577           2 : }
    1578             : 
    1579           2 : static void test_keyCopy (void)
    1580             : {
    1581             :         Key *orig, *copy;
    1582             : 
    1583           2 :         printf ("Test key copy\n");
    1584             : 
    1585             :         // Create test key
    1586           2 :         orig = keyNew ("user:yl/foo/bar", KEY_BINARY, KEY_SIZE, 6, KEY_VALUE, "foobar", KEY_COMMENT, "mycomment", KEY_UID, 123, KEY_GID,
    1587             :                        456, KEY_MODE, 0644, KEY_END);
    1588             : 
    1589             : 
    1590             :         // Copy the key
    1591           2 :         copy = keyNew (0);
    1592           2 :         succeed_if (keyCopy (copy, orig) == 1, "keyCopy failed");
    1593           2 :         succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
    1594           2 :         succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
    1595           2 :         compare_key (orig, copy);
    1596             : 
    1597           2 :         succeed_if (keyCopy (copy, orig) == 1, "keyCopy failed");
    1598           2 :         succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
    1599           2 :         succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
    1600           2 :         compare_key (orig, copy);
    1601           2 :         keyDel (orig); // everything independent from original!
    1602             : 
    1603             :         // Check the duplication
    1604           2 :         succeed_if_same_string (keyName (copy), "user/foo/bar");
    1605           2 :         succeed_if (strncmp (keyValue (copy), "foobar", 6) == 0, "keyCopy: key value copy error");
    1606             : 
    1607           2 :         orig = keyNew (0);
    1608           2 :         succeed_if (keyCopy (copy, orig) == 1, "make a key copy of an unmodified key");
    1609           2 :         compare_key (orig, copy);
    1610             : 
    1611           2 :         succeed_if (keyCopy (copy, 0) == 0, "make the key copy fresh");
    1612           2 :         compare_key (orig, copy);
    1613           2 :         keyDel (orig);
    1614             : 
    1615           2 :         keyDel (copy);
    1616             : 
    1617           2 :         orig = keyNew (0);
    1618           2 :         keySetName (orig, "invalid");
    1619             : 
    1620           2 :         copy = keyNew (0);
    1621           2 :         succeed_if (keyCopy (copy, orig) == 1, "keyCopy failed");
    1622           2 :         succeed_if_same_string (keyName (orig), "");
    1623           2 :         succeed_if_same_string (keyName (copy), "");
    1624           2 :         succeed_if (keyGetNameSize (orig) == 1, "orig name size");
    1625           2 :         succeed_if (keyGetNameSize (copy) == 1, "orig name size");
    1626           2 :         succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
    1627           2 :         succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
    1628             : 
    1629           2 :         keyDel (orig);
    1630           2 :         keyDel (copy);
    1631             : 
    1632           2 :         orig = keyNew ("user/orig", KEY_END);
    1633           2 :         succeed_if (keyNeedSync (orig), "fresh key does not need sync?");
    1634           2 :         KeySet * ks = ksNew (20, KS_END);
    1635           2 :         ksAppendKey (ks, orig);
    1636           2 :         copy = keyNew ("user/othername", KEY_END);
    1637           2 :         succeed_if (keyNeedSync (copy), "fresh key does not need sync?");
    1638           2 :         succeed_if (keyGetRef (orig) == 1, "orig ref counter should be 1");
    1639           2 :         succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
    1640           2 :         succeed_if (keyCopy (orig, copy) == -1, "copy should not be allowed when key is already referred to");
    1641           2 :         succeed_if (keyNeedSync (orig), "copied key does not need sync?");
    1642           2 :         succeed_if (keyNeedSync (copy), "copied key does not need sync?");
    1643             : 
    1644           2 :         succeed_if (keyGetRef (orig) == 1, "orig ref counter should be 1");
    1645           2 :         succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 1");
    1646             : 
    1647           2 :         succeed_if_same_string (keyName (orig), "user/orig");
    1648           2 :         succeed_if_same_string (keyName (copy), "user/othername");
    1649             : 
    1650           2 :         keyDel (copy);
    1651           2 :         ksRewind (ks);
    1652           2 :         succeed_if_same_string (keyName (ksNext (ks)), "user/orig");
    1653           2 :         ksDel (ks);
    1654           2 : }
    1655             : 
    1656             : 
    1657             : typedef void (*fun_t) (void);
    1658           0 : static void fun (void)
    1659             : {
    1660           0 : }
    1661             : 
    1662           2 : static void test_binary (void)
    1663             : {
    1664           2 :         printf ("Test binary values\n");
    1665             : 
    1666           2 :         Key * k = 0;
    1667             : 
    1668           2 :         int i = 20;
    1669           2 :         int * p = &i;
    1670             : 
    1671           2 :         k = keyNew (0);
    1672           2 :         succeed_if (keySetBinary (k, &p, sizeof (p)) == sizeof (p), "could not set binary");
    1673             : 
    1674             :         int * q;
    1675           2 :         succeed_if (keyGetBinary (k, &q, sizeof (q)) == sizeof (q), "could not get binary");
    1676           2 :         succeed_if (p == q, "pointers to int are not equal");
    1677           2 :         succeed_if (*p == *q, "values are not equal");
    1678           2 :         succeed_if (*q == 20, "values are not equal");
    1679           2 :         succeed_if (*p == 20, "values are not equal");
    1680             : 
    1681           2 :         keyDel (k);
    1682             : 
    1683             : 
    1684             :         union
    1685             :         {
    1686             :                 void (*f) (void);
    1687             :                 void * v;
    1688             :         } conversation;
    1689             : 
    1690           2 :         k = keyNew (0);
    1691           2 :         conversation.f = fun;
    1692           2 :         succeed_if (keySetBinary (k, &conversation.v, sizeof (conversation)) == sizeof (conversation), "could not set binary");
    1693             : 
    1694           2 :         conversation.v = 0;
    1695             :         conversation.f = 0;
    1696           2 :         void (*g) (void) = 0;
    1697           2 :         succeed_if (keyGetBinary (k, &conversation.v, sizeof (conversation)) == sizeof (conversation), "could not get binary");
    1698           2 :         g = conversation.f;
    1699           2 :         succeed_if (g == fun, "pointers to functions are not equal");
    1700             : 
    1701           2 :         keyDel (k);
    1702             : 
    1703             : 
    1704           2 :         conversation.f = fun;
    1705           2 :         k = keyNew ("system/symbols/fun", KEY_BINARY, KEY_SIZE, sizeof (conversation), KEY_VALUE, &conversation.v, KEY_END);
    1706             : 
    1707           2 :         conversation.v = 0;
    1708             :         conversation.f = 0;
    1709           2 :         succeed_if (keyGetBinary (k, &conversation.v, sizeof (conversation)) == sizeof (conversation), "could not get binary");
    1710           2 :         g = conversation.f;
    1711           2 :         succeed_if (g == fun, "pointers to functions are not equal");
    1712             : 
    1713           2 :         keyDel (k);
    1714             : 
    1715             : 
    1716           2 :         fun_t tmp = fun;
    1717             : 
    1718           2 :         k = keyNew ("system/symbol/fun", KEY_BINARY, KEY_SIZE, sizeof (fun_t), KEY_VALUE, &tmp, KEY_END);
    1719             : 
    1720           2 :         fun_t myfun = 0;
    1721           2 :         succeed_if (keyGetBinary (k, &myfun, sizeof (fun_t)) == sizeof (fun_t), "could not get binary");
    1722             : 
    1723           2 :         succeed_if (fun == myfun, "pointers not equal");
    1724             : 
    1725           2 :         keyDel (k);
    1726             : 
    1727             : 
    1728           2 :         k = keyNew ("system/symbol/cool", KEY_FUNC, fun, KEY_END);
    1729             : 
    1730           2 :         succeed_if (keyGetBinary (k, &myfun, sizeof (fun_t)) == sizeof (fun_t), "could not get binary");
    1731             : 
    1732           2 :         succeed_if (fun == myfun, "pointers not equal");
    1733             : 
    1734           2 :         keyDel (k);
    1735             : 
    1736             :         char data[10];
    1737           2 :         k = keyNew ("system/empty_binary", KEY_END);
    1738           2 :         succeed_if (keySetBinary (k, 0, 0) == 0, "could not set binary will null pointer");
    1739           2 :         succeed_if (keyIsBinary (k), "key is not binary");
    1740           2 :         succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
    1741           2 :         succeed_if (keyValue (k) == 0, "did not get back null pointer");
    1742             : 
    1743           2 :         succeed_if (keySetBinary (k, 0, 1) == 0, "could not set binary will null pointer");
    1744           2 :         succeed_if (keyIsBinary (k), "key is not binary");
    1745           2 :         succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
    1746           2 :         succeed_if (keyValue (k) == 0, "did not get back null pointer");
    1747             : 
    1748           2 :         succeed_if (keySetBinary (k, 0, 5) == 0, "could not set binary will null pointer");
    1749           2 :         succeed_if (keyIsBinary (k), "key is not binary");
    1750           2 :         succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
    1751           2 :         succeed_if (keyValue (k) == 0, "did not get back null pointer");
    1752             : 
    1753           2 :         succeed_if (keySetBinary (k, 0, -1) == -1, "misusage: this will fail");
    1754           2 :         succeed_if (keyIsBinary (k), "key is not binary (should be from previous calls)");
    1755           2 :         succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
    1756           2 :         succeed_if (keyValue (k) == 0, "did not get back null pointer");
    1757           2 :         keyDel (k);
    1758           2 : }
    1759             : 
    1760           2 : static void test_keyBelowOrSame (void)
    1761             : {
    1762           2 :         Key * key1 = keyNew (0);
    1763           2 :         Key * key2 = keyNew (0);
    1764             : 
    1765           2 :         printf ("Test of keyBelowOrSame\n");
    1766             : 
    1767           2 :         succeed_if (keyIsBelowOrSame (key1, 0) == -1, "NULL pointer");
    1768           2 :         succeed_if (keyIsBelowOrSame (0, 0) == -1, "NULL pointer");
    1769           2 :         succeed_if (keyIsBelowOrSame (0, key1) == -1, "NULL pointer");
    1770             : 
    1771           2 :         keySetName (key1, "user/valid");
    1772           2 :         keySetName (key2, "user/valid");
    1773           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1774           2 :         succeed_if (keyIsBelowOrSame (key2, key1), "Key should be below");
    1775             : 
    1776           2 :         keySetName (key1, "user/valid");
    1777           2 :         keySetName (key2, "user/valid/");
    1778           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1779           2 :         succeed_if (keyIsBelowOrSame (key2, key1), "Key should be below");
    1780             : 
    1781           2 :         keySetName (key1, "user/valid");
    1782           2 :         keySetName (key2, "user/valid/below");
    1783           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1784           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1785             : 
    1786           2 :         keySetName (key1, "user/valid");
    1787           2 :         keySetName (key2, "user/valid/b");
    1788           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1789           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1790             : 
    1791           2 :         keySetName (key1, "user/valid");
    1792           2 :         keySetName (key2, "user/valid/b");
    1793           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1794           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1795             : 
    1796           2 :         keySetName (key1, "user/valid");
    1797           2 :         keySetName (key2, "user/valid/b/e");
    1798           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1799           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1800             : 
    1801           2 :         keySetName (key1, "/valid");
    1802           2 :         keySetName (key2, "/valid/b/e");
    1803           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1804           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1805             : 
    1806           2 :         keySetName (key1, "/");
    1807           2 :         keySetName (key2, "/valid/b/e");
    1808           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1809           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1810             : 
    1811           2 :         keySetName (key1, "/");
    1812           2 :         keySetName (key2, "/v");
    1813           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1814           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1815             : 
    1816           2 :         keySetName (key1, "/");
    1817           2 :         keySetName (key2, "/");
    1818           2 :         succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
    1819           2 :         succeed_if (keyIsBelowOrSame (key2, key1), "Key should be below");
    1820             : 
    1821           2 :         keySetName (key1, "user/valide");
    1822           2 :         keySetName (key2, "user/valid/e");
    1823           2 :         succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
    1824           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1825             : 
    1826           2 :         keySetName (key1, "user/valid/b");
    1827           2 :         keySetName (key2, "user/valid/e");
    1828           2 :         succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
    1829           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1830             : 
    1831           2 :         keySetName (key1, "user/export/a");
    1832           2 :         keySetName (key2, "user/export-backup/b");
    1833           2 :         succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
    1834           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1835             : 
    1836           2 :         keySetName (key1, "user/export");
    1837           2 :         keySetName (key2, "user/export-backup-2/x");
    1838           2 :         succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
    1839           2 :         succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
    1840             : 
    1841           2 :         keyDel (key1);
    1842           2 :         keyDel (key2);
    1843           2 : }
    1844             : 
    1845           2 : static void test_keyNameSpecial (void)
    1846             : {
    1847           2 :         printf ("Test special keynames\n");
    1848           2 :         Key * k = keyNew (0);
    1849           2 :         succeed_if_same_string (keyName (k), "");
    1850             : 
    1851           2 :         succeed_if (keySetName (k, "system"), "could not set key name with system");
    1852           2 :         succeed_if_same_string (keyName (k), "system");
    1853             : 
    1854           2 :         succeed_if (keySetName (k, 0) == 0, "could not set key name with 0");
    1855           2 :         succeed_if_same_string (keyName (k), "");
    1856             : 
    1857           2 :         succeed_if (keySetName (k, "system"), "could not set key name with system");
    1858           2 :         succeed_if_same_string (keyName (k), "system");
    1859             : 
    1860           2 :         succeed_if (keySetName (k, "") == 0, "could not set key name with empty string");
    1861           2 :         succeed_if_same_string (keyName (k), "");
    1862             : 
    1863           2 :         succeed_if (keySetName (k, "system"), "could not set key name with system");
    1864           2 :         succeed_if_same_string (keyName (k), "system");
    1865             : 
    1866           2 :         succeed_if (keySetName (k, "invalid") == -1, "could not set key name invalid");
    1867           2 :         succeed_if_same_string (keyName (k), "");
    1868             : 
    1869             : 
    1870           2 :         succeed_if (keySetName (k, "system/something/.."), "could not set key name with ..");
    1871           2 :         succeed_if_same_string (keyName (k), "system");
    1872             : 
    1873           2 :         succeed_if (keySetName (k, "system/something/.."), "could not set key name with ..");
    1874           2 :         succeed_if_same_string (keyName (k), "system");
    1875             : 
    1876           2 :         succeed_if (keySetName (k, "system/something/../.."), "could not set key name with ..");
    1877           2 :         succeed_if_same_string (keyName (k), "system");
    1878             : 
    1879           2 :         succeed_if (keySetName (k, "system/something/../../.."), "could not set key name with ..");
    1880           2 :         succeed_if_same_string (keyName (k), "system");
    1881             : 
    1882           2 :         succeed_if (keySetName (k, "system/something/../../../.."), "could not set key name with ..");
    1883           2 :         succeed_if_same_string (keyName (k), "system");
    1884             : 
    1885           2 :         succeed_if (keySetName (k, "system/something/../../../../.."), "could not set key name with ..");
    1886           2 :         succeed_if_same_string (keyName (k), "system");
    1887             : 
    1888             : 
    1889           2 :         succeed_if (keySetName (k, "system/../something"), "could not set key name with ..");
    1890           2 :         succeed_if_same_string (keyName (k), "system/something");
    1891             : 
    1892           2 :         succeed_if (keySetName (k, "system/../../something"), "could not set key name with ..");
    1893           2 :         succeed_if_same_string (keyName (k), "system/something");
    1894             : 
    1895           2 :         succeed_if (keySetName (k, "system/../../../something"), "could not set key name with ..");
    1896           2 :         succeed_if_same_string (keyName (k), "system/something");
    1897             : 
    1898           2 :         succeed_if (keySetName (k, "system/../../../../something"), "could not set key name with ..");
    1899           2 :         succeed_if_same_string (keyName (k), "system/something");
    1900             : 
    1901           2 :         succeed_if (keySetName (k, "system/../../../../../something"), "could not set key name with ..");
    1902           2 :         succeed_if_same_string (keyName (k), "system/something");
    1903             : 
    1904             : 
    1905           2 :         succeed_if (keySetName (k, "system/a/b/c/.."), "could not set key name with ..");
    1906           2 :         succeed_if_same_string (keyName (k), "system/a/b");
    1907             : 
    1908           2 :         succeed_if (keySetName (k, "system/a/b/c/../.."), "could not set key name with ..");
    1909           2 :         succeed_if_same_string (keyName (k), "system/a");
    1910             : 
    1911           2 :         succeed_if (keySetName (k, "system/a/b/c/../../.."), "could not set key name with ..");
    1912           2 :         succeed_if_same_string (keyName (k), "system");
    1913             : 
    1914           2 :         succeed_if (keySetName (k, "system/a/b/c/../../../.."), "could not set key name with ..");
    1915           2 :         succeed_if_same_string (keyName (k), "system");
    1916             : 
    1917           2 :         succeed_if (keySetName (k, "system/a/b/c/../../../../.."), "could not set key name with ..");
    1918           2 :         succeed_if_same_string (keyName (k), "system");
    1919             : 
    1920             : 
    1921           2 :         succeed_if (keySetName (k, "system/../a/b/c"), "could not set key name with ..");
    1922           2 :         succeed_if_same_string (keyName (k), "system/a/b/c");
    1923             : 
    1924           2 :         succeed_if (keySetName (k, "system/../../a/b/c"), "could not set key name with ..");
    1925           2 :         succeed_if_same_string (keyName (k), "system/a/b/c");
    1926             : 
    1927           2 :         succeed_if (keySetName (k, "system/../../../a/b/c"), "could not set key name with ..");
    1928           2 :         succeed_if_same_string (keyName (k), "system/a/b/c");
    1929             : 
    1930           2 :         succeed_if (keySetName (k, "system/../../../../a/b/c"), "could not set key name with ..");
    1931           2 :         succeed_if_same_string (keyName (k), "system/a/b/c");
    1932             : 
    1933           2 :         succeed_if (keySetName (k, "system/../../../../../a/b/c"), "could not set key name with ..");
    1934           2 :         succeed_if_same_string (keyName (k), "system/a/b/c");
    1935             : 
    1936             : 
    1937           2 :         keyDel (k);
    1938           2 : }
    1939             : 
    1940           2 : static void test_keyClear (void)
    1941             : {
    1942           2 :         printf ("Test clear of key\n");
    1943             : 
    1944           2 :         Key * k1 = keyNew ("system/abc", KEY_END);
    1945           2 :         succeed_if_same_string (keyName (k1), "system/abc");
    1946             : 
    1947           2 :         succeed_if (keyGetRef (k1) == 0, "New key reference");
    1948           2 :         keyIncRef (k1);
    1949           2 :         succeed_if (keyGetRef (k1) == 1, "Incremented key reference");
    1950           2 :         Key * k2 = k1; // create an alias for k1
    1951           2 :         succeed_if_same_string (keyName (k2), "system/abc");
    1952           2 :         succeed_if (keyGetRef (k1) == 1, "Incremented key reference");
    1953           2 :         succeed_if (keyGetRef (k2) == 1, "Incremented key reference");
    1954             : 
    1955           2 :         keyIncRef (k1);
    1956           2 :         Key * k3 = k1; // create an alias for k1
    1957           2 :         succeed_if_same_string (keyName (k3), "system/abc");
    1958           2 :         succeed_if (keyGetRef (k1) == 2, "Incremented key reference");
    1959           2 :         succeed_if (keyGetRef (k2) == 2, "Incremented key reference");
    1960           2 :         succeed_if (keyGetRef (k3) == 2, "Incremented key reference");
    1961             : 
    1962           2 :         keyClear (k1);
    1963           2 :         succeed_if_same_string (keyName (k1), "");
    1964           2 :         succeed_if_same_string (keyName (k2), "");
    1965           2 :         succeed_if_same_string (keyName (k3), "");
    1966             : 
    1967           2 :         keySetMeta (k1, "test_meta", "test_value");
    1968           2 :         succeed_if_same_string (keyValue (keyGetMeta (k1, "test_meta")), "test_value");
    1969           2 :         succeed_if_same_string (keyValue (keyGetMeta (k2, "test_meta")), "test_value");
    1970           2 :         succeed_if_same_string (keyValue (keyGetMeta (k3, "test_meta")), "test_value");
    1971             : 
    1972           2 :         keyClear (k2);
    1973           2 :         succeed_if (keyGetMeta (k1, "test_meta") == 0, "there should be no meta after keyClear");
    1974           2 :         succeed_if (keyGetMeta (k2, "test_meta") == 0, "there should be no meta after keyClear");
    1975           2 :         succeed_if (keyGetMeta (k3, "test_meta") == 0, "there should be no meta after keyClear");
    1976             : 
    1977           2 :         keySetString (k1, "mystring");
    1978           2 :         succeed_if_same_string (keyValue (k1), "mystring");
    1979           2 :         succeed_if_same_string (keyValue (k2), "mystring");
    1980           2 :         succeed_if_same_string (keyValue (k3), "mystring");
    1981             : 
    1982           2 :         keyClear (k3);
    1983           2 :         succeed_if_same_string (keyValue (k1), "");
    1984           2 :         succeed_if_same_string (keyValue (k2), "");
    1985           2 :         succeed_if_same_string (keyValue (k3), "");
    1986             : 
    1987           2 :         succeed_if (keyGetRef (k1) == 2, "Incremented key reference");
    1988           2 :         succeed_if (keyGetRef (k2) == 2, "Incremented key reference");
    1989           2 :         succeed_if (keyGetRef (k3) == 2, "Incremented key reference");
    1990             : 
    1991           2 :         keyDel (k3); // does nothing
    1992           2 :         keyDecRef (k3);
    1993           2 :         k3 = 0; // remove alias
    1994           2 :         succeed_if (keyGetRef (k1) == 1, "Incremented key reference");
    1995           2 :         succeed_if (keyGetRef (k2) == 1, "Incremented key reference");
    1996             : 
    1997           2 :         keyDel (k2); // does nothing
    1998           2 :         keyDecRef (k2);
    1999           2 :         k2 = 0; // remove alias
    2000           2 :         succeed_if (keyGetRef (k1) == 0, "Incremented key reference");
    2001             : 
    2002           2 :         keyDel (k1);
    2003           2 : }
    2004             : 
    2005           2 : static void test_keyBaseName (void)
    2006             : {
    2007           2 :         printf ("Test basename\n");
    2008           2 :         Key * k = keyNew ("user:yl///foo\\///bar\\/foo_bar\\/", KEY_END);
    2009           2 :         succeed_if_same_string (keyName (k), "user/foo\\//bar\\/foo_bar\\/");
    2010           2 :         succeed_if_same_string (keyBaseName (k), "bar/foo_bar/");
    2011             : 
    2012           2 :         keySetName (k, "system");
    2013           2 :         succeed_if_same_string (keyBaseName (k), "");
    2014             : 
    2015           2 :         keySetName (k, "system/valid//////");
    2016           2 :         succeed_if_same_string (keyName (k), "system/valid");
    2017           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2018             : 
    2019           2 :         keySetName (k, "system//////valid//////");
    2020           2 :         succeed_if_same_string (keyName (k), "system/valid");
    2021           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2022             : 
    2023           2 :         keySetName (k, "system///.///valid//.////");
    2024           2 :         succeed_if_same_string (keyName (k), "system/valid");
    2025           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2026             : 
    2027           2 :         keySetName (k, "user");
    2028           2 :         succeed_if_same_string (keyBaseName (k), "");
    2029             : 
    2030           2 :         keySetName (k, "user/valid//////");
    2031           2 :         succeed_if_same_string (keyName (k), "user/valid");
    2032           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2033             : 
    2034           2 :         keySetName (k, "user//////valid//////");
    2035           2 :         succeed_if_same_string (keyName (k), "user/valid");
    2036           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2037             : 
    2038           2 :         keySetName (k, "user///.///valid//.////");
    2039           2 :         succeed_if_same_string (keyName (k), "user/valid");
    2040           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2041             : 
    2042             : 
    2043           2 :         keySetName (k, "user:yl///foo\\///bar\\/foo_bar\\/");
    2044           2 :         succeed_if_same_string (keyName (k), "user/foo\\//bar\\/foo_bar\\/");
    2045           2 :         succeed_if_same_string (keyBaseName (k), "bar/foo_bar/");
    2046             : 
    2047           2 :         keySetName (k, "user//////foo_bar\\/");
    2048           2 :         succeed_if_same_string (keyName (k), "user/foo_bar\\/");
    2049           2 :         succeed_if_same_string (keyBaseName (k), "foo_bar/");
    2050             : 
    2051           2 :         keySetName (k, "user//////%");
    2052           2 :         succeed_if_same_string (keyName (k), "user/%");
    2053           2 :         succeed_if_same_string (keyBaseName (k), "");
    2054             : 
    2055           2 :         keySetName (k, "user//////\\%");
    2056           2 :         succeed_if_same_string (keyName (k), "user/\\%");
    2057           2 :         succeed_if_same_string (keyBaseName (k), "%");
    2058             : 
    2059           2 :         keySetName (k, "user//////\\\\%");
    2060           2 :         succeed_if_same_string (keyName (k), "user/\\\\%");
    2061           2 :         succeed_if_same_string (keyBaseName (k), "\\%");
    2062             : 
    2063           2 :         keySetName (k, "user//////\\\\\\%");
    2064           2 :         succeed_if_same_string (keyName (k), "user/\\\\\\%");
    2065           2 :         succeed_if_same_string (keyBaseName (k), "\\\\%");
    2066           2 :         keyDel (k);
    2067           2 : }
    2068             : 
    2069           2 : static void test_keySetBaseName (void)
    2070             : {
    2071           2 :         printf ("Test set basename\n");
    2072             : 
    2073           2 :         Key * k = keyNew (0);
    2074             : 
    2075           2 :         succeed_if (keySetBaseName (k, "abc") == -1, "invalid key");
    2076           2 :         succeed_if_same_string (keyName (k), "");
    2077           2 :         succeed_if_same_string (keyBaseName (k), "");
    2078             : 
    2079           2 :         keySetName (k, "spec");
    2080           2 :         succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
    2081           2 :         succeed_if_same_string (keyName (k), "spec");
    2082           2 :         succeed_if_same_string (keyBaseName (k), "");
    2083             : 
    2084           2 :         keySetName (k, "proc");
    2085           2 :         succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
    2086           2 :         succeed_if_same_string (keyName (k), "proc");
    2087           2 :         succeed_if_same_string (keyBaseName (k), "");
    2088             : 
    2089           2 :         keySetName (k, "dir");
    2090           2 :         succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
    2091           2 :         succeed_if_same_string (keyName (k), "dir");
    2092           2 :         succeed_if_same_string (keyBaseName (k), "");
    2093             : 
    2094           2 :         keySetName (k, "user");
    2095           2 :         succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
    2096           2 :         succeed_if_same_string (keyName (k), "user");
    2097           2 :         succeed_if_same_string (keyBaseName (k), "");
    2098             : 
    2099           2 :         keySetName (k, "system");
    2100           2 :         succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
    2101           2 :         succeed_if_same_string (keyName (k), "system");
    2102           2 :         succeed_if_same_string (keyBaseName (k), "");
    2103             : 
    2104           2 :         keySetName (k, "/");
    2105           2 :         succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
    2106           2 :         succeed_if_same_string (keyName (k), "/");
    2107           2 :         succeed_if_same_string (keyBaseName (k), "");
    2108             : 
    2109           2 :         keySetName (k, "/x");
    2110           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing single character basename of cascading key with depth 1 failed");
    2111           2 :         succeed_if_same_string (keyName (k), "/");
    2112           2 :         succeed_if_same_string (keyBaseName (k), "");
    2113             : 
    2114           2 :         keySetName (k, "/cascading");
    2115           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing basename of cascading key with depth 1 failed");
    2116           2 :         succeed_if_same_string (keyName (k), "/");
    2117           2 :         succeed_if_same_string (keyBaseName (k), "");
    2118             : 
    2119           2 :         keySetName (k, "system/notCascading");
    2120           2 :         succeed_if (keySetBaseName (k, 0) >= 0, "removing basename of non cascading key with depth 1 failed");
    2121           2 :         succeed_if_same_string (keyName (k), "system");
    2122           2 :         succeed_if_same_string (keyBaseName (k), "");
    2123             : 
    2124           2 :         keySetName (k, "system/foo/bar");
    2125           2 :         succeed_if (keySetBaseName (k, 0) >= 0, "removing basename of non cascading key with depth 2 failed");
    2126           2 :         succeed_if_same_string (keyName (k), "system/foo");
    2127           2 :         succeed_if_same_string (keyBaseName (k), "foo");
    2128           2 :         succeed_if (keySetBaseName (k, 0) >= 0, "second removing basename of non cascading key with depth 2 failed");
    2129           2 :         succeed_if_same_string (keyName (k), "system");
    2130           2 :         succeed_if_same_string (keyBaseName (k), "");
    2131             : 
    2132           2 :         keySetName (k, "/foo/bar");
    2133           2 :         succeed_if (keySetBaseName (k, 0) >= 0, "removing basename of cascading key with depth 2 failed");
    2134           2 :         succeed_if_same_string (keyName (k), "/foo");
    2135           2 :         succeed_if_same_string (keyBaseName (k), "foo");
    2136           2 :         succeed_if (keySetBaseName (k, 0) == 2, "second removing basename of cascading key with depth 2 failed");
    2137           2 :         succeed_if_same_string (keyName (k), "/");
    2138           2 :         succeed_if_same_string (keyBaseName (k), "");
    2139           2 :         succeed_if (keySetBaseName (k, 0) == -1, "third removing basename of cascading key with depth 2 was possible");
    2140           2 :         succeed_if_same_string (keyName (k), "/");
    2141           2 :         succeed_if_same_string (keyBaseName (k), "");
    2142             : 
    2143           2 :         keySetName (k, "/\\/");
    2144           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing basename of single character escaped cascading key with depth 1 failed");
    2145           2 :         succeed_if_same_string (keyName (k), "/");
    2146           2 :         succeed_if_same_string (keyBaseName (k), "");
    2147             : 
    2148           2 :         keySetName (k, "/\\.");
    2149           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing basename of single character escaped dot cascading key with depth 1 failed");
    2150           2 :         succeed_if_same_string (keyName (k), "/");
    2151           2 :         succeed_if_same_string (keyBaseName (k), "");
    2152             : 
    2153           2 :         keySetName (k, "/\\..");
    2154           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing basename of escaped dot dot cascading key with depth 1 failed");
    2155           2 :         succeed_if_same_string (keyName (k), "/");
    2156           2 :         succeed_if_same_string (keyBaseName (k), "");
    2157             : 
    2158           2 :         keySetName (k, "/\\%");
    2159           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing basename of single character escaped % cascading key with depth 1 failed");
    2160           2 :         succeed_if_same_string (keyName (k), "/");
    2161           2 :         succeed_if_same_string (keyBaseName (k), "");
    2162             : 
    2163           2 :         keySetName (k, "/#_1");
    2164           2 :         succeed_if (keySetBaseName (k, 0) == 2, "removing basename of array cascading key with depth 1 failed");
    2165           2 :         succeed_if_same_string (keyName (k), "/");
    2166           2 :         succeed_if_same_string (keyBaseName (k), "");
    2167             : 
    2168           2 :         keySetName (k, "system");
    2169           2 :         succeed_if (keySetBaseName (k, "valid") == -1, "add root name, but set was used");
    2170           2 :         succeed_if_same_string (keyName (k), "system");
    2171           2 :         succeed_if_same_string (keyBaseName (k), "");
    2172             : 
    2173           2 :         keySetName (k, "proc");
    2174           2 :         succeed_if (keySetBaseName (k, "a") == -1, "add root name, but set was used");
    2175           2 :         succeed_if_same_string (keyName (k), "proc");
    2176           2 :         succeed_if_same_string (keyBaseName (k), "");
    2177             : 
    2178           2 :         keySetName (k, "system/valid");
    2179           2 :         succeed_if (keySetBaseName (k, 0) == sizeof ("system"), "could not remove base name");
    2180           2 :         succeed_if_same_string (keyName (k), "system");
    2181           2 :         succeed_if_same_string (keyBaseName (k), "");
    2182             : 
    2183           2 :         keySetName (k, "system/valid");
    2184           2 :         succeed_if (keySetBaseName (k, "") > 0, "could not set empty name");
    2185           2 :         succeed_if_same_string (keyName (k), "system/%"); // is an empty name
    2186           2 :         succeed_if_same_string (keyBaseName (k), "");
    2187             : 
    2188           2 :         keySetName (k, "system/valid");
    2189           2 :         succeed_if (keySetBaseName (k, "a") >= 0, "escaped slash ok");
    2190           2 :         succeed_if_same_string (keyName (k), "system/a");
    2191           2 :         succeed_if_same_string (keyBaseName (k), "a");
    2192             : 
    2193           2 :         keySetName (k, "system/valid");
    2194           2 :         succeed_if (keySetBaseName (k, "/") >= 0, "escaped slash ok");
    2195           2 :         succeed_if_same_string (keyName (k), "system/\\/");
    2196           2 :         succeed_if_same_string (keyBaseName (k), "/");
    2197             : 
    2198           2 :         keySetName (k, "system/valid");
    2199           2 :         succeed_if (keySetBaseName (k, "\\/") >= 0, "escaped slash ok");
    2200           2 :         succeed_if_same_string (keyName (k), "system/\\\\\\/");
    2201           2 :         succeed_if_same_string (keyBaseName (k), "\\/");
    2202             : 
    2203           2 :         keySetName (k, "system/valid");
    2204           2 :         succeed_if (keySetBaseName (k, "\\\\/") >= 0, "backslash escaped, but slash unescaped");
    2205           2 :         succeed_if_same_string (keyName (k), "system/\\\\\\\\\\/");
    2206           2 :         succeed_if_same_string (keyBaseName (k), "\\\\/");
    2207             : 
    2208           2 :         keySetName (k, "system/valid");
    2209           2 :         succeed_if (keySetBaseName (k, "\\\\\\/") >= 0, "backslash escaped, slash escaped");
    2210           2 :         succeed_if_same_string (keyName (k), "system/\\\\\\\\\\\\\\/");
    2211           2 :         succeed_if_same_string (keyBaseName (k), "\\\\\\/");
    2212             : 
    2213           2 :         keySetName (k, "system/valid");
    2214           2 :         succeed_if (keySetBaseName (k, "%") == sizeof ("system/\\%"), "could not set basename");
    2215           2 :         succeed_if_same_string (keyBaseName (k), "%");
    2216           2 :         succeed_if_same_string (keyName (k), "system/\\%");
    2217           2 :         succeed_if_same_string (keyBaseName (k), "%");
    2218             : 
    2219           2 :         keySetName (k, "system/valid");
    2220           2 :         succeed_if (keySetBaseName (k, ".") == sizeof ("system/\\%"), "could not set basename");
    2221           2 :         succeed_if_same_string (keyBaseName (k), ".");
    2222           2 :         succeed_if_same_string (keyName (k), "system/\\.");
    2223           2 :         succeed_if_same_string (keyBaseName (k), ".");
    2224             : 
    2225           2 :         keySetName (k, "system/valid");
    2226           2 :         succeed_if (keySetBaseName (k, "..") == sizeof ("system/\\.."), "could not set basename");
    2227           2 :         succeed_if_same_string (keyBaseName (k), "..");
    2228           2 :         succeed_if_same_string (keyName (k), "system/\\..");
    2229           2 :         succeed_if_same_string (keyBaseName (k), "..");
    2230             : 
    2231           2 :         keySetName (k, "system/valid");
    2232           2 :         succeed_if (keySetBaseName (k, "\\\\\\\\") >= 0, "backslash escaped, backslash escaped");
    2233           2 :         succeed_if_same_string (keyName (k), "system/\\\\\\\\\\\\\\\\");
    2234           2 :         succeed_if_same_string (keyBaseName (k), "\\\\\\\\");
    2235             : 
    2236           2 :         keySetName (k, "system/valid");
    2237           2 :         succeed_if (keySetBaseName (k, "\\\\") >= 0, "escaped backslash ok");
    2238           2 :         succeed_if_same_string (keyName (k), "system/\\\\\\\\");
    2239           2 :         succeed_if_same_string (keyBaseName (k), "\\\\");
    2240             : 
    2241           2 :         keySetName (k, "system/valid");
    2242           2 :         succeed_if (keySetBaseName (k, "\\.") >= 0, "escaped dot");
    2243           2 :         succeed_if_same_string (keyName (k), "system/\\\\.");
    2244           2 :         succeed_if_same_string (keyBaseName (k), "\\.");
    2245             : 
    2246           2 :         keySetName (k, "system/valid");
    2247           2 :         succeed_if (keySetBaseName (k, "\\..") >= 0, "escaped dot-dot");
    2248           2 :         succeed_if_same_string (keyName (k), "system/\\\\..");
    2249           2 :         succeed_if_same_string (keyBaseName (k), "\\..");
    2250             : 
    2251           2 :         keySetName (k, "system/valid");
    2252           2 :         succeed_if (keySetBaseName (k, "%") == sizeof ("system/\\%"), "add some char");
    2253           2 :         succeed_if_same_string (keyName (k), "system/\\%");
    2254           2 :         succeed_if_same_string (keyBaseName (k), "%");
    2255             : 
    2256           2 :         keySetName (k, "system/valid");
    2257           2 :         succeed_if (keySetBaseName (k, "#1") == sizeof ("system/#1"), "valid array entry");
    2258           2 :         succeed_if_same_string (keyName (k), "system/#1");
    2259           2 :         succeed_if_same_string (keyBaseName (k), "#1");
    2260             : 
    2261           2 :         keySetName (k, "system/valid");
    2262           2 :         succeed_if (keySetBaseName (k, "#_10") >= 0, "valid array entry");
    2263           2 :         succeed_if_same_string (keyName (k), "system/#_10");
    2264           2 :         succeed_if_same_string (keyBaseName (k), "#_10");
    2265             : 
    2266           2 :         keySetName (k, "user/tests/yajl/___empty_map");
    2267           2 :         succeed_if_same_string (keyBaseName (k), "___empty_map");
    2268           2 :         keySetBaseName (k, "#0");
    2269           2 :         succeed_if_same_string (keyBaseName (k), "#0");
    2270             : 
    2271           2 :         keySetBaseName (k, "nullkey");
    2272           2 :         succeed_if_same_string (keyBaseName (k), "nullkey");
    2273           2 :         succeed_if_same_string (keyName (k), "user/tests/yajl/nullkey");
    2274             : 
    2275             :         //! [base1]
    2276           2 :         keySetName (k, "system/valid");
    2277           2 :         keySetBaseName (k, ".hiddenkey");
    2278           2 :         succeed_if_same_string (keyName (k), "system/.hiddenkey");
    2279           2 :         succeed_if_same_string (keyBaseName (k), ".hiddenkey");
    2280             :         //! [base1]
    2281             : 
    2282             :         //! [base2]
    2283           2 :         keySetName (k, "system/valid");
    2284           2 :         keySetBaseName (k, "");
    2285           2 :         succeed_if_same_string (keyName (k), "system/%");
    2286           2 :         succeed_if_same_string (keyBaseName (k), "");
    2287             :         //! [base2]
    2288             : 
    2289             :         //! [base3]
    2290           2 :         keySetName (k, "system/valid");
    2291           2 :         keySetBaseName (k, "%");
    2292           2 :         succeed_if_same_string (keyName (k), "system/\\%");
    2293           2 :         succeed_if_same_string (keyBaseName (k), "%");
    2294             :         //! [base3]
    2295             : 
    2296           2 :         keyDel (k);
    2297           2 : }
    2298             : 
    2299           2 : static void test_keyAddBaseName (void)
    2300             : {
    2301           2 :         printf ("Test add basename\n");
    2302             : 
    2303           2 :         Key * k = keyNew (0);
    2304             : 
    2305             :         //![base0 empty]
    2306           2 :         keySetName (k, "");
    2307           2 :         succeed_if_same_string (keyBaseName (k), "");
    2308           2 :         keySetName (k, "user");
    2309           2 :         succeed_if_same_string (keyBaseName (k), "");
    2310             :         //![base0 empty]
    2311             : 
    2312             :         //![base1 empty]
    2313           2 :         keySetName (k, "system/valid");
    2314           2 :         succeed_if (keyAddBaseName (k, "") >= 0, "could not add a base name");
    2315           2 :         succeed_if_same_string (keyName (k), "system/valid/%");
    2316           2 :         succeed_if_same_string (keyBaseName (k), "");
    2317             :         //![base1 empty]
    2318             : 
    2319           2 :         keySetName (k, "system/valid");
    2320           2 :         succeed_if (keyAddBaseName (k, "%") >= 0, "could not add a base name");
    2321           2 :         succeed_if_same_string (keyName (k), "system/valid/\\%");
    2322           2 :         succeed_if_same_string (keyBaseName (k), "%");
    2323             : 
    2324           2 :         keySetName (k, "system/valid");
    2325           2 :         succeed_if (keyAddBaseName (k, "#") == sizeof ("system/valid/#"), "could not add a base name");
    2326           2 :         succeed_if_same_string (keyName (k), "system/valid/#");
    2327           2 :         succeed_if_same_string (keyBaseName (k), "#");
    2328             : 
    2329           2 :         keySetName (k, "system/valid");
    2330           2 :         succeed_if (keyAddBaseName (k, "#_2") >= 0, "could not add a base name");
    2331           2 :         succeed_if_same_string (keyName (k), "system/valid/#_2");
    2332           2 :         succeed_if_same_string (keyBaseName (k), "#_2");
    2333             : 
    2334             :         //![base1 add]
    2335           2 :         keySetName (k, "system/valid");
    2336           2 :         succeed_if (keyAddBaseName (k, ".") >= 0, "could not add a base name");
    2337           2 :         succeed_if_same_string (keyName (k), "system/valid/\\.");
    2338           2 :         succeed_if_same_string (keyBaseName (k), ".");
    2339             :         //![base1 add]
    2340             : 
    2341           2 :         keySetName (k, "system/valid");
    2342           2 :         succeed_if (keyAddBaseName (k, "..") >= 0, "could not add a base name");
    2343           2 :         succeed_if_same_string (keyName (k), "system/valid/\\..");
    2344           2 :         succeed_if_same_string (keyBaseName (k), "..");
    2345             : 
    2346             : 
    2347           2 :         keySetName (k, "system/valid");
    2348           2 :         succeed_if (keyAddBaseName (k, "hello%#") >= 0, "could not add a base name");
    2349           2 :         succeed_if_same_string (keyName (k), "system/valid/hello%#");
    2350           2 :         succeed_if_same_string (keyBaseName (k), "hello%#");
    2351             : 
    2352           2 :         keySetName (k, "system/valid");
    2353           2 :         succeed_if (keyAddBaseName (k, "hello..") >= 0, "could not add a base name");
    2354           2 :         succeed_if_same_string (keyName (k), "system/valid/hello..");
    2355           2 :         succeed_if_same_string (keyBaseName (k), "hello..");
    2356             : 
    2357           2 :         keySetName (k, "system/valid");
    2358           2 :         succeed_if (keyAddBaseName (k, "..hello..") >= 0, "could not add a base name");
    2359           2 :         succeed_if_same_string (keyName (k), "system/valid/..hello..");
    2360           2 :         succeed_if_same_string (keyBaseName (k), "..hello..");
    2361             : 
    2362           2 :         keySetName (k, "system/valid");
    2363           2 :         succeed_if (keyAddBaseName (k, "has/slash") >= 0, "could not add a base name");
    2364           2 :         succeed_if_same_string (keyName (k), "system/valid/has\\/slash");
    2365           2 :         succeed_if_same_string (keyBaseName (k), "has/slash");
    2366             : 
    2367           2 :         keySetName (k, "system/valid");
    2368           2 :         keyAddBaseName (k, "#0");
    2369           2 :         succeed_if_same_string (keyName (k), "system/valid/#0");
    2370           2 :         succeed_if_same_string (keyBaseName (k), "#0");
    2371             : 
    2372           2 :         keyDel (k);
    2373           2 : }
    2374             : 
    2375           2 : static void test_keyDirectBelow (void)
    2376             : {
    2377           2 :         printf ("Test direct below check\n");
    2378             : 
    2379           2 :         Key * k1 = keyNew ("/dir", KEY_CASCADING_NAME, KEY_END);
    2380           2 :         Key * k2 = keyNew ("/dir/directbelow", KEY_CASCADING_NAME, KEY_END);
    2381           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2382             : 
    2383           2 :         keySetName (k1, "user/dir");
    2384           2 :         keySetName (k2, "user/dir/directbelow");
    2385           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2386             : 
    2387           2 :         keySetName (k1, "user/dir");
    2388           2 :         keySetName (k2, "user/dir/direct\\/below");
    2389           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2390             : 
    2391           2 :         keySetName (k1, "user/dir");
    2392           2 :         keySetName (k2, "user/dir/direct\\/");
    2393           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2394             : 
    2395           2 :         keySetName (k1, "user/dir");
    2396           2 :         succeed_if (keySetName (k2, "user/dir/direct\\\\") > -1, "could not set correct name");
    2397           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2398             : 
    2399           2 :         keySetName (k1, "user/dir");
    2400           2 :         succeed_if (keySetName (k2, "user/dir/direct\\") == -1, "could set incorrect name");
    2401           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 0, "invalid name: should not be direct below");
    2402             : 
    2403           2 :         keySetName (k1, "user/dir");
    2404           2 :         keySetName (k2, "user/dir/direct\\\\\\/below");
    2405           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2406             : 
    2407           2 :         keySetName (k1, "user/dir");
    2408           2 :         keySetName (k2, "user/dir/direct\\\\below");
    2409           2 :         succeed_if (keyIsBelow (k1, k2) == 1, "below");
    2410           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
    2411             : 
    2412           2 :         keySetName (k1, "user/dir");
    2413           2 :         keySetName (k2, "user/dir/direct\\\\/b");
    2414           2 :         succeed_if_same_string (keyName (k2), "user/dir/direct\\\\/b");
    2415           2 :         succeed_if (keyIsBelow (k1, k2) == 1, "below");
    2416           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 0, "direct below, but shouldnt be");
    2417             : 
    2418           2 :         keySetName (k1, "user/dir");
    2419           2 :         keySetName (k2, "user/dir/direct\\\\/below");
    2420           2 :         succeed_if (keyIsBelow (k1, k2) == 1, "below");
    2421           2 :         succeed_if (keyIsDirectBelow (k1, k2) == 0, "direct below, but shouldnt be");
    2422             : 
    2423           2 :         keyDel (k1);
    2424           2 :         keyDel (k2);
    2425           2 : }
    2426             : 
    2427           2 : static void test_keyEscape (void)
    2428             : {
    2429           2 :         printf ("test escape in basename\n");
    2430             : 
    2431           2 :         Key * k = keyNew ("/valid", KEY_END);
    2432             :         char buffer[500];
    2433             : 
    2434             : #define TEST_ESCAPE_PART(A, S)                                                                                                             \
    2435             :         do                                                                                                                                 \
    2436             :         {                                                                                                                                  \
    2437             :                 succeed_if (keySetBaseName (k, A) != -1, "keySetBaseName returned an error");                                              \
    2438             :                 succeed_if_same_string (keyBaseName (k), A);                                                                               \
    2439             :                 succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName returned an error");                                    \
    2440             :                 succeed_if_same_string (buffer, A);                                                                                        \
    2441             :         } while (0)
    2442             : 
    2443             : #include <data_escape.c>
    2444             : 
    2445           2 :         keySetName (k, "spec/valid");
    2446             : 
    2447             : #include <data_escape.c>
    2448             : 
    2449           2 :         keySetName (k, "proc/valid");
    2450             : 
    2451             : #include <data_escape.c>
    2452             : 
    2453           2 :         keySetName (k, "dir/valid");
    2454             : 
    2455             : #include <data_escape.c>
    2456             : 
    2457           2 :         keySetName (k, "user/valid");
    2458             : 
    2459             : #include <data_escape.c>
    2460             : 
    2461           2 :         keySetName (k, "system/valid");
    2462             : 
    2463             : #include <data_escape.c>
    2464             : 
    2465             : #undef TEST_ESCAPE_PART
    2466             : #define TEST_ESCAPE_PART(A, S)                                                                                                             \
    2467             :         do                                                                                                                                 \
    2468             :         {                                                                                                                                  \
    2469             :                 succeed_if (keySetBaseName (k, A) == -1, "keySetBaseName should have returned an error");                                  \
    2470             :                 succeed_if_same_string (keyBaseName (k), "");                                                                              \
    2471             :                 succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName returned an error");                                    \
    2472             :                 succeed_if_same_string (buffer, "");                                                                                       \
    2473             :         } while (0)
    2474             : 
    2475          12 :         for (int i = 0; i < NUMBER_OF_NAMESPACES; ++i)
    2476             :         {
    2477          12 :                 keySetName (k, namespaces[i]);
    2478             : 
    2479             : #include <data_escape.c>
    2480             :         }
    2481             : 
    2482           2 :         keySetName (k, "/");
    2483           2 :         succeed_if (keyAddBaseName (k, "valid") != -1, "keyAddBaseName returned an error");
    2484           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2485           2 :         succeed_if_same_string (keyName (k), "/valid");
    2486             : 
    2487             : 
    2488             : // generates huge key (but fits within 500)
    2489             : #undef TEST_ESCAPE_PART
    2490             : #define TEST_ESCAPE_PART(A, S)                                                                                                             \
    2491             :         do                                                                                                                                 \
    2492             :         {                                                                                                                                  \
    2493             :                 succeed_if (keyAddBaseName (k, A) != -1, "keyAddBaseName returned an error");                                              \
    2494             :                 succeed_if_same_string (keyBaseName (k), A);                                                                               \
    2495             :                 succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName (for keyAddBaseName) returned an error");               \
    2496             :                 succeed_if_same_string (buffer, A);                                                                                        \
    2497             :         } while (0)
    2498             : 
    2499          12 :         for (int i = 0; i < NUMBER_OF_NAMESPACES; ++i)
    2500             :         {
    2501          12 :                 keySetName (k, namespaces[i]);
    2502             : 
    2503             : #include <data_escape.c>
    2504             :         }
    2505             : 
    2506           2 :         keyDel (k);
    2507           2 : }
    2508             : 
    2509           2 : static void test_keyAdd (void)
    2510             : {
    2511           2 :         printf ("test keyAdd\n");
    2512             : 
    2513           2 :         Key * k = keyNew ("", KEY_END);
    2514           2 :         succeed_if (keyAddName (0, "valid") == -1, "cannot add to null name");
    2515           2 :         succeed_if (keyAddName (k, "valid") == -1, "added to empty name?");
    2516             : 
    2517           2 :         keySetName (k, "/");
    2518           2 :         succeed_if (keyAddName (k, 0) == 0, "cannot add null pointer");
    2519           2 :         succeed_if (keyAddName (k, "") == 0, "cannot add empty name");
    2520           2 :         succeed_if (keyAddName (k, "/") == 0, "cannot add slashes");
    2521           2 :         succeed_if (keyAddName (k, "//") == 0, "cannot add slashes");
    2522           2 :         succeed_if (keyAddName (k, "////") == 0, "cannot add slashes");
    2523           2 :         succeed_if (keyAddName (k, "invalid\\") == -1, "added invalid name");
    2524           2 :         succeed_if (keyAddName (k, "valid") == sizeof ("/valid"), "added valid name");
    2525             : 
    2526           2 :         keySetName (k, "user");
    2527           2 :         succeed_if (keyAddName (k, 0) == 0, "cannot add null pointer");
    2528           2 :         succeed_if (keyAddName (k, "") == 0, "cannot add empty name");
    2529           2 :         succeed_if (keyAddName (k, "/") == 0, "cannot add slashes");
    2530           2 :         succeed_if (keyAddName (k, "//") == 0, "cannot add slashes");
    2531           2 :         succeed_if (keyAddName (k, "////") == 0, "cannot add slashes");
    2532           2 :         succeed_if (keyAddName (k, "invalid\\") == -1, "added invalid name");
    2533           2 :         succeed_if (keyAddName (k, "valid") == sizeof ("user/valid"), "added valid name");
    2534             : 
    2535             : #undef TEST_NOESCAPE_PART
    2536             : #define TEST_NOESCAPE_PART(A, S)                                                                                                           \
    2537             :         do                                                                                                                                 \
    2538             :         {                                                                                                                                  \
    2539             :                 succeed_if (keyAddName (k, A) != -1, "keyAddName returned an error");                                                      \
    2540             :                 succeed_if_same_string (keyBaseName (k), S);                                                                               \
    2541             :                 succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName returned an error");                                    \
    2542             :                 succeed_if_same_string (buffer, S);                                                                                        \
    2543             :         } while (0)
    2544             :         char buffer[500];
    2545             : 
    2546          12 :         for (int i = 0; i < NUMBER_OF_NAMESPACES; ++i)
    2547             :         {
    2548          12 :                 keySetName (k, namespaces[i]);
    2549             : 
    2550             : #include <data_noescape.c>
    2551             :         }
    2552             : 
    2553           2 :         keyDel (k);
    2554           2 : }
    2555             : 
    2556           2 : void test_keyCascading (void)
    2557             : {
    2558           2 :         printf ("test cascading\n");
    2559             : 
    2560           2 :         Key * k = keyNew ("/", KEY_END);
    2561           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2562           2 :         succeed_if_same_string (keyName (k), "/");
    2563           2 :         succeed_if_same_string (keyBaseName (k), "");
    2564             : 
    2565           2 :         succeed_if (keyAddName (k, "valid") > 0, "could not add valid");
    2566           2 :         succeed_if (keyGetNameSize (k) == 7, "size not correct");
    2567           2 :         succeed_if_same_string (keyName (k), "/valid");
    2568           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2569             : 
    2570           2 :         keySetName (k, "/");
    2571           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2572           2 :         succeed_if (keyAddName (k, "/valid") == 7, "could not add valid with starting slash");
    2573           2 :         succeed_if (keyGetNameSize (k) == 7, "size not correct");
    2574           2 :         succeed_if_same_string (keyName (k), "/valid");
    2575           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2576             : 
    2577           2 :         keySetName (k, "////");
    2578           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2579           2 :         succeed_if (keyAddName (k, "/////valid") == 7, "could not add valid with starting slash");
    2580           2 :         succeed_if (keyGetNameSize (k) == 7, "size not correct");
    2581           2 :         succeed_if_same_string (keyName (k), "/valid");
    2582           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2583             : 
    2584           2 :         keySetName (k, "/");
    2585           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2586           2 :         succeed_if (keyAddName (k, "/////more/valid") > 0, "could not add valid with starting slash");
    2587           2 :         succeed_if_same_string (keyName (k), "/more/valid");
    2588           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2589             : 
    2590           2 :         keySetName (k, "/");
    2591           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2592           2 :         succeed_if (keyAddName (k, "/////./valid") == 7, "could not add valid with starting slash");
    2593           2 :         succeed_if (keyGetNameSize (k) == 7, "size not correct");
    2594           2 :         succeed_if_same_string (keyName (k), "/valid");
    2595           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2596             : 
    2597           2 :         keySetName (k, "/");
    2598           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2599           2 :         succeed_if (keyAddName (k, "/////more/../valid") == 7, "could not add valid with ..");
    2600           2 :         succeed_if (keyGetNameSize (k) == 7, "size not correct");
    2601           2 :         succeed_if_same_string (keyName (k), "/valid");
    2602           2 :         succeed_if_same_string (keyBaseName (k), "valid");
    2603             : 
    2604           2 :         keySetName (k, "/");
    2605           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2606           2 :         succeed_if (keyAddName (k, "/////..") == 0, "try to substract root with ..");
    2607           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2608           2 :         succeed_if_same_string (keyName (k), "/");
    2609           2 :         succeed_if_same_string (keyBaseName (k), "");
    2610             : 
    2611           2 :         keySetName (k, "/");
    2612           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2613           2 :         succeed_if (keyAddName (k, "/////../more") == sizeof ("/more"), "try to substract root with ..");
    2614           2 :         succeed_if (keyGetNameSize (k) == sizeof ("/more"), "size not correct");
    2615           2 :         succeed_if_same_string (keyName (k), "/more");
    2616           2 :         succeed_if_same_string (keyBaseName (k), "more");
    2617             : 
    2618             : 
    2619           2 :         keySetName (k, "/");
    2620           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2621           2 :         succeed_if (keyAddName (k, "/////more/..") == 0, "could not add nothing with ..");
    2622           2 :         succeed_if (keyGetNameSize (k) == 2, "size not correct");
    2623           2 :         succeed_if_same_string (keyName (k), "/");
    2624           2 :         succeed_if_same_string (keyBaseName (k), "");
    2625             : 
    2626             : 
    2627           2 :         keySetName (k, "/");
    2628           2 :         succeed_if (keyAddName (k, "/is//../a//../complex/..///.") == 0, "could not add complex stuff");
    2629           2 :         succeed_if_same_string (keyName (k), "/");
    2630           2 :         succeed_if_same_string (keyBaseName (k), "");
    2631             : 
    2632             :         // printf ("%s\n", keyName(k));
    2633             : 
    2634           2 :         keyDel (k);
    2635           2 : }
    2636             : 
    2637           2 : static void test_keyUnescapedName (void)
    2638             : {
    2639           2 :         printf ("test keyUnescapedName\n");
    2640             : 
    2641           2 :         Key * k = keyNew ("user/something", KEY_END);
    2642           2 :         succeed_if (!memcmp (keyUnescapedName (k), "user\0something", sizeof ("user/something")), "unescaped name wrong");
    2643             : 
    2644           2 :         keySetName (k, "/something/else");
    2645           2 :         succeed_if (!memcmp (keyUnescapedName (k), "\0something\0else", sizeof ("/something/else")), "unescaped cascading name wrong");
    2646             : 
    2647           2 :         keySetName (k, "/\\/other/more");
    2648           2 :         succeed_if (!memcmp (keyUnescapedName (k), "\0/other\0more", sizeof ("\0/other\0more")), "unescaped cascading name wrong");
    2649             : 
    2650           2 :         keySetName (k, "/\\/other/\\/more");
    2651           2 :         succeed_if (!memcmp (keyUnescapedName (k), "\0/other\0/more", sizeof ("\0/other\0/more")), "unescaped cascading name wrong");
    2652             : 
    2653           2 :         keySetName (k, "system/something/else");
    2654           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else", sizeof ("system/something/else")), "unescaped name wrong");
    2655             : 
    2656           2 :         keyAddBaseName (k, "more");
    2657           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0more", sizeof ("system/something/else/more")),
    2658             :                     "unescaped name wrong");
    2659             : 
    2660           2 :         keySetBaseName (k, "else");
    2661           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0else", sizeof ("system/something/else/else")),
    2662             :                     "unescaped name wrong");
    2663             : 
    2664           2 :         keySetBaseName (k, "");
    2665           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0\0", sizeof ("system/something/else/")),
    2666             :                     "unescaped name wrong");
    2667             : 
    2668           2 :         keySetBaseName (k, "%");
    2669           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0%", sizeof ("system/something/else/%")),
    2670             :                     "unescaped name wrong");
    2671             : 
    2672           2 :         keySetBaseName (k, "\\");
    2673           2 :         succeed_if_same_string (keyBaseName (k), "\\");
    2674           2 :         char sol1[] = "system\0something\0else\0\\";
    2675           2 :         succeed_if (!memcmp (keyUnescapedName (k), sol1, sizeof (sol1)), "unescaped name wrong");
    2676             : 
    2677             :         /* print memory of keyUnescapedName
    2678             :         for (size_t i = 0; i<sizeof(sol1); ++i)
    2679             :         {
    2680             :                 printf ("%c %d\n", (char)((char*)keyUnescapedName(k))[i], (int)((char*)keyUnescapedName(k))[i]);
    2681             :         }
    2682             :         */
    2683             : 
    2684           2 :         keySetBaseName (k, "\\\\");
    2685           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0\\\\", sizeof ("system/something/else/\\\\")),
    2686             :                     "unescaped name wrong");
    2687             : 
    2688           2 :         keySetName (k, "system/something\\/else");
    2689           2 :         succeed_if (!memcmp (keyUnescapedName (k), "system\0something/else", sizeof ("system/something/else")), "unescaped name wrong");
    2690             : 
    2691           2 :         succeed_if (keySetName (k, "system/something/else/\\") == -1, "tangling backslash");
    2692             : 
    2693           2 :         keySetName (k, "system/something/else/\\\\");
    2694           2 :         char sol2[] = "system\0something\0else\0\\";
    2695           2 :         succeed_if (!memcmp (keyUnescapedName (k), sol2, sizeof (sol2)), "unescaped name wrong");
    2696             :         /*
    2697             :         for (size_t i = 0; i<sizeof(sol2); ++i)
    2698             :         {
    2699             :                 printf ("%c %d\n", (char)((char*)keyUnescapedName(k))[i], (int)((char*)keyUnescapedName(k))[i]);
    2700             :         }
    2701             :         */
    2702             : 
    2703           2 :         keyDel (k);
    2704           2 : }
    2705             : 
    2706           2 : static void test_keyCanonify (void)
    2707             : {
    2708           2 :         printf ("test canonify\n");
    2709             : 
    2710           2 :         Key * k = keyNew ("/a/very/long/#0/name\\/with/sec\\tion/and\\\\/subsection/and!/$%&/chars()/[about]/{some}/_-.,;:/€/»/|/key",
    2711             :                           KEY_CASCADING_NAME, KEY_END);
    2712           2 :         succeed_if_same_string (
    2713             :                 keyName (k), "/a/very/long/#0/name\\/with/sec\\tion/and\\\\/subsection/and!/$%&/chars()/[about]/{some}/_-.,;:/€/»/|/key");
    2714           2 :         succeed_if (keyGetNameSize (k) == 105, "name size wrong");
    2715           2 :         succeed_if (keyGetUnescapedNameSize (k) == 103, "unescaped name size wrong");
    2716           2 :         succeed_if_same_string ((char *) keyUnescapedName (k), "");
    2717           2 :         succeed_if_same_string ((char *) keyUnescapedName (k) + 1, "a");
    2718           2 :         succeed_if_same_string ((char *) keyUnescapedName (k) + 3, "very");
    2719           2 :         succeed_if_same_string ((char *) keyUnescapedName (k) + 99, "key");
    2720             : 
    2721           2 :         keyDel (k);
    2722           2 : }
    2723             : 
    2724           2 : int main (int argc, char ** argv)
    2725             : {
    2726           2 :         printf ("KEY ABI  TESTS\n");
    2727           2 :         printf ("==================\n\n");
    2728             : 
    2729           2 :         init (argc, argv);
    2730             : 
    2731           2 :         test_keyNewSpecial ();
    2732           2 :         test_keyNewSystem ();
    2733           2 :         test_keyNewUser ();
    2734           2 :         test_keyReference ();
    2735           2 :         test_keyName ();
    2736           2 :         test_keyNameSlashes ();
    2737           2 :         test_keyValue ();
    2738           2 :         test_keyBinary ();
    2739           2 :         test_keyInactive ();
    2740           2 :         test_keyBelow ();
    2741           2 :         test_keyDup ();
    2742           2 :         test_keyCopy ();
    2743           2 :         test_binary ();
    2744           2 :         test_keyBelowOrSame ();
    2745           2 :         test_keyNameSpecial ();
    2746           2 :         test_keyClear ();
    2747           2 :         test_keyBaseName ();
    2748           2 :         test_keySetBaseName ();
    2749           2 :         test_keyAddBaseName ();
    2750           2 :         test_keyDirectBelow ();
    2751           2 :         test_keyEscape ();
    2752           2 :         test_keyAdd ();
    2753           2 :         test_keyCascading ();
    2754           2 :         test_keyUnescapedName ();
    2755           2 :         test_keyCanonify ();
    2756             : 
    2757           2 :         printf ("\ntestabi_key RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
    2758             : 
    2759           2 :         return nbError;
    2760             : }

Generated by: LCOV version 1.13