LCOV - code coverage report
Current view: top level - tests/ctest - test_key.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 1082 1090 99.3 %
Date: 2019-09-12 12:28:41 Functions: 21 21 100.0 %

          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_internal.h>
      10             : 
      11             : #ifdef HAVE_TIME_H
      12             : #include <time.h>
      13             : #endif
      14             : 
      15           2 : static void test_keyRefcounter (void)
      16             : {
      17           2 :         Key * key = keyNew (0);
      18           2 :         key->ksReference = 5;
      19           2 :         succeed_if (key->ksReference == 5, "wrong ref");
      20           2 :         succeed_if (keyGetRef (key) == 5, "wrong ref");
      21          12 :         while (keyGetRef (key) > 0)
      22          10 :                 keyDecRef (key);
      23           2 :         succeed_if (key->ksReference == 0, "wrong ref after dec");
      24           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
      25           2 :         succeed_if (keyDecRef (key) == 0, "should stay at minimum");
      26           2 :         succeed_if (keyGetRef (key) == 0, "reference counter");
      27           2 :         succeed_if (keyDecRef (key) == 0, "should stay at minimum");
      28           2 :         keyDel (key);
      29           2 : }
      30             : 
      31           2 : static void test_keyHelpers (void)
      32             : {
      33           2 :         char * name = "user/abc/defghi/jkl";
      34             :         char * p;
      35           2 :         size_t size = 0;
      36           2 :         int level = 0;
      37             :         char buffer[20];
      38             : 
      39           2 :         Key * key = keyNew ("system/parent/base", KEY_END);
      40             :         Key *k1, *k2;
      41             : 
      42           2 :         printf ("Test key helpers\n");
      43             : 
      44             :         /* copied out of example from keyNameGetOneLevel
      45             :          Lets define a key name with a lot of repeating '/' and escaped '/'
      46             :          char *keyName="user////abc/def\\/ghi////jkl///";*/
      47             : 
      48           2 :         p = name;
      49          12 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
      50             :         {
      51           8 :                 level++;
      52             : 
      53           8 :                 strncpy (buffer, p, size);
      54           8 :                 buffer[size] = 0;
      55             : 
      56             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
      57           8 :                 switch (level)
      58             :                 {
      59             :                 case 1:
      60           2 :                         succeed_if_same_string (buffer, "user");
      61             :                         break;
      62             :                 case 2:
      63           2 :                         succeed_if_same_string (buffer, "abc");
      64             :                         break;
      65             :                 case 3:
      66           2 :                         succeed_if_same_string (buffer, "defghi");
      67             :                         break;
      68             :                 case 4:
      69           2 :                         succeed_if_same_string (buffer, "jkl");
      70             :                         break;
      71             :                 default:
      72           0 :                         succeed_if (0, "should not reach case statement");
      73             :                 }
      74             :         }
      75             : 
      76             :         /* with escaped sequence:*/
      77           2 :         name = "user////abc/def\\/ghi////jkl///";
      78           2 :         size = 0;
      79           2 :         level = 0;
      80             : 
      81           2 :         p = name;
      82          12 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
      83             :         {
      84           8 :                 level++;
      85             : 
      86           8 :                 strncpy (buffer, p, size);
      87           8 :                 buffer[size] = 0;
      88             : 
      89             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
      90           8 :                 switch (level)
      91             :                 {
      92             :                 case 1:
      93           2 :                         succeed_if_same_string (buffer, "user");
      94           2 :                         succeed_if (size == 4, "wrong size returned");
      95             :                         break;
      96             :                 case 2:
      97           2 :                         succeed_if_same_string (buffer, "abc");
      98           2 :                         succeed_if (size == 3, "wrong size returned");
      99             :                         break;
     100             :                 case 3:
     101           2 :                         succeed_if_same_string (buffer, "def\\/ghi");
     102           2 :                         succeed_if (size == 8, "wrong size returned");
     103             :                         break;
     104             :                 case 4:
     105           2 :                         succeed_if_same_string (buffer, "jkl");
     106           2 :                         succeed_if (size == 3, "wrong size returned");
     107             :                         break;
     108             :                 default:
     109           0 :                         succeed_if (0, "should not reach case statement");
     110             :                 }
     111             :         }
     112             : 
     113             :         /* with escaped sequence at the end:*/
     114           2 :         name = "user////abc/def\\/ghi////jkl\\/\\/";
     115           2 :         size = 0;
     116           2 :         level = 0;
     117             : 
     118           2 :         p = name;
     119          12 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
     120             :         {
     121           8 :                 level++;
     122             : 
     123           8 :                 strncpy (buffer, p, size);
     124           8 :                 buffer[size] = 0;
     125             : 
     126             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
     127           8 :                 switch (level)
     128             :                 {
     129             :                 case 1:
     130           2 :                         succeed_if_same_string (buffer, "user");
     131           2 :                         succeed_if (size == 4, "wrong size returned");
     132             :                         break;
     133             :                 case 2:
     134           2 :                         succeed_if_same_string (buffer, "abc");
     135           2 :                         succeed_if (size == 3, "wrong size returned");
     136             :                         break;
     137             :                 case 3:
     138           2 :                         succeed_if_same_string (buffer, "def\\/ghi");
     139           2 :                         succeed_if (size == 8, "wrong size returned");
     140             :                         break;
     141             :                 case 4:
     142           2 :                         succeed_if_same_string (buffer, "jkl\\/\\/");
     143           2 :                         succeed_if (size == 7, "wrong size returned");
     144             :                         break;
     145             :                 default:
     146           0 :                         succeed_if (0, "should not reach case statement");
     147             :                 }
     148             :         }
     149             : 
     150             :         /* with escaped sequence at the begin:*/
     151           2 :         name = "user////\\/abc/\\/def\\/ghi////jkl\\/\\/";
     152           2 :         size = 0;
     153           2 :         level = 0;
     154             : 
     155           2 :         p = name;
     156          12 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
     157             :         {
     158           8 :                 level++;
     159             : 
     160           8 :                 strncpy (buffer, p, size);
     161           8 :                 buffer[size] = 0;
     162             : 
     163             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
     164           8 :                 switch (level)
     165             :                 {
     166             :                 case 1:
     167           2 :                         succeed_if_same_string (buffer, "user");
     168           2 :                         succeed_if (size == 4, "wrong size returned");
     169             :                         break;
     170             :                 case 2:
     171           2 :                         succeed_if_same_string (buffer, "\\/abc");
     172           2 :                         succeed_if (size == 5, "wrong size returned");
     173             :                         break;
     174             :                 case 3:
     175           2 :                         succeed_if_same_string (buffer, "\\/def\\/ghi");
     176           2 :                         succeed_if (size == 10, "wrong size returned");
     177             :                         break;
     178             :                 case 4:
     179           2 :                         succeed_if_same_string (buffer, "jkl\\/\\/");
     180           2 :                         succeed_if (size == 7, "wrong size returned");
     181             :                         break;
     182             :                 default:
     183           0 :                         succeed_if (0, "should not reach case statement");
     184             :                 }
     185             :         }
     186             : 
     187             :         /* with double escaped slashes:*/
     188           2 :         name = "user////\\\\/abc/\\/def\\\\/ghi\\/jkl\\\\///";
     189           2 :         size = 0;
     190           2 :         level = 0;
     191             : 
     192           2 :         p = name;
     193          14 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
     194             :         {
     195          10 :                 level++;
     196             : 
     197          10 :                 strncpy (buffer, p, size);
     198          10 :                 buffer[size] = 0;
     199             : 
     200             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
     201          10 :                 switch (level)
     202             :                 {
     203             :                 case 1:
     204           2 :                         succeed_if_same_string (buffer, "user");
     205           2 :                         succeed_if (size == 4, "wrong size returned");
     206             :                         break;
     207             :                 case 2:
     208           2 :                         succeed_if_same_string (buffer, "\\\\");
     209           2 :                         succeed_if (size == 2, "wrong size returned");
     210             :                         break;
     211             :                 case 3:
     212           2 :                         succeed_if_same_string (buffer, "abc");
     213           2 :                         succeed_if (size == 3, "wrong size returned");
     214             :                         break;
     215             :                 case 4:
     216           2 :                         succeed_if_same_string (buffer, "\\/def\\\\");
     217           2 :                         succeed_if (size == 7, "wrong size returned");
     218             :                         break;
     219             :                 case 5:
     220           2 :                         succeed_if_same_string (buffer, "ghi\\/jkl\\\\");
     221           2 :                         succeed_if (size == 10, "wrong size returned");
     222             :                         break;
     223             :                 default:
     224           0 :                         succeed_if (0, "should not reach case statement");
     225             :                 }
     226             :         }
     227             : 
     228             :         /* with triple escaped slashes:*/
     229           2 :         name = "user////\\\\\\/ab/\\\\\\/def\\\\/ghi/jkl\\\\\\///";
     230           2 :         size = 0;
     231           2 :         level = 0;
     232             : 
     233           2 :         p = name;
     234          14 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
     235             :         {
     236          10 :                 level++;
     237             : 
     238          10 :                 strncpy (buffer, p, size);
     239          10 :                 buffer[size] = 0;
     240             : 
     241             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
     242          10 :                 switch (level)
     243             :                 {
     244             :                 case 1:
     245           2 :                         succeed_if_same_string (buffer, "user");
     246           2 :                         succeed_if (size == 4, "wrong size returned");
     247             :                         break;
     248             :                 case 2:
     249           2 :                         succeed_if_same_string (buffer, "\\\\\\/ab");
     250           2 :                         succeed_if (size == 6, "wrong size returned");
     251             :                         break;
     252             :                 case 3:
     253           2 :                         succeed_if_same_string (buffer, "\\\\\\/def\\\\");
     254           2 :                         succeed_if (size == 9, "wrong size returned");
     255             :                         break;
     256             :                 case 4:
     257           2 :                         succeed_if_same_string (buffer, "ghi");
     258           2 :                         succeed_if (size == 3, "wrong size returned");
     259             :                         break;
     260             :                 case 5:
     261           2 :                         succeed_if_same_string (buffer, "jkl\\\\\\/");
     262           2 :                         succeed_if (size == 7, "wrong size returned");
     263             :                         break;
     264             :                 default:
     265           0 :                         succeed_if (0, "should not reach case statement");
     266             :                 }
     267             :         }
     268             : 
     269             :         /* backslashes only:*/
     270           2 :         name = "/\\/\\\\/\\\\\\/\\\\\\\\/\\\\\\\\\\/\\\\\\\\\\\\/\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\";
     271           2 :         size = 0;
     272           2 :         level = 0;
     273             : 
     274           2 :         p = name;
     275          12 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
     276             :         {
     277           8 :                 level++;
     278             : 
     279           8 :                 strncpy (buffer, p, size);
     280           8 :                 buffer[size] = 0;
     281             : 
     282             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
     283           8 :                 switch (level)
     284             :                 {
     285             :                 case 1:
     286           2 :                         succeed_if_same_string (buffer, "\\/\\\\");
     287           2 :                         succeed_if (size == 1 + 1 + 2, "wrong size returned");
     288             :                         break;
     289             :                 case 2:
     290           2 :                         succeed_if_same_string (buffer, "\\\\\\/\\\\\\\\");
     291           2 :                         succeed_if (size == 3 + 1 + 4, "wrong size returned");
     292             :                         break;
     293             :                 case 3:
     294           2 :                         succeed_if_same_string (buffer, "\\\\\\\\\\/\\\\\\\\\\\\");
     295           2 :                         succeed_if (size == 5 + 1 + 6, "wrong size returned");
     296             :                         break;
     297             :                 case 4:
     298           2 :                         succeed_if_same_string (buffer, "\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\");
     299           2 :                         succeed_if (size == 7 + 1 + 8, "wrong size returned");
     300             :                         break;
     301             :                 default:
     302           0 :                         succeed_if (0, "should not reach case statement");
     303             :                 }
     304             :         }
     305             : 
     306             :         /* backslashes with slashes:*/
     307           2 :         name = "////////\\/\\\\//////\\\\\\/\\\\\\\\////\\\\\\\\\\/\\\\\\\\\\\\//\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\";
     308           2 :         size = 0;
     309           2 :         level = 0;
     310             : 
     311           2 :         p = name;
     312          12 :         while (*(p = keyNameGetOneLevel (p + size, &size)))
     313             :         {
     314           8 :                 level++;
     315             : 
     316           8 :                 strncpy (buffer, p, size);
     317           8 :                 buffer[size] = 0;
     318             : 
     319             :                 /* printf("Level %d name: \"%s\"\n",level,buffer);*/
     320           8 :                 switch (level)
     321             :                 {
     322             :                 case 1:
     323           2 :                         succeed_if_same_string (buffer, "\\/\\\\");
     324           2 :                         succeed_if (size == 1 + 1 + 2, "wrong size returned");
     325             :                         break;
     326             :                 case 2:
     327           2 :                         succeed_if_same_string (buffer, "\\\\\\/\\\\\\\\");
     328           2 :                         succeed_if (size == 3 + 1 + 4, "wrong size returned");
     329             :                         break;
     330             :                 case 3:
     331           2 :                         succeed_if_same_string (buffer, "\\\\\\\\\\/\\\\\\\\\\\\");
     332           2 :                         succeed_if (size == 5 + 1 + 6, "wrong size returned");
     333             :                         break;
     334             :                 case 4:
     335           2 :                         succeed_if_same_string (buffer, "\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\");
     336           2 :                         succeed_if (size == 7 + 1 + 8, "wrong size returned");
     337             :                         break;
     338             :                 default:
     339           0 :                         succeed_if (0, "should not reach case statement");
     340             :                 }
     341             :         }
     342             : 
     343           2 :         keyDel (key);
     344             : 
     345           2 :         succeed_if (keyAddBaseName (0, "s") == -1, "null pointer saftey");
     346             : 
     347           2 :         k1 = keyNew ("user/dir1/dir2", KEY_END);
     348           2 :         succeed_if (keyAddBaseName (k1, 0) == 15, "Could not add nothing to basename");
     349           2 :         succeed_if_same_string (keyName (k1), "user/dir1/dir2");
     350           2 :         succeed_if (keyAddBaseName (k1, "") == 17, "Could not add nothing to basename");
     351           2 :         succeed_if_same_string (keyName (k1), "user/dir1/dir2/%");
     352           2 :         succeed_if (keyAddBaseName (k1, "mykey") == 23, "Could not add basename");
     353           2 :         succeed_if_same_string (keyName (k1), "user/dir1/dir2/%/mykey");
     354           2 :         succeed_if (keyGetNameSize (k1) == 23, "Name size not correct");
     355           2 :         succeed_if (keyAddBaseName (k1, "mykey") == sizeof ("user/dir1/dir2/%/mykey/mykey"), "Could not add basename");
     356           2 :         succeed_if_same_string (keyName (k1), "user/dir1/dir2/%/mykey/mykey");
     357           2 :         succeed_if (keyGetNameSize (k1) == 29, "Name size not correct");
     358           2 :         succeed_if (keyAddBaseName (k1, "a") == 31, "Could not add basename");
     359           2 :         succeed_if_same_string (keyName (k1), "user/dir1/dir2/%/mykey/mykey/a");
     360           2 :         succeed_if (keyGetNameSize (k1) == 31, "Name size not correct");
     361           2 :         keyDel (k1);
     362             : 
     363             :         {
     364           2 :                 k2 = keyNew ("user/dir1/dir2", KEY_END);
     365           2 :                 char c[] = "user/dir1/dir2/mykey\\/mykey\\/a";
     366           2 :                 succeed_if (keyAddBaseName (k2, "mykey/mykey/a") == sizeof (c), "Could not add basename");
     367           2 :                 succeed_if_same_string (keyName (k2), c);
     368           2 :                 succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
     369           2 :                 keyDel (k2);
     370             :         }
     371             : 
     372             :         {
     373           2 :                 k2 = keyNew ("user/dir1/dir2", KEY_END);
     374           2 :                 char c[] = "user/dir1/dir2/mykey\\/\\/\\/\\/a";
     375           2 :                 succeed_if (keyAddBaseName (k2, "mykey////a") == sizeof (c), "Could not add basename");
     376           2 :                 succeed_if_same_string (keyName (k2), c);
     377           2 :                 succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
     378           2 :                 keyDel (k2);
     379             :         }
     380             : 
     381             :         {
     382           2 :                 k2 = keyNew ("user/dir1/dir2", KEY_END);
     383           2 :                 char c[] = "user/dir1/dir2/mykey\\/\\/\\/\\/";
     384           2 :                 succeed_if (keyAddBaseName (k2, "mykey////") == sizeof (c), "Could not add basename");
     385           2 :                 succeed_if_same_string (keyName (k2), c);
     386           2 :                 succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
     387           2 :                 keyDel (k2);
     388             :         }
     389             : 
     390             : 
     391           2 :         k2 = keyNew (0);
     392           2 :         succeed_if (keyAddBaseName (k2, "no") == -1, "Could add basename on empty name");
     393           2 :         succeed_if_same_string (keyName (k2), "");
     394           2 :         succeed_if (keyGetNameSize (k2) == 1, "Name size not correct");
     395           2 :         keyDel (k2);
     396             : 
     397           2 :         k2 = keyNew (0);
     398           2 :         succeed_if (keyAddBaseName (k2, "user") == -1, "Could add basename on empty name");
     399           2 :         succeed_if_same_string (keyName (k2), "");
     400           2 :         succeed_if (keyGetNameSize (k2) == 1, "Name size not correct");
     401           2 :         keyDel (k2);
     402             : 
     403           2 :         k2 = keyNew ("user/dir1/dir2/mykey/mykey/a", KEY_END);
     404           2 :         succeed_if (keySetBaseName (k2, "mykey") == 33, "Could not add basename");
     405           2 :         succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/mykey");
     406           2 :         succeed_if (keyGetNameSize (k2) == 33, "Name size not correct");
     407           2 :         succeed_if (keySetBaseName (k2, "einva") == 33, "Could not add basename");
     408           2 :         succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/einva");
     409           2 :         succeed_if (keyGetNameSize (k2) == 33, "Name size not correct");
     410           2 :         succeed_if (keySetBaseName (k2, "chang") == 33, "Could not add basename");
     411           2 :         succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/chang");
     412           2 :         succeed_if (keySetBaseName (k2, "change") == 34, "Could not add basename");
     413           2 :         succeed_if (keyGetNameSize (k2) == 34, "Name size not correct");
     414           2 :         succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/change");
     415           2 :         keyDel (k2);
     416             : 
     417           2 :         k2 = keyNew ("user/dir1/a", KEY_END);
     418           2 :         succeed_if (keySetBaseName (k2, 0) == 10, "Could not add basename");
     419           2 :         succeed_if_same_string (keyName (k2), "user/dir1");
     420           2 :         succeed_if (keyGetNameSize (k2) == 10, "Name size not correct");
     421           2 :         keyDel (k2);
     422             : 
     423           2 :         k2 = keyNew ("user/dir1/a", KEY_END);
     424           2 :         succeed_if (keySetBaseName (k2, "some/more") == sizeof ("user/dir1/some\\/more"), "Could not add basename");
     425           2 :         succeed_if_same_string (keyName (k2), "user/dir1/some\\/more");
     426           2 :         succeed_if (keyGetNameSize (k2) == sizeof ("user/dir1/some\\/more"), "Name size not correct");
     427           2 :         keyDel (k2);
     428             : 
     429             :         {
     430           2 :                 k2 = keyNew ("user/dir1/a", KEY_END);
     431           2 :                 char c[] = "user/dir1/some\\/\\/\\/\\/more";
     432           2 :                 succeed_if (keySetBaseName (k2, "some////more") == sizeof (c), "Could not add basename");
     433           2 :                 succeed_if_same_string (keyName (k2), c);
     434           2 :                 succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
     435           2 :                 keyDel (k2);
     436             :         }
     437             : 
     438             :         {
     439           2 :                 k2 = keyNew ("user/dir1/a", KEY_END);
     440           2 :                 char c[] = "user/dir1/\\/\\/\\/\\/more";
     441           2 :                 succeed_if (keySetBaseName (k2, "////more") == sizeof (c), "Could not add basename");
     442           2 :                 succeed_if_same_string (keyName (k2), c);
     443           2 :                 succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
     444           2 :                 keyDel (k2);
     445             :         }
     446             : 
     447           2 :         k2 = keyNew ("user", KEY_END);
     448           2 :         succeed_if (keySetBaseName (k2, "user") == -1, "Could add basename, but there is none");
     449           2 :         succeed_if_same_string (keyName (k2), "user");
     450           2 :         succeed_if (keyGetNameSize (k2) == 5, "Name size not correct");
     451           2 :         keyDel (k2);
     452             : 
     453           2 :         k2 = keyNew ("system", KEY_END);
     454           2 :         succeed_if (keySetBaseName (k2, "system") == -1, "Could add basename, but there is none");
     455           2 :         succeed_if_same_string (keyName (k2), "system");
     456           2 :         succeed_if (keyGetNameSize (k2) == 7, "Name size not correct");
     457           2 :         keyDel (k2);
     458           2 : }
     459             : 
     460           2 : static void test_keyPlugin (void)
     461             : {
     462           2 :         Plugin * plug = (Plugin *) 1222243;
     463             : 
     464           2 :         Key * k = keyNew ("system/name", KEY_BINARY, KEY_SIZE, sizeof (plug), KEY_VALUE, &plug, KEY_END);
     465           2 :         Plugin * xlug = *(Plugin **) keyValue (k);
     466             : 
     467           2 :         succeed_if (xlug == plug, "should point to the same");
     468           2 :         succeed_if (plug == (Plugin *) 1222243, "should point to that");
     469           2 :         succeed_if (xlug == (Plugin *) 1222243, "should point to that too");
     470             : 
     471           2 :         keyDel (k);
     472           2 : }
     473             : 
     474             : #define TEST_ESCAPE_PART(A, S)                                                                                                             \
     475             :         do                                                                                                                                 \
     476             :         {                                                                                                                                  \
     477             :                 char a[] = A;                                                                                                              \
     478             :                 char s[] = S;                                                                                                              \
     479             :                 elektraEscapeKeyNamePart (a, buffer);                                                                                      \
     480             :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");                                                  \
     481             :                 elektraUnescapeKeyName (buffer, buffer2);                                                                                  \
     482             :                 succeed_if_same_string (a, buffer2);                                                                                       \
     483             :         } while (0)
     484             : 
     485             : 
     486           2 : static void test_keyNameEscape (void)
     487             : {
     488             :         char buffer[500];
     489             :         char buffer2[500];
     490             : 
     491           2 :         printf ("test escapeKeyNamePart\n");
     492             : 
     493             : #include <data_escape.c>
     494             : 
     495             : 
     496             :         /*
     497             :         for (size_t i = 0; i<10; ++i)
     498             :         {
     499             :                 int z = buffer[i];
     500             :                 printf ("%c %d\n", (char)z, z);
     501             :         }
     502             :         */
     503             : 
     504           2 :         printf ("test roundtripping properties\n");
     505           2 :         Key * k = keyNew ("user/a", KEY_END);
     506             : #ifdef LONG_TEST
     507             :         char a[] = "abcd";
     508             : #else
     509           2 :         char a[] = "ab";
     510             : #endif
     511         514 :         for (int c0 = 0; c0 < 256; ++c0)
     512      131072 :                 for (int c1 = 0; c1 < 256; ++c1)
     513             : #ifdef LONG_TEST
     514             :                         for (int c2 = 0; c2 < 256; ++c2)
     515             :                                 for (int c3 = 0; c3 < 256; ++c3)
     516             : #endif
     517             :                                 {
     518      131072 :                                         a[0] = c0;
     519      131072 :                                         a[1] = c1;
     520             : #ifdef LONG_TEST
     521             :                                         a[2] = c2;
     522             :                                         a[3] = c3;
     523             : #endif
     524      131072 :                                         elektraEscapeKeyNamePart (a, buffer);
     525      131072 :                                         elektraUnescapeKeyName (buffer, buffer2);
     526      131072 :                                         succeed_if_same_string (a, buffer2);
     527             : 
     528      131072 :                                         keySetBaseName (k, a);
     529      131072 :                                         succeed_if_same_string (a, keyBaseName (k));
     530             :                                 }
     531           2 :         keyDel (k);
     532           2 : }
     533             : 
     534           2 : static void test_keyNameUnescape (void)
     535             : {
     536             :         char buffer[500];
     537             : 
     538           2 :         printf ("test unescapeKeyNamePart\n");
     539             :         {
     540           2 :                 char a[] = "\\\\a";
     541           2 :                 char s[] = "\\\\a";
     542           2 :                 elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
     543           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     544             :                 /*
     545             :                 for (size_t i = 0; i<sizeof(s); ++i)
     546             :                 {
     547             :                         int z = buffer[i];
     548             :                         printf ("%c %d\n", (char)z, z);
     549             :                 }
     550             :                 */
     551             :         }
     552             : 
     553             :         {
     554           2 :                 char a[] = "a\\/test";
     555           2 :                 char s[] = "a/test";
     556           2 :                 elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
     557           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     558             :         }
     559             : 
     560             :         {
     561           2 :                 char a[] = "a\\\\\\/test";
     562           2 :                 char s[] = "a\\/test";
     563           2 :                 elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
     564           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     565             :         }
     566             : 
     567             :         {
     568           2 :                 char a[] = "a\\\\\\\\\\/test";
     569           2 :                 char s[] = "a\\\\/test";
     570           2 :                 elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
     571           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     572             :         }
     573             : 
     574             : 
     575           2 :         printf ("test unescapeKeyName\n");
     576             : 
     577             :         {
     578           2 :                 char a[] = "user/a/test";
     579           2 :                 char s[] = "user\0a\0test";
     580           2 :                 elektraUnescapeKeyName (a, buffer);
     581           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     582             :         }
     583             : 
     584             :         {
     585           2 :                 char a[] = "user/a\\/test";
     586           2 :                 char s[] = "user\0a/test";
     587           2 :                 elektraUnescapeKeyName (a, buffer);
     588           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     589             :         }
     590             : 
     591             :         {
     592           2 :                 char a[] = "user/a\\\\/test";
     593           2 :                 char s[] = "user\0a\\\0test";
     594           2 :                 elektraUnescapeKeyName (a, buffer);
     595           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     596             :         }
     597             : 
     598             :         {
     599           2 :                 char a[] = "user/\\\\/test";
     600           2 :                 char s[] = "user\0\\\0test";
     601           2 :                 elektraUnescapeKeyName (a, buffer);
     602           2 :                 succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
     603             :         }
     604             : 
     605             :         /*
     606             :         for (size_t i = 0; i<sizeof(s); ++i)
     607             :         {
     608             :                 int z = buffer[i];
     609             :                 printf ("%c %d\n", (char)z, z);
     610             :         }
     611             :         */
     612           2 : }
     613             : 
     614           2 : static void test_keyCompare (void)
     615             : {
     616           2 :         printf ("test keyCompare\n");
     617           2 :         Key * key1 = keyNew (0);
     618           2 :         Key * key2 = keyNew (0);
     619             : 
     620           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys don't differ of course");
     621             : 
     622           2 :         keySetName (key1, "user/myname");
     623           2 :         succeed_if_same_string (keyName (key1), "user/myname");
     624           2 :         succeed_if (keyCompare (key1, key2) == KEY_NAME, "the keys should differ in name");
     625           2 :         keySetName (key2, "user/myname");
     626           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in name");
     627             : 
     628           2 :         keySetOwner (key1, "myowner");
     629           2 :         succeed_if (keyCompare (key1, key2) == (KEY_OWNER | KEY_META), "the keys should differ in owner");
     630           2 :         keySetOwner (key2, "myowner");
     631           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in owner");
     632             : 
     633           2 :         keySetString (key1, "myvalue");
     634           2 :         succeed_if (keyCompare (key1, key2) == KEY_VALUE, "the keys should differ in value");
     635           2 :         keySetString (key2, "myvalue");
     636           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in value");
     637             : 
     638           2 :         keySetComment (key1, "mycomment");
     639           2 :         succeed_if (keyCompare (key1, key2) == (KEY_COMMENT | KEY_META), "the keys should differ in comment");
     640           2 :         keySetComment (key2, "mycomment");
     641           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in comment");
     642             : 
     643           2 :         keySetUID (key1, 50);
     644           2 :         succeed_if (keyCompare (key1, key2) == (KEY_META), "the keys should differ in uid");
     645           2 :         keySetUID (key2, 50);
     646           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in uid");
     647             : 
     648           2 :         keySetGID (key1, 50);
     649           2 :         succeed_if (keyCompare (key1, key2) == (KEY_META), "the keys should differ in gid");
     650           2 :         keySetGID (key2, 50);
     651           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in gid");
     652             : 
     653           2 :         keySetMode (key1, 0222);
     654           2 :         succeed_if (keyCompare (key1, key2) == (KEY_META), "the keys should differ in mode");
     655           2 :         keySetMode (key2, 0222);
     656           2 :         succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in mode");
     657             : 
     658           2 :         keyDel (key1);
     659           2 :         keyDel (key2);
     660           2 : }
     661             : 
     662           2 : static void test_keyNewExtensions (void)
     663             : {
     664           2 :         printf ("test keyNewExtensions\n");
     665             : 
     666           2 :         Key * key = 0;
     667           2 :         succeed_if (keyIsUser (key) == -1, "empty user key");
     668           2 :         succeed_if (keyIsSystem (key) == -1, "empty user key?");
     669             : 
     670           2 :         key = keyNew ("", KEY_END);
     671           2 :         succeed_if (keyIsUser (key) == 0, "empty user key");
     672           2 :         succeed_if (keyIsSystem (key) == 0, "empty user key?");
     673           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + mode");
     674             : 
     675             :         // Key with name + UID/GID
     676           2 :         key = keyNew ("system/sw/test", KEY_UID, 123, KEY_GID, 456, KEY_END);
     677           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name + UID + GID");
     678           2 :         succeed_if (keyGetUID (key) == 123, "keyNew: UID no set correctly");
     679           2 :         succeed_if (keyGetGID (key) == 456, "keyNew: GID not set correctly");
     680           2 :         succeed_if (keyIsUser (key) == 0, "not user");
     681           2 :         succeed_if (keyIsSystem (key) == 1, "is system");
     682           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + UID + GID");
     683             : 
     684             :         // Key with name + MODE
     685           2 :         key = keyNew ("system/sw/test", KEY_MODE, 0644, KEY_END);
     686           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name + mode");
     687           2 :         succeed_if (keyGetMode (key) == 0644, "keyNew: mode no set correctly");
     688           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + mode");
     689           2 : }
     690             : 
     691           2 : static void test_owner (void)
     692             : {
     693           2 :         printf ("test owner\n");
     694             : 
     695           2 :         Key * key = 0;
     696             :         char fullroot[KDB_MAX_PATH_LENGTH];
     697           2 :         char array[] = "here is some data stored";
     698           2 :         char testOwner[] = "max";
     699             : 
     700             :         char * getBack;
     701           2 :         key = keyNew ("user/test/test", KEY_END);
     702           2 :         succeed_if (keySetOwner (key, "hugo") == sizeof ("hugo"), "could not set owner");
     703           2 :         succeed_if_same_string (keyOwner (key), "hugo");
     704           2 :         succeed_if (keyGetOwnerSize (key) == 5, "owner length not correct");
     705           2 :         keyGetFullName (key, fullroot, KDB_MAX_PATH_LENGTH);
     706           2 :         succeed_if_same_string (keyOwner (key), "hugo");
     707             :         /* printf ("%s, %s, %s\n", keyName(key), keyBaseName(key), fullroot); */
     708           2 :         succeed_if_same_string (keyName (key), "user/test/test");
     709           2 :         succeed_if_same_string (keyBaseName (key), "test");
     710             :         // printf ("%s\n", fullroot);
     711           2 :         succeed_if_same_string (fullroot, "user:hugo/test/test");
     712           2 :         succeed_if (keyIsUser (key) == 1, "is user");
     713           2 :         succeed_if (keyIsSystem (key) == 0, "not system");
     714           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
     715             : 
     716           2 :         key = keyNew ("user/test/test", KEY_END);
     717           2 :         succeed_if (keySetOwner (key, "tommy") == sizeof ("tommy"), "could not set owner");
     718           2 :         succeed_if_same_string (keyOwner (key), "tommy");
     719           2 :         succeed_if (keyGetOwnerSize (key) == 6, "owner length not correct");
     720           2 :         keyGetFullName (key, fullroot, KDB_MAX_PATH_LENGTH);
     721           2 :         succeed_if_same_string (keyOwner (key), "tommy");
     722             :         /* printf ("%s, %s, %s\n", keyName(key), keyBaseName(key), fullroot); */
     723           2 :         succeed_if_same_string (keyName (key), "user/test/test");
     724           2 :         succeed_if_same_string (keyBaseName (key), "test");
     725           2 :         succeed_if_same_string (fullroot, "user:tommy/test/test");
     726           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
     727             : 
     728             :         // Key with name + owner
     729           2 :         key = keyNew ("user/test/test", KEY_OWNER, "yl", KEY_END);
     730           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name + owner");
     731           2 :         succeed_if_same_string (keyOwner (key), "yl");
     732           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
     733             : 
     734           2 :         key = keyNew ("user/valid/there", KEY_BINARY, KEY_SIZE, sizeof (array), KEY_VALUE, array, KEY_END);
     735           2 :         succeed_if (key != NULL, "keyNew: Unable to create a key with name + value of default type");
     736           2 :         succeed_if (keyIsBinary (key), "Could not set type to binary");
     737           2 :         succeed_if (keyGetValueSize (key) == sizeof (array), "Value size not correct");
     738           2 :         succeed_if (memcmp ((char *) keyValue (key), array, sizeof (array)) == 0, "could not get correct binary value");
     739           2 :         getBack = elektraMalloc (keyGetValueSize (key));
     740           2 :         keyGetBinary (key, getBack, keyGetValueSize (key));
     741           2 :         succeed_if (memcmp (getBack, array, sizeof (array)) == 0, "could not get correct value with keyGetBinary");
     742           2 :         elektraFree (getBack);
     743           2 :         succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
     744             : 
     745           2 :         key = keyNew ("user:y", KEY_END);
     746           2 :         succeed_if_same_string (keyName (key), "user");
     747           2 :         succeed_if (keyGetNameSize (key) == 5, "empty name size");
     748           2 :         succeed_if_same_string (keyOwner (key), "y");
     749           2 :         succeed_if (keyGetOwnerSize (key) == 2, "owner y size");
     750           2 :         keyDel (key);
     751             : 
     752           2 :         succeed_if (key = keyNew ("user:perfectowner", KEY_END), "could not create new key");
     753           2 :         succeed_if (keySetName (key, "user:perfectowner") == 5, "could not set to user with owner");
     754           2 :         succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
     755           2 :         succeed_if_same_string (keyOwner (key), "perfectowner");
     756           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     757             : 
     758             :         char ret[1000];
     759           2 :         size_t i = 0;
     760           2 :         key = keyNew ("user:max/name", KEY_END);
     761           2 :         succeed_if (keyGetOwner (0, ret, 100) == -1, "null pointer");
     762           2 :         succeed_if (keyGetOwner (key, 0, 100) == -1, "string null pointer");
     763           2 :         succeed_if (keyGetOwner (key, ret, 0) == -1, "length checking");
     764           6 :         for (i = 1; i < sizeof (testOwner); i++)
     765             :         {
     766           6 :                 succeed_if (keyGetOwner (key, ret, i) == -1, "length checking too short");
     767             :         }
     768           8 :         for (i = sizeof (testOwner); i < sizeof (testOwner) * 2; i++)
     769             :         {
     770           8 :                 succeed_if (keyGetOwner (key, ret, i) == sizeof (testOwner), "length checking longer");
     771             :         }
     772           2 :         succeed_if (keyGetOwner (key, ret, (size_t) -1) == -1, "maxSize exceeded");
     773             : 
     774           2 :         succeed_if (keySetOwner (key, 0) == 1, "delete owner");
     775           2 :         succeed_if (keyGetOwner (key, ret, i) == 1, "length checking deleting");
     776           2 :         succeed_if_same_string (ret, "");
     777             : 
     778           2 :         succeed_if (keySetOwner (key, testOwner) == sizeof (testOwner), "set owner");
     779           2 :         succeed_if (keyGetOwner (key, ret, i) == sizeof (testOwner), "length checking working");
     780           2 :         succeed_if_same_string (ret, testOwner);
     781             : 
     782           2 :         succeed_if (keySetOwner (key, "") == 1, "delete owner");
     783           2 :         succeed_if (keyGetOwner (key, ret, i) == 1, "length checking deleting");
     784           2 :         succeed_if_same_string (ret, "");
     785             : 
     786           2 :         succeed_if (keySetOwner (key, testOwner) == sizeof (testOwner), "set owner");
     787           2 :         succeed_if (keyGetOwner (key, ret, i) == sizeof (testOwner), "length checking working");
     788           2 :         succeed_if_same_string (ret, testOwner);
     789           2 :         keyDel (key);
     790             : 
     791           2 :         succeed_if (keyOwner (0) == 0, "null pointer");
     792             : 
     793           2 :         key = keyNew (0);
     794           2 :         succeed_if_same_string (keyOwner (key), "");
     795           2 :         succeed_if (keyGetOwner (key, ret, 1000) == 1, "get empty owner");
     796           2 :         succeed_if_same_string (ret, "");
     797           2 :         succeed_if (keyGetOwner (key, ret, 0) == -1, "get empty owner");
     798           2 :         keyDel (key);
     799             : 
     800           2 :         succeed_if (keySetOwner (0, "") == -1, "null pointer");
     801           2 : }
     802             : 
     803           4 : static void test_keyComment (void)
     804             : {
     805             :         Key * key;
     806             :         char ret[1000];
     807             :         size_t i;
     808           4 :         char testComment[] = "testcomment";
     809             : 
     810           4 :         printf ("Test comment of key\n");
     811             : 
     812           4 :         succeed_if (key = keyNew (0), "could not create new key");
     813           4 :         succeed_if (keyGetCommentSize (key) == 1, "empty comment size");
     814           4 :         succeed_if (keySetComment (key, "perfectcomment") == 15, "could not set comment");
     815           4 :         succeed_if (keyGetCommentSize (key) == 15, "comment size not correct");
     816           4 :         succeed_if_same_string (keyComment (key), "perfectcomment");
     817           4 :         succeed_if (keySetComment (key, "perfectcomment") == 15, "could not re-set same comment");
     818           4 :         succeed_if_same_string (keyComment (key), "perfectcomment");
     819           4 :         succeed_if (keySetComment (key, "nearperfectcomment") == 19, "could not re-set other comment");
     820           4 :         succeed_if (keyGetCommentSize (key) == 19, "comment size not correct");
     821           4 :         succeed_if_same_string (keyComment (key), "nearperfectcomment");
     822           4 :         succeed_if (keyGetComment (key, ret, keyGetCommentSize (key) >= 999 ? 999 : keyGetCommentSize (key)) == 19,
     823             :                     "could not get comment");
     824           4 :         succeed_if_same_string (ret, "nearperfectcomment");
     825           4 :         succeed_if (keyDel (key) == 0, "could not delete key");
     826             : 
     827           4 :         succeed_if (key = keyNew (0), "could not create new key");
     828           4 :         succeed_if_same_string (keyComment (key), "");
     829           4 :         succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
     830           4 :         succeed_if (keySetComment (key, "") == 1, "could not set comment");
     831           4 :         succeed_if_same_string (keyComment (key), "");
     832           4 :         succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
     833           4 :         succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get empty comment");
     834           4 :         succeed_if (keyGetComment (key, ret, 1) == 1, "Could not get empty comment");
     835           4 :         succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
     836           4 :         succeed_if (keyDel (key) == 0, "could not delete key");
     837             : 
     838           4 :         succeed_if (key = keyNew (0), "could not create new key");
     839        1020 :         for (i = 1; i < 256; i++)
     840             :         {
     841        1020 :                 ret[0] = i;
     842        1020 :                 ret[1] = i;
     843        1020 :                 ret[2] = 0;
     844        1020 :                 succeed_if (keySetComment (key, ret) == 3, "could not set comment");
     845             :                 // output_key (key);
     846        1020 :                 succeed_if_same_string (keyComment (key), ret);
     847             :         }
     848           4 :         succeed_if (keyDel (key) == 0, "could not delete key");
     849             : 
     850             : 
     851           4 :         printf ("Test comment of key 2\n");
     852             : 
     853           4 :         succeed_if (keyComment (0) == 0, "null pointer");
     854           4 :         succeed_if (keyGetCommentSize (0) == -1, "null pointer");
     855           4 :         succeed_if (keySetComment (0, "") == -1, "null pointer");
     856             : 
     857           4 :         key = keyNew (0);
     858           4 :         succeed_if (keyGetCommentSize (key) == 1, "empty comment size");
     859             : 
     860           4 :         keySetComment (key, testComment);
     861           4 :         succeed_if (keyGetComment (0, ret, 100) == -1, "null pointer");
     862           4 :         succeed_if (keyGetComment (key, 0, 100) == -1, "comment null pointer");
     863           4 :         succeed_if (keyGetComment (key, ret, 0) == -1, "length checking");
     864             : 
     865          44 :         for (i = 1; i < sizeof (testComment); i++)
     866             :         {
     867          44 :                 succeed_if (keyGetComment (key, ret, i) == -1, "length checking too short");
     868             :         }
     869          48 :         for (i = sizeof (testComment); i < sizeof (testComment) * 2; i++)
     870             :         {
     871          48 :                 succeed_if (keyGetComment (key, ret, i) == sizeof (testComment), "length checking longer");
     872             :         }
     873           4 :         succeed_if (keyGetComment (key, ret, (size_t) -1) == -1, "maxSize exceeded");
     874             : 
     875           4 :         succeed_if (keySetComment (key, 0) == 1, "delete comment");
     876           4 :         succeed_if (keyGetComment (key, ret, i) == 1, "length checking deleting");
     877           4 :         succeed_if_same_string (ret, "");
     878             : 
     879           4 :         succeed_if (keySetComment (key, testComment) == sizeof (testComment), "set comment");
     880           4 :         succeed_if (keyGetComment (key, ret, i) == sizeof (testComment), "length checking working");
     881           4 :         succeed_if_same_string (ret, testComment);
     882             : 
     883           4 :         succeed_if (keySetComment (key, "") == 1, "delete comment");
     884           4 :         succeed_if (keyGetComment (key, ret, i) == 1, "length checking deleting");
     885           4 :         succeed_if_same_string (ret, "");
     886             : 
     887           4 :         succeed_if (keySetComment (key, testComment) == sizeof (testComment), "set comment");
     888           4 :         succeed_if (keyGetComment (key, ret, i) == sizeof (testComment), "length checking working");
     889           4 :         succeed_if_same_string (ret, testComment);
     890             : 
     891           4 :         succeed_if (keyGetCommentSize (key) == sizeof (testComment), "testComment comment size");
     892           4 :         succeed_if (strncmp (keyComment (key), testComment, sizeof (testComment)) == 0, "testComment not same");
     893           4 :         keyDel (key);
     894           4 : }
     895             : 
     896           2 : static void test_keyOwner (void)
     897             : {
     898             :         Key * key;
     899             :         char ret[1000];
     900             :         int i;
     901           2 :         printf ("Test owner of keys\n");
     902           2 :         succeed_if (key = keyNew (0), "could not create new key");
     903           2 :         succeed_if (keyGetOwnerSize (key) == 1, "empty owner size");
     904           2 :         succeed_if (keySetOwner (key, "perfectowner") == 13, "could not set owner");
     905           2 :         succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
     906           2 :         succeed_if_same_string (keyOwner (key), "perfectowner");
     907           2 :         succeed_if (keySetOwner (key, "perfectowner") == 13, "could not re-set same owner");
     908           2 :         succeed_if_same_string (keyOwner (key), "perfectowner");
     909           2 :         succeed_if (keySetOwner (key, "nearperfectowner") == 17, "could not re-set other owner");
     910           2 :         succeed_if (keyGetOwnerSize (key) == 17, "owner size not correct");
     911           2 :         succeed_if_same_string (keyOwner (key), "nearperfectowner");
     912           2 :         succeed_if (keyGetOwner (key, ret, keyGetOwnerSize (key) >= 999 ? 999 : keyGetOwnerSize (key)) == 17, "could not get owner");
     913           2 :         succeed_if_same_string (ret, "nearperfectowner");
     914           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     915             : 
     916           2 :         succeed_if (key = keyNew (0), "could not create new key");
     917           2 :         succeed_if (keySetName (key, "user:perfectowner") == 5, "could not set to user with owner");
     918           2 :         succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
     919           2 :         succeed_if_same_string (keyOwner (key), "perfectowner");
     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_same_string (keyOwner (key), "");
     924           2 :         succeed_if (keyGetOwnerSize (key) == 1, "Empty owner size problem");
     925           2 :         succeed_if (keySetOwner (key, "") == 1, "could not set owner");
     926           2 :         succeed_if_same_string (keyOwner (key), "");
     927           2 :         succeed_if (keyGetOwnerSize (key) == 1, "Empty owner size problem");
     928           2 :         succeed_if (keyGetOwner (key, ret, 0) == -1, "Could not get empty owner");
     929           2 :         succeed_if (keyGetOwner (key, ret, 1) == 1, "Could not get empty owner");
     930           2 :         succeed_if (ret[0] == 0, "keyGetOwner did not return empty owner");
     931           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     932             : 
     933           2 :         succeed_if (key = keyNew (0), "could not create new key");
     934         510 :         for (i = 1; i < 256; i++)
     935             :         {
     936         510 :                 ret[0] = i;
     937         510 :                 ret[1] = i;
     938         510 :                 ret[2] = 0;
     939         510 :                 succeed_if (keySetOwner (key, ret) == 3, "could not set owner");
     940             :                 // output_key (key);
     941         510 :                 succeed_if_same_string (keyOwner (key), ret);
     942             :         }
     943           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     944           2 : }
     945             : 
     946           2 : static void test_keyDir (void)
     947             : {
     948             :         mode_t i;
     949           2 :         Key * key = keyNew ("user", KEY_END);
     950             : 
     951           2 :         printf ("Test directory keys\n");
     952             : 
     953           2 :         succeed_if (keyGetMode (key) == 0600, "new key not 0600 by default");
     954             : 
     955           2 :         succeed_if (keySetMode (key, 0644) == 0, "could not set to 0644");
     956           2 :         succeed_if (keyGetMode (key) == 0644, "key is not 0644, but was set");
     957             : 
     958           2 :         succeed_if (keySetDir (key) == 0, "could not set directory key");
     959             :         // succeed_if (keyGetMode(key) == 0755, "key is not 0644, but was set");
     960             : 
     961        1024 :         for (i = 0; i <= 0777; i++)
     962             :         {
     963        1024 :                 succeed_if (keySetMode (key, i) == 0, "could not set to 0000 <= i <= 0777");
     964        1024 :                 succeed_if (keyGetMode (key) == i, "key is not correct 0000 <= i <= 0777");
     965             : 
     966        1024 :                 succeed_if (keySetDir (key) == 0, "could not set directory key");
     967             :         }
     968           2 :         keyDel (key);
     969             : 
     970           2 :         key = keyNew ("user", KEY_DIR, KEY_END);
     971           2 :         succeed_if (keyGetMode (key) == 0700, "new key with KEY_DIR not 0700 by default");
     972             : 
     973           2 :         succeed_if (keySetMode (key, 0644) == 0, "could not set to 0644");
     974           2 :         succeed_if (keyGetMode (key) == 0644, "key is not 0644, but was set");
     975             : 
     976           2 :         succeed_if (keySetDir (key) == 0, "could not set directory key");
     977           2 :         succeed_if (keyGetMode (key) == 0744, "key is not 0644, but was set");
     978           2 :         keyDel (key);
     979             : 
     980           2 :         key = keyNew ("user/s", KEY_DIR, KEY_MODE, 0444, KEY_END);
     981           2 :         succeed_if (keyGetMode (key) == 0544, "0444 set by keyNew");
     982           2 :         keyDel (key);
     983             : 
     984           2 :         key = keyNew ("user/s", KEY_MODE, 0444, KEY_DIR, KEY_END);
     985           2 :         succeed_if (keyGetMode (key) == 0544, "0555 set by keyNew");
     986           2 :         keyDel (key);
     987           2 : }
     988             : 
     989           2 : static void test_keyTime (void)
     990             : {
     991           2 :         Key * key = keyNew (0);
     992           2 :         time_t now = time (0);
     993           2 :         time_t past = now - 60 * 60 * 24 * 356 * 10;
     994           2 :         time_t future = now + 60 * 60 * 24 * 356 * 10;
     995             :         /*
     996             :         time_t far_future = now + 60L*60L*24L*356L * 100L;
     997             :         */
     998             : 
     999           2 :         printf ("Test key time\n");
    1000             : 
    1001           2 :         succeed_if (keyGetATime (0) == (time_t) -1, "null pointer check");
    1002           2 :         succeed_if (keyGetMTime (0) == (time_t) -1, "null pointer check");
    1003           2 :         succeed_if (keyGetCTime (0) == (time_t) -1, "null pointer check");
    1004             : 
    1005           2 :         succeed_if (keySetATime (0, 0) == -1, "null pointer check");
    1006           2 :         succeed_if (keySetMTime (0, 0) == -1, "null pointer check");
    1007           2 :         succeed_if (keySetCTime (0, 0) == -1, "null pointer check");
    1008             : 
    1009           2 :         succeed_if (keyGetATime (key) == 0, "new initialized atime not 0");
    1010           2 :         succeed_if (keyGetMTime (key) == 0, "new initialized mtime not 0");
    1011           2 :         succeed_if (keyGetCTime (key) == 0, "new initialized ctime not 0");
    1012             : 
    1013           2 :         succeed_if (keySetATime (key, now) == 0, "could not set atime");
    1014           2 :         succeed_if (keySetMTime (key, now) == 0, "could not set mtime");
    1015           2 :         succeed_if (keySetCTime (key, now) == 0, "could not set ctime");
    1016             : 
    1017           2 :         succeed_if (keyGetATime (key) == now, "new initialized atime not 0");
    1018           2 :         succeed_if (keyGetMTime (key) == now, "new initialized mtime not 0");
    1019           2 :         succeed_if (keyGetCTime (key) == now, "new initialized ctime not 0");
    1020             : 
    1021             : 
    1022           2 :         succeed_if (keySetATime (key, past) == 0, "could not set atime");
    1023           2 :         succeed_if (keySetMTime (key, past) == 0, "could not set mtime");
    1024           2 :         succeed_if (keySetCTime (key, past) == 0, "could not set ctime");
    1025             : 
    1026           2 :         succeed_if (keyGetATime (key) == past, "new initialized atime not 0");
    1027           2 :         succeed_if (keyGetMTime (key) == past, "new initialized mtime not 0");
    1028           2 :         succeed_if (keyGetCTime (key) == past, "new initialized ctime not 0");
    1029             : 
    1030             : 
    1031           2 :         succeed_if (keySetATime (key, future) == 0, "could not set atime");
    1032           2 :         succeed_if (keySetMTime (key, future) == 0, "could not set mtime");
    1033           2 :         succeed_if (keySetCTime (key, future) == 0, "could not set ctime");
    1034             : 
    1035           2 :         succeed_if (keyGetATime (key) == future, "new initialized atime not 0");
    1036           2 :         succeed_if (keyGetMTime (key) == future, "new initialized mtime not 0");
    1037           2 :         succeed_if (keyGetCTime (key) == future, "new initialized ctime not 0");
    1038             : 
    1039             :         /*
    1040             :                 succeed_if (keySetATime (key, far_future) == 0, "could not set atime");
    1041             :                 succeed_if (keySetMTime (key, far_future) == 0, "could not set mtime");
    1042             :                 succeed_if (keySetCTime (key, far_future) == 0, "could not set ctime");
    1043             : 
    1044             :                 succeed_if (keyGetATime(key) == far_future, "new initialized atime not 0");
    1045             :                 succeed_if (keyGetMTime(key) == far_future, "new initialized mtime not 0");
    1046             :                 succeed_if (keyGetCTime(key) == far_future, "new initialized ctime not 0");
    1047             : 
    1048             :                 warn_if_fail (keyGetATime(key) > 0, "time_t not 64 bit, 2038 problem");
    1049             :                 warn_if_fail (keyGetMTime(key) > 0, "time_t not 64 bit, 2038 problem");
    1050             :                 warn_if_fail (keyGetCTime(key) > 0, "time_t not 64 bit, 2038 problem");
    1051             :         */
    1052             : 
    1053           2 :         keyDel (key);
    1054           2 : }
    1055             : 
    1056           2 : static void test_keyMeta (void)
    1057             : {
    1058           2 :         Key * key = 0;
    1059             : 
    1060           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid null pointer");
    1061           2 :         succeed_if (keyGetGID (key) == (gid_t) -1, "gid null pointer");
    1062           2 :         succeed_if (keyGetMode (key) == (mode_t) -1, "mode null pointer");
    1063             : 
    1064           2 :         key = 0;
    1065           2 :         succeed_if (keyNeedSync (key) == -1, "key needs sync");
    1066           2 :         key = keyNew (0);
    1067           2 :         succeed_if (keyNeedSync (key) == 0, "fresh key needs sync");
    1068           2 :         keyDel (key);
    1069             : 
    1070           2 :         key = keyNew ("user/remove", KEY_END);
    1071           2 :         succeed_if (keyNeedSync (key) == 1, "need sync");
    1072           2 :         keyDel (key);
    1073             : 
    1074           2 :         succeed_if (keyNeedSync (0) == -1, "keyNeedSync(0)");
    1075             : 
    1076           2 :         key = keyNew (0);
    1077           2 :         succeed_if (keyNeedSync (key) == 0, "keyNew(0) should not need sync");
    1078           2 :         succeed_if (keySetName (key, "invalid") == -1, "invalid name should fail");
    1079           2 :         succeed_if (keyNeedSync (key) == 0, "keyNew(0) should not need sync");
    1080           2 :         keyDel (key);
    1081             : 
    1082           2 :         key = keyNew (0);
    1083           2 :         succeed_if (keyNeedSync (key) == 0, "should not need sync");
    1084           2 :         keySetUID (key, 20);
    1085           2 :         succeed_if (keyNeedSync (key) == 1, "should need sync");
    1086           2 :         keyDel (key);
    1087             : 
    1088           2 :         key = keyNew (0);
    1089           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid not set to nobody");
    1090           2 :         succeed_if (keyGetGID (key) == (gid_t) -1, "gid not set to nobody");
    1091             : 
    1092           2 :         succeed_if (keySetUID (key, 20) == 0, "could not set uid");
    1093           2 :         succeed_if (keySetGID (key, 21) == 0, "could not set uid");
    1094             : 
    1095           2 :         succeed_if (keyGetUID (key) == 20, "uid not set to 20");
    1096           2 :         succeed_if (keyGetGID (key) == 21, "gid not set to 21");
    1097             : 
    1098           2 :         succeed_if (keySetUID (key, (uid_t) -1) == 0, "could not set uid");
    1099           2 :         succeed_if (keySetGID (key, (gid_t) -1) == 0, "could not set uid");
    1100             : 
    1101           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid not set to nobody");
    1102           2 :         succeed_if (keyGetGID (key) == (gid_t) -1, "gid not set to nobody");
    1103             : 
    1104           2 :         succeed_if (keySetUID (key, 0) == 0, "could not set uid");
    1105           2 :         succeed_if (keySetGID (key, 0) == 0, "could not set uid");
    1106             : 
    1107           2 :         succeed_if (keyGetUID (key) == 0, "uid not set to 20");
    1108           2 :         succeed_if (keyGetGID (key) == 0, "gid not set to 21");
    1109           2 :         keyDel (key);
    1110             : 
    1111           2 :         key = keyNew (0);
    1112           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "new key does not have default mode");
    1113           2 :         succeed_if (keySetDir (key) == 0, "could not set dir");
    1114           2 :         succeed_if (keyGetMode (key) == (KDB_FILE_MODE | KDB_DIR_MODE), "directory key");
    1115           2 :         keyDel (key);
    1116             : 
    1117           2 :         key = keyNew ("user/dir", KEY_DIR, KEY_END);
    1118           2 :         succeed_if (keyGetMode (key) == (KDB_FILE_MODE | KDB_DIR_MODE), "directory key");
    1119           2 :         succeed_if (keySetDir (key) == 0, "could not set dir");
    1120           2 :         succeed_if (keyGetMode (key) == (KDB_FILE_MODE | KDB_DIR_MODE), "directory key");
    1121           2 :         keyDel (key);
    1122           2 : }
    1123             : 
    1124           2 : static void test_elektraKeySetName (void)
    1125             : {
    1126           2 :         printf ("test elektraKeySetName\n");
    1127             : 
    1128           2 :         Key * key = keyNew ("", KEY_END);
    1129           2 :         Key * dup = 0;
    1130             : 
    1131           2 :         succeed_if (elektraKeySetName (key, "/", KEY_CASCADING_NAME) != -1, "could not set cascading name");
    1132           2 :         succeed_if_same_string (keyName (key), "/");
    1133           2 :         dup = keyDup (key);
    1134           2 :         succeed_if_same_string (keyName (dup), "/");
    1135           2 :         keyDel (dup);
    1136             : 
    1137           2 :         elektraKeySetName (key, "/c", KEY_CASCADING_NAME);
    1138           2 :         succeed_if_same_string (keyName (key), "/c");
    1139           2 :         dup = keyDup (key);
    1140           2 :         succeed_if_same_string (keyName (dup), "/c");
    1141           2 :         keyDel (dup);
    1142             : 
    1143           2 :         succeed_if (elektraKeySetName (key, "/", KEY_CASCADING_NAME) != -1, "could not set cascading name");
    1144           2 :         succeed_if_same_string (keyName (key), "/");
    1145           2 :         elektraKeySetName (key, "/cascading", KEY_CASCADING_NAME);
    1146           2 :         succeed_if_same_string (keyName (key), "/cascading");
    1147           2 :         dup = keyDup (key);
    1148           2 :         succeed_if_same_string (keyName (dup), "/cascading");
    1149           2 :         keyDel (dup);
    1150             : 
    1151           2 :         elektraKeySetName (key, "/cascading/s/deep/below", KEY_CASCADING_NAME);
    1152           2 :         succeed_if_same_string (keyName (key), "/cascading/s/deep/below");
    1153           2 :         dup = keyDup (key);
    1154           2 :         succeed_if_same_string (keyName (dup), "/cascading/s/deep/below");
    1155           2 :         keyDel (dup);
    1156             : 
    1157           2 :         elektraKeySetName (key, "user/cascading/s/deep/below", KEY_CASCADING_NAME);
    1158           2 :         succeed_if_same_string (keyName (key), "user/cascading/s/deep/below");
    1159           2 :         dup = keyDup (key);
    1160           2 :         succeed_if_same_string (keyName (dup), "user/cascading/s/deep/below");
    1161           2 :         keyDel (dup);
    1162             : 
    1163           2 :         elektraKeySetName (key, "system/cascading/s/deep/below", KEY_CASCADING_NAME);
    1164           2 :         succeed_if_same_string (keyName (key), "system/cascading/s/deep/below");
    1165           2 :         dup = keyDup (key);
    1166           2 :         succeed_if_same_string (keyName (dup), "system/cascading/s/deep/below");
    1167           2 :         keyDel (dup);
    1168             : 
    1169           2 :         elektraKeySetName (key, "order", KEY_META_NAME);
    1170           2 :         succeed_if_same_string (keyName (key), "order");
    1171           2 :         dup = keyDup (key);
    1172           2 :         succeed_if_same_string (keyName (dup), "order");
    1173           2 :         keyDel (dup);
    1174             : 
    1175           2 :         elektraKeySetName (key, "check/type", KEY_META_NAME);
    1176           2 :         succeed_if_same_string (keyName (key), "check/type");
    1177           2 :         dup = keyDup (key);
    1178           2 :         succeed_if_same_string (keyName (dup), "check/type");
    1179           2 :         keyDel (dup);
    1180             : 
    1181           2 :         elektraKeySetName (key, "a", KEY_META_NAME);
    1182           2 :         succeed_if_same_string (keyName (key), "a");
    1183           2 :         dup = keyDup (key);
    1184           2 :         succeed_if_same_string (keyName (dup), "a");
    1185           2 :         keyDel (dup);
    1186             : 
    1187           2 :         elektraKeySetName (key, "", KEY_EMPTY_NAME);
    1188           2 :         succeed_if_same_string (keyName (key), "");
    1189           2 :         succeed_if (key->key != 0, "null pointer?");
    1190           2 :         dup = keyDup (key);
    1191           2 :         succeed_if_same_string (keyName (dup), "");
    1192           2 :         keyDel (dup);
    1193             : 
    1194           2 :         elektraKeySetName (key, "", KEY_META_NAME | KEY_EMPTY_NAME);
    1195           2 :         succeed_if_same_string (keyName (key), "");
    1196           2 :         succeed_if (key->key != 0, "null pointer?");
    1197           2 :         dup = keyDup (key);
    1198           2 :         succeed_if_same_string (keyName (dup), "");
    1199           2 :         keyDel (dup);
    1200             : 
    1201           2 :         keySetName (key, 0);
    1202           2 :         succeed_if_same_string (keyName (key), "");
    1203           2 :         succeed_if (key->key != 0, "null pointer?");
    1204           2 :         dup = keyDup (key);
    1205           2 :         succeed_if_same_string (keyName (dup), "");
    1206           2 :         keyDel (dup);
    1207             : 
    1208           2 :         elektraKeySetName (key, "", KEY_META_NAME | KEY_CASCADING_NAME);
    1209           2 :         succeed_if_same_string (keyName (key), "");
    1210           2 :         succeed_if (key->key != 0, "null pointer?");
    1211           2 :         dup = keyDup (key);
    1212           2 :         succeed_if_same_string (keyName (dup), "");
    1213           2 :         keyDel (dup);
    1214             : 
    1215           2 :         elektraKeySetName (key, "/cascading", KEY_META_NAME | KEY_CASCADING_NAME);
    1216           2 :         succeed_if_same_string (keyName (key), "/cascading");
    1217           2 :         succeed_if (key->key != 0, "null pointer?");
    1218           2 :         dup = keyDup (key);
    1219           2 :         succeed_if_same_string (keyName (dup), "/cascading");
    1220           2 :         keyDel (dup);
    1221             : 
    1222           2 :         elektraKeySetName (key, "meta", KEY_META_NAME | KEY_CASCADING_NAME);
    1223           2 :         succeed_if_same_string (keyName (key), "meta");
    1224           2 :         succeed_if (key->key != 0, "null pointer?");
    1225           2 :         dup = keyDup (key);
    1226           2 :         succeed_if_same_string (keyName (dup), "meta");
    1227           2 :         keyDel (dup);
    1228             : 
    1229           2 :         elektraKeySetName (key, "other", KEY_META_NAME | KEY_CASCADING_NAME);
    1230           2 :         succeed_if_same_string (keyName (key), "other");
    1231           2 :         succeed_if (key->key != 0, "null pointer?");
    1232           2 :         dup = keyDup (key);
    1233           2 :         succeed_if_same_string (keyName (dup), "other");
    1234           2 :         keyDel (dup);
    1235             : 
    1236           2 :         elektraKeySetName (key, "other///meta", KEY_META_NAME | KEY_CASCADING_NAME);
    1237           2 :         succeed_if_same_string (keyName (key), "other/meta");
    1238           2 :         succeed_if (key->key != 0, "null pointer?");
    1239           2 :         dup = keyDup (key);
    1240           2 :         succeed_if_same_string (keyName (dup), "other/meta");
    1241           2 :         keyDel (dup);
    1242             : 
    1243           2 :         elektraKeySetName (key, "user:hello/test", KEY_META_NAME | KEY_CASCADING_NAME);
    1244           2 :         succeed_if_same_string (keyName (key), "user/test");
    1245           2 :         succeed_if (key->key != 0, "null pointer?");
    1246           2 :         dup = keyDup (key);
    1247           2 :         succeed_if_same_string (keyName (dup), "user/test");
    1248           2 :         keyDel (dup);
    1249             : 
    1250          18 :         for (int i = 0; i < 8; ++i)
    1251             :         {
    1252          16 :                 int flags = 0;
    1253          16 :                 if (i & 1) flags |= KEY_CASCADING_NAME;
    1254          16 :                 if (i & 2) flags |= KEY_META_NAME;
    1255          16 :                 if (i & 4) flags |= KEY_EMPTY_NAME;
    1256             : 
    1257          16 :                 elektraKeySetName (key, "spec/test", flags);
    1258          16 :                 succeed_if_same_string (keyName (key), "spec/test");
    1259          16 :                 succeed_if (key->key != 0, "null pointer?");
    1260          16 :                 dup = keyDup (key);
    1261          16 :                 succeed_if_same_string (keyName (dup), "spec/test");
    1262          16 :                 keyDel (dup);
    1263             : 
    1264          16 :                 elektraKeySetName (key, "proc/test", flags);
    1265          16 :                 succeed_if_same_string (keyName (key), "proc/test");
    1266          16 :                 succeed_if (key->key != 0, "null pointer?");
    1267          16 :                 dup = keyDup (key);
    1268          16 :                 succeed_if_same_string (keyName (dup), "proc/test");
    1269          16 :                 keyDel (dup);
    1270             : 
    1271          16 :                 elektraKeySetName (key, "dir/test", flags);
    1272          16 :                 succeed_if_same_string (keyName (key), "dir/test");
    1273          16 :                 succeed_if (key->key != 0, "null pointer?");
    1274          16 :                 dup = keyDup (key);
    1275          16 :                 succeed_if_same_string (keyName (dup), "dir/test");
    1276          16 :                 keyDel (dup);
    1277             : 
    1278          16 :                 elektraKeySetName (key, "user:hello/test", flags);
    1279          16 :                 succeed_if_same_string (keyName (key), "user/test");
    1280          16 :                 succeed_if (key->key != 0, "null pointer?");
    1281          16 :                 dup = keyDup (key);
    1282          16 :                 succeed_if_same_string (keyName (dup), "user/test");
    1283          16 :                 keyDel (dup);
    1284             : 
    1285          16 :                 elektraKeySetName (key, "system/test", flags);
    1286          16 :                 succeed_if_same_string (keyName (key), "system/test");
    1287          16 :                 succeed_if (key->key != 0, "null pointer?");
    1288          16 :                 dup = keyDup (key);
    1289          16 :                 succeed_if_same_string (keyName (dup), "system/test");
    1290          16 :                 keyDel (dup);
    1291             :         }
    1292             : 
    1293           2 :         keyDel (key);
    1294           2 : }
    1295             : 
    1296           2 : static void test_keyLock (void)
    1297             : {
    1298           2 :         printf ("Test locking\n");
    1299             : 
    1300           2 :         Key * key = keyNew ("", KEY_LOCK_NAME, KEY_END);
    1301           2 :         Key * key2 = keyNew ("", KEY_LOCK_NAME, KEY_END);
    1302             : 
    1303           2 :         succeed_if (keySetName (key, "user") == -1, "read only name, not allowed to set");
    1304             : 
    1305           2 :         keyDel (key);
    1306           2 :         key = keyNew ("", KEY_LOCK_VALUE, KEY_END);
    1307             : 
    1308           2 :         succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
    1309           2 :         succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
    1310             : 
    1311           2 :         keyDel (key);
    1312           2 :         key = keyNew ("", KEY_LOCK_META, KEY_END);
    1313             : 
    1314           2 :         succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
    1315           2 :         succeed_if (keyCopyMeta (key, key2, "meta") == -1, "read only meta, not allowed to set");
    1316           2 :         succeed_if (keyCopyAllMeta (key, key2) == -1, "read only meta, not allowed to set");
    1317             : 
    1318           2 :         keyDel (key);
    1319           2 :         key = keyNew (0);
    1320             : 
    1321           2 :         keyLock (key, KEY_LOCK_NAME);
    1322           2 :         succeed_if (keySetName (key, "user") == -1, "read only name, not allowed to set");
    1323           2 :         succeed_if (keyAddName (key, "a") == -1, "read only name, not allowed to set");
    1324           2 :         succeed_if (keySetBaseName (key, "a") == -1, "read only name, not allowed to set");
    1325           2 :         succeed_if (keyAddBaseName (key, "a") == -1, "read only name, not allowed to set");
    1326             : 
    1327           2 :         keyDel (key);
    1328           2 :         key = keyNew (0);
    1329             : 
    1330           2 :         keyLock (key, KEY_LOCK_VALUE);
    1331             : 
    1332           2 :         succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
    1333           2 :         succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
    1334             : 
    1335           2 :         keyDel (key);
    1336           2 :         key = keyNew (0);
    1337             : 
    1338           2 :         keyLock (key, KEY_LOCK_META);
    1339             : 
    1340           2 :         succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
    1341           2 :         succeed_if (keyCopyMeta (key, key2, "meta") == -1, "read only meta, not allowed to set");
    1342           2 :         succeed_if (keyCopyAllMeta (key, key2) == -1, "read only meta, not allowed to set");
    1343             : 
    1344           2 :         keyDel (key);
    1345           2 :         keyDel (key2);
    1346           2 : }
    1347             : 
    1348             : 
    1349           2 : static void test_keyAddName (void)
    1350             : {
    1351           2 :         Key * k = keyNew ("user", KEY_END);
    1352           2 :         keyAddName (k, "something");
    1353           2 :         succeed_if_same_string (keyName (k), "user/something");
    1354             : 
    1355           2 :         keyAddName (k, "with/slash");
    1356           2 :         succeed_if_same_string (keyName (k), "user/something/with/slash");
    1357           2 :         keyDel (k);
    1358             : 
    1359             : #define TEST_ADD_NAME(base, toadd, result)                                                                                                 \
    1360             :         do                                                                                                                                 \
    1361             :         {                                                                                                                                  \
    1362             :                 k = keyNew (base, KEY_META_NAME, KEY_CASCADING_NAME, KEY_END);                                                             \
    1363             :                 succeed_if (keyAddName (k, toadd) == sizeof (result), "could not add name");                                               \
    1364             :                 succeed_if_same_string (keyName (k), result);                                                                              \
    1365             :                 keyDel (k);                                                                                                                \
    1366             :         } while (0)
    1367             : 
    1368           2 :         TEST_ADD_NAME ("spec", "something", "spec/something");
    1369           2 :         TEST_ADD_NAME ("proc", "something", "proc/something");
    1370           2 :         TEST_ADD_NAME ("dir", "something", "dir/something");
    1371           2 :         TEST_ADD_NAME ("user", "something", "user/something");
    1372           2 :         TEST_ADD_NAME ("system", "something", "system/something");
    1373             : 
    1374           2 :         TEST_ADD_NAME ("meta", "something", "meta/something");
    1375           2 :         TEST_ADD_NAME ("meta/", "something", "meta/something");
    1376           2 :         TEST_ADD_NAME ("meta//", "something", "meta/something");
    1377             : 
    1378           2 :         TEST_ADD_NAME ("meta", "something/", "meta/something");
    1379           2 :         TEST_ADD_NAME ("meta", "something//", "meta/something");
    1380             : 
    1381           2 :         TEST_ADD_NAME ("meta", "/something", "meta/something");
    1382           2 :         TEST_ADD_NAME ("meta", "//something", "meta/something");
    1383             : 
    1384           2 :         TEST_ADD_NAME ("user", "./user", "user/user");
    1385           2 :         TEST_ADD_NAME ("user/", "./user", "user/user");
    1386           2 :         TEST_ADD_NAME ("user/", "/./user", "user/user");
    1387           2 :         TEST_ADD_NAME ("user/", "/////./user", "user/user");
    1388           2 :         TEST_ADD_NAME ("user", "../user", "user/user");
    1389             : 
    1390           2 :         TEST_ADD_NAME ("user/verylongstringtoremove", "../x", "user/x");
    1391           2 :         TEST_ADD_NAME ("user/huhu", "../x", "user/x");
    1392           2 :         TEST_ADD_NAME ("user/rem", "../x", "user/x");
    1393           2 :         TEST_ADD_NAME ("user/more/level", "../../x", "user/x");
    1394             : 
    1395           2 :         TEST_ADD_NAME ("user/something", "../user", "user/user");
    1396             : 
    1397           2 :         TEST_ADD_NAME ("/something", "user", "/something/user");
    1398           2 :         TEST_ADD_NAME ("/", "user", "/user");
    1399           2 :         TEST_ADD_NAME ("/s", "user", "/s/user");
    1400           2 :         TEST_ADD_NAME ("/s", "/user", "/s/user");
    1401           2 :         TEST_ADD_NAME ("/s", "../user", "/user");
    1402           2 :         TEST_ADD_NAME ("/s", "..//user", "/user");
    1403           2 :         TEST_ADD_NAME ("/more/level", "../..//user", "/user");
    1404           2 :         TEST_ADD_NAME ("/much/more/level/1/2/3", "../../../../../..//user", "/user");
    1405           2 :         TEST_ADD_NAME ("/much/more/level/1/2/3", "../../../../../../..//user", "/user");
    1406           2 :         TEST_ADD_NAME ("/much/more/level/1/2/3", "..///../../../../../../..//user", "/user");
    1407           2 :         TEST_ADD_NAME ("/much/more/level/1/2/3", "..///../../..////../../../..//user", "/user");
    1408           2 :         TEST_ADD_NAME ("/much/more/level/1/2/3", "../../....///../../..////../../../..//user", "/user");
    1409           2 :         TEST_ADD_NAME ("/s", ".../user", "/s/.../user");
    1410           2 :         TEST_ADD_NAME ("/s", "..a/user", "/s/..a/user");
    1411           2 :         TEST_ADD_NAME ("/s", "..../user", "/s/..../user");
    1412             : 
    1413             :         // TEST_ADD_NAME("user", "///sw/../sw//././MyApp", "user/sw/MyApp");
    1414           2 :         TEST_ADD_NAME ("user", "sw/../sw", "user/sw");
    1415             : 
    1416             : #undef TEST_ADD_NAME
    1417             : #define TEST_ADD_NAME(base, toadd, result)                                                                                                 \
    1418             :         do                                                                                                                                 \
    1419             :         {                                                                                                                                  \
    1420             :                 k = keyNew (base, KEY_META_NAME, KEY_CASCADING_NAME, KEY_END);                                                             \
    1421             :                 succeed_if (keyAddName (k, toadd) == 0, "adding irrelevant wrong return");                                                 \
    1422             :                 succeed_if_same_string (keyName (k), result);                                                                              \
    1423             :                 keyDel (k);                                                                                                                \
    1424             :         } while (0)
    1425             : 
    1426           2 :         TEST_ADD_NAME ("/", 0, "/");
    1427           2 :         TEST_ADD_NAME ("/", "", "/");
    1428           2 :         TEST_ADD_NAME ("/", "/", "/");
    1429           2 :         TEST_ADD_NAME ("/", "//", "/");
    1430           2 :         TEST_ADD_NAME ("//", "/", "/");
    1431           2 :         TEST_ADD_NAME ("//", "//", "/");
    1432           2 :         TEST_ADD_NAME ("///", "//", "/");
    1433           2 :         TEST_ADD_NAME ("//", "///", "/");
    1434           2 :         TEST_ADD_NAME ("///", "///", "/");
    1435           2 :         TEST_ADD_NAME ("///.", "///", "/");
    1436           2 :         TEST_ADD_NAME ("///.", "///.", "/");
    1437           2 :         TEST_ADD_NAME ("///.", "///./", "/");
    1438           2 :         TEST_ADD_NAME ("///./", "///.", "/");
    1439           2 :         TEST_ADD_NAME ("///./", "///./", "/");
    1440           2 :         TEST_ADD_NAME ("///./..", "///./", "/");
    1441           2 :         TEST_ADD_NAME ("///./..", "///./..", "/");
    1442           2 :         TEST_ADD_NAME ("///./..", "///./../", "/");
    1443           2 :         TEST_ADD_NAME ("///./../", "///./..", "/");
    1444           2 :         TEST_ADD_NAME ("///./../", "///./../", "/");
    1445             : 
    1446           2 :         k = keyNew ("system/elektra/mountpoints/_t_error/config", KEY_END);
    1447           2 :         keyAddName (k, "on_open/error");
    1448           2 :         succeed_if_same_string (keyName (k), "system/elektra/mountpoints/_t_error/config/on_open/error");
    1449           2 :         keyDel (k);
    1450             : 
    1451           2 :         k = keyNew ("user", KEY_END);
    1452           2 :         succeed_if (keyAddName (k, "bar\\/foo_bar\\/") == sizeof ("user/bar\\/foo_bar\\/"), "could not add name");
    1453           2 :         succeed_if_same_string (keyName (k), "user/bar\\/foo_bar\\/");
    1454           2 :         keyDel (k);
    1455             : 
    1456           2 :         k = keyNew ("user", KEY_END);
    1457           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\/") == sizeof ("user/ba\\\\/foo_bar\\/"), "could not add name");
    1458           2 :         succeed_if_same_string (keyName (k), "user/ba\\\\/foo_bar\\/");
    1459           2 :         keyDel (k);
    1460             : 
    1461           2 :         k = keyNew ("user", KEY_END);
    1462           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("user/ba\\\\/foo_bar\\//%"), "could not add name");
    1463           2 :         succeed_if_same_string (keyName (k), "user/ba\\\\/foo_bar\\//%");
    1464           2 :         keyDel (k);
    1465             : 
    1466           2 :         k = keyNew ("user:yl", KEY_END);
    1467           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("user/ba\\\\/foo_bar\\//%"), "could not add name");
    1468           2 :         succeed_if_same_string (keyName (k), "user/ba\\\\/foo_bar\\//%");
    1469           2 :         keyDel (k);
    1470             : 
    1471           2 :         k = keyNew ("user:yl", KEY_END);
    1472           2 :         succeed_if (keyAddName (k, "ba\\\\foo_bar\\//%") == sizeof ("user/ba\\\\foo_bar\\//%"), "could not add name");
    1473           2 :         succeed_if_same_string (keyName (k), "user/ba\\\\foo_bar\\//%");
    1474           2 :         keyDel (k);
    1475             : 
    1476           2 :         k = keyNew ("system", KEY_END);
    1477           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("system/ba\\\\/foo_bar\\//%"), "could not add name");
    1478           2 :         succeed_if_same_string (keyName (k), "system/ba\\\\/foo_bar\\//%");
    1479           2 :         keyDel (k);
    1480             : 
    1481           2 :         k = keyNew ("meta", KEY_META_NAME, KEY_END);
    1482           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("meta/ba\\\\/foo_bar\\//%"), "could not add name");
    1483           2 :         succeed_if_same_string (keyName (k), "meta/ba\\\\/foo_bar\\//%");
    1484           2 :         keyDel (k);
    1485             : 
    1486           2 :         k = keyNew ("/", KEY_CASCADING_NAME, KEY_END);
    1487           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("/ba\\\\/foo_bar\\//%"), "could not add name");
    1488           2 :         succeed_if_same_string (keyName (k), "/ba\\\\/foo_bar\\//%");
    1489           2 :         keyDel (k);
    1490             : 
    1491           2 :         k = keyNew ("/", KEY_CASCADING_NAME, KEY_END);
    1492           2 :         succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("/ba\\\\/foo_bar\\//%"), "could not add name");
    1493           2 :         succeed_if_same_string (keyName (k), "/ba\\\\/foo_bar\\//%");
    1494           2 :         keyDel (k);
    1495             : 
    1496           2 :         k = keyNew ("/", KEY_CASCADING_NAME, KEY_END);
    1497           2 :         succeed_if (keyAddName (k, "/\\\\/foo_bar\\//%") == sizeof ("/\\\\/foo_bar\\//%"), "could not add name");
    1498           2 :         succeed_if_same_string (keyName (k), "/\\\\/foo_bar\\//%");
    1499           2 :         keyDel (k);
    1500           2 : }
    1501             : 
    1502           2 : static void test_keyNeedSync (void)
    1503             : {
    1504           2 :         printf ("Test key need sync\n");
    1505             : 
    1506           2 :         Key * k = keyNew (0);
    1507           2 :         succeed_if (!keyNeedSync (k), "no sync, because written like that in docu prior to 0.8.9");
    1508           2 :         keyDel (k);
    1509             : 
    1510           2 :         k = keyNew ("", KEY_END);
    1511           2 :         succeed_if (keyNeedSync (k), "fresh key should need sync");
    1512             : 
    1513           2 :         set_bit (k->flags, KEY_FLAG_SYNC);
    1514           2 :         succeed_if (keyNeedSync (k), "sync bit was set");
    1515           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1516           2 :         succeed_if (!keyNeedSync (k), "sync bit was cleared");
    1517             : 
    1518           2 :         keySetName (k, "");
    1519           2 :         succeed_if (keyNeedSync (k), "nothing done, but synced (impl-dep, could be optimized)");
    1520             : 
    1521           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1522           2 :         keySetName (k, "user/abc");
    1523           2 :         succeed_if (keyNeedSync (k), "new name, should definitely need sync");
    1524             : 
    1525           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1526           2 :         keySetString (k, "a str");
    1527           2 :         succeed_if (keyNeedSync (k), "new string, should definitely need sync");
    1528             : 
    1529           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1530           2 :         keySetBinary (k, "a str", 4);
    1531           2 :         succeed_if (keyNeedSync (k), "new binary, should definitely need sync");
    1532             : 
    1533           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1534           2 :         keySetMeta (k, "metakey", "metaval");
    1535           2 :         succeed_if (keyNeedSync (k), "new meta, should definitely need sync");
    1536             : 
    1537           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1538           2 :         Key * d = keyDup (k);
    1539           2 :         succeed_if (keyNeedSync (d), "dup key, should definitely need sync");
    1540             : 
    1541           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1542           2 :         clear_bit (d->flags, KEY_FLAG_SYNC);
    1543           2 :         succeed_if (keyCopy (d, k) != -1, "copy not successful");
    1544           2 :         succeed_if (keyNeedSync (d), "copy key, should definitely need sync");
    1545           2 :         succeed_if (!keyNeedSync (k), "sources sync flag should not be affected");
    1546           2 :         keyDel (d);
    1547             : 
    1548           2 :         keyIncRef (k);
    1549           2 :         succeed_if (!keyNeedSync (k), "ref counter should not affect sync");
    1550           2 :         keyDecRef (k);
    1551           2 :         succeed_if (!keyNeedSync (k), "ref counter should not affect sync");
    1552             : 
    1553             : 
    1554           2 :         keySetName (k, "");
    1555           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1556             : 
    1557           2 :         succeed_if (keySetBaseName (k, "") == -1, "could not set base name");
    1558           2 :         succeed_if (!keyNeedSync (k), "nothing done, so still no sync (impl-dep, could be deoptimized)");
    1559             : 
    1560           2 :         keySetName (k, "user/abc");
    1561           2 :         succeed_if (keyNeedSync (k), "name set, sync should be there");
    1562             : 
    1563           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1564           2 :         succeed_if (keySetBaseName (k, "xynz") != -1, "could not set base name");
    1565           2 :         succeed_if (keyNeedSync (k), "base name changed, sync should be there");
    1566             : 
    1567           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1568           2 :         succeed_if (keyAddBaseName (k, "foo") != -1, "could not add base name");
    1569           2 :         succeed_if (keyNeedSync (k), "base name changed, sync should be there");
    1570             : 
    1571           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1572           2 :         succeed_if (keyAddName (k, "bar") != -1, "could not add name");
    1573           2 :         succeed_if (keyNeedSync (k), "base name changed, sync should be there");
    1574             : 
    1575           2 :         clear_bit (k->flags, KEY_FLAG_SYNC);
    1576           2 :         succeed_if (keySetOwner (k, "someowner") != -1, "could not set owner");
    1577           2 :         succeed_if (keyNeedSync (k), "owner changed, sync should be there");
    1578             : 
    1579           2 :         keyDel (k);
    1580           2 : }
    1581             : 
    1582           2 : static void test_keyCopy (void)
    1583             : {
    1584           2 :         printf ("test copy key\n");
    1585           2 :         Key * k = keyNew ("", KEY_END);
    1586           2 :         Key * c = keyNew ("user/name", KEY_END);
    1587             : 
    1588           2 :         succeed_if (keyCopy (c, k) != -1, "could not copy");
    1589           2 :         succeed_if_same_string (keyName (k), "");
    1590           2 :         succeed_if_same_string (keyName (c), "");
    1591             : 
    1592           2 :         succeed_if (elektraKeySetName (k, "/abc", KEY_CASCADING_NAME) != -1, "could not set cascading name");
    1593           2 :         succeed_if (keyCopy (c, k) != -1, "could not copy");
    1594           2 :         succeed_if_same_string (keyName (k), "/abc");
    1595           2 :         succeed_if_same_string (keyName (c), "/abc");
    1596             : 
    1597           2 :         keyDel (k);
    1598           2 :         keyDel (c);
    1599           2 : }
    1600             : 
    1601           2 : static void test_keyFixedNew (void)
    1602             : {
    1603           2 :         printf ("test fixed new\n");
    1604           2 :         Key * k1 = keyNew (0);
    1605           2 :         Key * k2 = keyNew ("", KEY_SIZE, 0, KEY_VALUE, 0, KEY_END);
    1606           2 :         compare_key (k1, k2);
    1607           2 :         keyDel (k1);
    1608           2 :         keyDel (k2);
    1609             : 
    1610           2 :         k1 = keyNew ("user/hello", KEY_END);
    1611           2 :         k2 = keyNew ("user/hello", KEY_SIZE, 0, KEY_VALUE, 0, KEY_END);
    1612           2 :         compare_key (k1, k2);
    1613           2 :         keyDel (k1);
    1614           2 :         keyDel (k2);
    1615             : 
    1616           2 :         k1 = keyNew ("user/hello", KEY_VALUE, "hello", KEY_END);
    1617           2 :         k2 = keyNew ("user/hello", KEY_SIZE, 6, KEY_VALUE, "hello", KEY_END);
    1618           2 :         compare_key (k1, k2);
    1619           2 :         keyDel (k1);
    1620           2 :         keyDel (k2);
    1621           2 : }
    1622             : 
    1623           2 : static void test_keyFlags (void)
    1624             : {
    1625           2 :         printf ("Test KEY_FLAGS\n");
    1626             : 
    1627           2 :         Key * key = keyNew ("user/foo", KEY_FLAGS, KEY_BINARY | KEY_LOCK_NAME | KEY_LOCK_VALUE | KEY_LOCK_META, KEY_END);
    1628           2 :         Key * key2 = NULL;
    1629             : 
    1630           2 :         succeed_if (keyIsBinary (key), "Could not set type to binary");
    1631             : 
    1632           2 :         succeed_if (keySetName (key, "system") == -1, "read only name, not allowed to set");
    1633           2 :         succeed_if (keyAddName (key, "bar") == -1, "read only name, not allowed to set");
    1634           2 :         succeed_if (keyAddBaseName (key, "bar") == -1, "read only name, not allowed to set");
    1635             : 
    1636           2 :         succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
    1637           2 :         succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
    1638             : 
    1639           2 :         succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
    1640           2 :         succeed_if (keyCopyMeta (key, key2, "meta") == -1, "read only meta, not allowed to set");
    1641           2 :         succeed_if (keyCopyAllMeta (key, key2) == -1, "read only meta, not allowed to set");
    1642             : 
    1643           2 :         keyDel (key);
    1644           2 :         keyDel (key2);
    1645           2 : }
    1646             : 
    1647           2 : int main (int argc, char ** argv)
    1648             : {
    1649           2 :         printf ("KEY      TESTS\n");
    1650           2 :         printf ("==================\n\n");
    1651             : 
    1652           2 :         init (argc, argv);
    1653             : 
    1654           2 :         test_keyRefcounter ();
    1655           2 :         test_keyHelpers ();
    1656           2 :         test_keyPlugin ();
    1657           2 :         test_keyNameEscape ();
    1658           2 :         test_keyNameUnescape ();
    1659           2 :         test_keyCompare ();
    1660           2 :         test_keyNewExtensions ();
    1661           2 :         test_keyComment ();
    1662           2 :         test_keyOwner ();
    1663           2 :         test_keyComment ();
    1664           2 :         test_keyDir ();
    1665           2 :         test_keyTime ();
    1666           2 :         test_keyMeta ();
    1667           2 :         test_owner ();
    1668           2 :         test_elektraKeySetName ();
    1669           2 :         test_keyLock ();
    1670           2 :         test_keyAddName ();
    1671           2 :         test_keyNeedSync ();
    1672           2 :         test_keyCopy ();
    1673           2 :         test_keyFixedNew ();
    1674           2 :         test_keyFlags ();
    1675             : 
    1676           2 :         printf ("\ntest_key RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
    1677             : 
    1678           2 :         return nbError;
    1679             : }

Generated by: LCOV version 1.13