LCOV - code coverage report
Current view: top level - tests/ctest - test_meta.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 311 311 100.0 %
Date: 2019-09-12 12:28:41 Functions: 13 13 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 <kdbproposal.h>
      10             : #include <tests_internal.h>
      11             : 
      12           2 : static void test_ro (void)
      13             : {
      14             :         Key * key;
      15             : 
      16           2 :         key = keyNew (0);
      17           2 :         key->flags |= KEY_FLAG_RO_VALUE;
      18             : 
      19           2 :         succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
      20           2 :         succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
      21             : 
      22           2 :         key->flags |= KEY_FLAG_RO_NAME;
      23           2 :         succeed_if (keySetName (key, "user") == -1, "read only name, not allowed to set");
      24             : 
      25           2 :         key->flags |= KEY_FLAG_RO_META;
      26           2 :         succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
      27             : 
      28           2 :         keyDel (key);
      29           2 : }
      30             : 
      31           2 : static void test_uid (void)
      32             : {
      33             :         Key * key;
      34             : 
      35           2 :         key = keyNew ("user/uid", KEY_UID, 100, KEY_END);
      36           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "100");
      37           2 :         succeed_if (keyGetUID (key) == 100, "uid was not set correctly");
      38             : 
      39           2 :         succeed_if (keySetUID (key, 101) == 0, "could not set uid");
      40           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "101");
      41           2 :         succeed_if (keyGetUID (key) == 101, "uid was not set correctly");
      42             : 
      43           2 :         succeed_if (keySetUID (key, 0) == 0, "could not set uid");
      44           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "0");
      45           2 :         succeed_if (keyGetUID (key) == 0, "uid was not set correctly");
      46             : 
      47           2 :         succeed_if (keySetUID (key, (uid_t) -1) == 0, "could not set uid");
      48           2 :         warn_if_fail (!strcmp (keyValue (keyGetMeta (key, "uid")), "-1"),
      49             :                       "this is for 64bit, other platforms might have other results here");
      50           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
      51             : 
      52           2 :         succeed_if (keySetMeta (key, "uid", "102") == sizeof ("102"), "could not set meta");
      53           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "102");
      54           2 :         succeed_if (keyGetUID (key) == 102, "uid was not set correctly");
      55             : 
      56           2 :         succeed_if (keySetMeta (key, "uid", "x") == sizeof ("x"), "could not set meta");
      57           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "x");
      58           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
      59             : 
      60           2 :         succeed_if (keySetMeta (key, "uid", "x1") == sizeof ("x1"), "could not set meta");
      61           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "x1");
      62           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
      63             : 
      64           2 :         succeed_if (keySetMeta (key, "uid", "2000000") == sizeof ("2000000"), "could not set large uid");
      65           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "2000000");
      66           2 :         succeed_if (keyGetUID (key) == 2000000, "large uid was not set correctly");
      67             : 
      68           2 :         succeed_if (keySetMeta (key, "uid", "1x") == sizeof ("1x"), "could not set meta");
      69           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "1x");
      70           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
      71             : 
      72           2 :         succeed_if (keySetMeta (key, "uid", "50x") == sizeof ("50x"), "could not set meta");
      73           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "50x");
      74           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
      75             : 
      76           2 :         keyDel (key);
      77             : 
      78           2 :         key = keyNew ("user/uid", KEY_END);
      79           2 :         succeed_if (keyValue (keyGetMeta (key, "uid")) == 0, "got value, but uid was not set up to now");
      80           2 :         succeed_if (keyGetUID (key) == (uid_t) -1, "got value, but uid was not set up to now");
      81             : 
      82           2 :         keyDel (key);
      83           2 : }
      84             : 
      85             : 
      86           2 : static void test_comment (void)
      87             : {
      88             :         Key * key;
      89             :         char ret[10];
      90             : 
      91           2 :         succeed_if (key = keyNew (0), "could not create new key");
      92           2 :         succeed_if_same_string (keyComment (key), "");
      93           2 :         succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
      94           2 :         succeed_if (keyValue (keyGetMeta (key, "comment")) == 0, "No comment up to now");
      95             : 
      96           2 :         succeed_if (keySetComment (key, 0) == 1, "could not remove comment");
      97           2 :         succeed_if (keyValue (keyGetMeta (key, "comment")) == 0, "There should be an no comment");
      98           2 :         succeed_if_same_string (keyComment (key), "");
      99           2 :         succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
     100           2 :         succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get empty comment");
     101           2 :         succeed_if (keyGetComment (key, ret, 1) == 1, "Could not get empty comment");
     102           2 :         succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
     103             : 
     104           2 :         succeed_if (keySetComment (key, "") == 1, "could not remove comment");
     105           2 :         succeed_if (keyValue (keyGetMeta (key, "comment")) == 0, "There should be an no comment");
     106           2 :         succeed_if_same_string (keyComment (key), "");
     107           2 :         succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
     108           2 :         succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get empty comment");
     109           2 :         succeed_if (keyGetComment (key, ret, 1) == 1, "Could not get empty comment");
     110           2 :         succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
     111             : 
     112           2 :         succeed_if (keySetComment (key, "mycom") == sizeof ("mycom"), "could not set comment");
     113           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "comment")), "mycom");
     114           2 :         succeed_if_same_string (keyComment (key), "mycom");
     115           2 :         succeed_if (keyGetCommentSize (key) == sizeof ("mycom"), "My comment size problem");
     116           2 :         succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get my comment");
     117           2 :         succeed_if (keyGetComment (key, ret, 1) == -1, "Could not get my comment");
     118           2 :         succeed_if (keyGetComment (key, ret, sizeof ("mycom")) == sizeof ("mycom"), "Could not get my comment");
     119           2 :         succeed_if_same_string (ret, "mycom");
     120           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     121           2 : }
     122             : 
     123           2 : static void test_owner (void)
     124             : {
     125             :         Key * key;
     126             : 
     127           2 :         succeed_if (key = keyNew (0), "could not create new key");
     128           2 :         succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key");
     129           2 :         succeed_if_same_string (keyOwner (key), "");
     130           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     131             : 
     132           2 :         succeed_if (key = keyNew ("system/key", KEY_END), "could not create new key");
     133           2 :         succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key");
     134           2 :         succeed_if_same_string (keyOwner (key), "");
     135           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     136             : 
     137           2 :         succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key");
     138           2 :         succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key");
     139           2 :         succeed_if_same_string (keyOwner (key), "");
     140           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     141             : 
     142           2 :         succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key");
     143           2 :         succeed_if (keySetOwner (key, "markus") == sizeof ("markus"), "could not set owner markus");
     144           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "markus");
     145           2 :         succeed_if_same_string (keyOwner (key), "markus");
     146           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     147             : 
     148             : 
     149           2 :         succeed_if (key = keyNew ("user:markus/key", KEY_END), "could not create new key");
     150           2 :         succeed_if (keySetOwner (key, "markus") == sizeof ("markus"), "could not set owner markus");
     151           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "markus");
     152           2 :         succeed_if_same_string (keyOwner (key), "markus");
     153           2 :         succeed_if (keyDel (key) == 0, "could not delete key");
     154             : 
     155           2 :         setenv ("USER", "markus", 1);
     156           2 :         succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key with env");
     157           2 :         succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key with env");
     158           2 :         succeed_if_same_string (keyOwner (key), "");
     159           2 :         succeed_if (keyDel (key) == 0, "could not delete key with env");
     160             : 
     161           2 :         succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key with env");
     162           2 :         succeed_if (keySetMeta (key, "owner", "myowner") == 8, "owner set for empty key with env");
     163           2 :         succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "myowner");
     164           2 :         succeed_if (keyDel (key) == 0, "could not delete key with env");
     165           2 : }
     166             : 
     167           2 : static void test_mode (void)
     168             : {
     169             :         Key * key;
     170             : 
     171           2 :         key = keyNew ("user/mode", KEY_MODE, 0100, KEY_END);
     172           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "100");
     173           2 :         succeed_if (keyGetMode (key) == 0100, "mode was not set correctly");
     174             : 
     175           2 :         succeed_if (keySetMode (key, 0101) == 0, "could not set mode");
     176           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "101");
     177           2 :         succeed_if (keyGetMode (key) == 0101, "mode was not set correctly");
     178             : 
     179           2 :         succeed_if (keySetMode (key, 0) == 0, "could not set mode");
     180           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0");
     181           2 :         succeed_if (keyGetMode (key) == 0, "mode was not set correctly");
     182             : 
     183           2 :         succeed_if (keySetMeta (key, "mode", "102") == sizeof ("102"), "could not set meta");
     184           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "102");
     185           2 :         succeed_if (keyGetMode (key) == 0102, "mode was not set correctly");
     186             : 
     187           2 :         succeed_if (keySetMeta (key, "mode", "0103") == sizeof ("0103"), "could not set meta");
     188           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0103");
     189           2 :         succeed_if (keyGetMode (key) == 0103, "mode was not set correctly with leading octal 0");
     190             : 
     191           2 :         succeed_if (keySetMeta (key, "mode", "x") == sizeof ("x"), "could not set meta");
     192           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "x");
     193           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
     194             : 
     195           2 :         succeed_if (keySetMeta (key, "mode", "x1") == sizeof ("x1"), "could not set meta");
     196           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "x1");
     197           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
     198             : 
     199             : #if SIZEOF_MODE_T > 2
     200           2 :         succeed_if (keySetMeta (key, "mode", "2000000") == sizeof ("2000000"), "could not set large mode");
     201           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "2000000");
     202           2 :         succeed_if (keyGetMode (key) == 02000000, "large mode was not set correctly");
     203             : #endif
     204             : 
     205           2 :         succeed_if (keySetMeta (key, "mode", "1x") == sizeof ("1x"), "could not set meta");
     206           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "1x");
     207           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
     208             : 
     209           2 :         succeed_if (keySetMeta (key, "mode", "50x") == sizeof ("50x"), "could not set meta");
     210           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "50x");
     211           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
     212             : 
     213           2 :         keyDel (key);
     214             : 
     215           2 :         key = keyNew ("user/mode", KEY_END);
     216           2 :         succeed_if (keyValue (keyGetMeta (key, "mode")) == 0, "got value, but mode was not set up to now");
     217           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "KDB_FILE_MODE not default on new key");
     218             : 
     219           2 :         succeed_if (keySetMeta (key, "mode", "") == sizeof (""), "could not set large mode");
     220           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "");
     221           2 :         succeed_if (keyGetMode (key) == KDB_FILE_MODE, "empty mode should also yield default");
     222             : 
     223           2 :         keyDel (key);
     224           2 : }
     225             : 
     226           2 : static void test_metaKeySet (void)
     227             : {
     228           2 :         Key * key = keyNew ("user/test", KEY_END);
     229           2 :         keySetMeta (key, "meta/test1", "value1");
     230           2 :         keySetMeta (key, "meta/test2", "value2");
     231           2 :         keySetMeta (key, "meta/test3", "value3");
     232             : 
     233           2 :         KeySet * metaKeys = elektraKeyGetMetaKeySet (key);
     234             : 
     235             :         /* test whether the metakeyset contains all keys */
     236           2 :         Key * metaKey = ksLookupByName (metaKeys, "meta/test1", KDB_O_NONE);
     237           2 :         exit_if_fail (metaKey, "the first metakey was not found in the metakeyset");
     238           2 :         succeed_if (!strcmp (keyString (metaKey), "value1"), "the first metakey in the metakeyset has a wrong value");
     239             : 
     240           2 :         metaKey = ksLookupByName (metaKeys, "meta/test2", KDB_O_NONE);
     241           2 :         exit_if_fail (metaKey, "the second metakey was not found in the metakeyset");
     242           2 :         succeed_if (!strcmp (keyString (metaKey), "value2"), "the second metakey in the metakeyset has a wrong value");
     243             : 
     244           2 :         metaKey = ksLookupByName (metaKeys, "meta/test3", KDB_O_NONE);
     245           2 :         exit_if_fail (metaKey, "the third metakey was not found in the metakeyset");
     246           2 :         succeed_if (!strcmp (keyString (metaKey), "value3"), "the third metakey in the metakeyset has a wrong value");
     247             : 
     248             :         /* test whether the metakeyset is affected by deletions */
     249           2 :         ksPop (metaKeys);
     250             : 
     251           2 :         const Key * deletedKey = keyGetMeta (key, "meta/test3");
     252           2 :         exit_if_fail (deletedKey, "key deleted from the metakeyset is not present on the original key anymore");
     253           2 :         succeed_if (!strcmp (keyString (deletedKey), "value3"), "key deleted from the metakeyset has a wrong value afterwards");
     254             : 
     255           2 :         ksDel (metaKeys);
     256           2 :         metaKeys = elektraKeyGetMetaKeySet (key);
     257           2 :         ksRewind (metaKeys);
     258           2 :         metaKey = ksNext (metaKeys);
     259           2 :         keySetString (metaKey, "newvalue");
     260             : 
     261           2 :         const Key * modifiedKey = keyGetMeta (key, "meta/test1");
     262           2 :         succeed_if (!strcmp (keyString (modifiedKey), "value1"),
     263             :                     "metakey has incorrect value after a key from the metakeyset was modified");
     264             : 
     265           2 :         ksDel (metaKeys);
     266           2 :         keyDel (key);
     267           2 : }
     268             : 
     269           2 : static void test_metaArrayToKS (void)
     270             : {
     271           2 :         Key * test = keyNew ("/a", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END);
     272           2 :         KeySet * ks = elektraMetaArrayToKS (test, "dep");
     273             :         Key * cur;
     274           2 :         cur = ksNext (ks);
     275           2 :         succeed_if (!strcmp (keyName (cur), "dep"), "failed!");
     276           2 :         cur = ksNext (ks);
     277           2 :         succeed_if (!strcmp (keyName (cur), "dep/#0"), "failed!");
     278           2 :         cur = ksNext (ks);
     279           2 :         succeed_if (!strcmp (keyName (cur), "dep/#1"), "failed!");
     280           2 :         keyDel (test);
     281           2 :         ksDel (ks);
     282           2 : }
     283           8 : static void checkTopArray (Key ** array, unsigned int size)
     284             : {
     285             :         unsigned int i;
     286           8 :         KeySet * done = ksNew (size, KS_END);
     287          50 :         for (i = 0; i < size; ++i)
     288             :         {
     289          42 :                 Key * cur = array[i];
     290          42 :                 KeySet * deps = elektraMetaArrayToKS (cur, "dep");
     291             :                 Key * dep;
     292          42 :                 ksRewind (deps);
     293          42 :                 ksNext (deps);
     294          42 :                 ksRewind (done);
     295         128 :                 while ((dep = ksNext (deps)) != NULL)
     296             :                 {
     297          44 :                         if (!strcmp (keyName (cur), keyString (dep))) continue;
     298          40 :                         Key * ret = ksLookupByName (done, keyString (dep), KDB_O_NONE);
     299          40 :                         succeed_if (ret != NULL, "Failed, dependency not resolved correctly\n");
     300             :                 }
     301          42 :                 ksDel (deps);
     302          42 :                 ksAppendKey (done, cur);
     303             :         }
     304           8 :         ksDel (done);
     305           8 : }
     306             : 
     307             : #define succeed_if_top(i, s)                                                                                                               \
     308             :         {                                                                                                                                  \
     309             :                 if (strcmp (keyName (array[i]), s))                                                                                        \
     310             :                 {                                                                                                                          \
     311             :                         fprintf (stderr, "Failed, %s should be on position %d\n", s, i);                                                   \
     312             :                         succeed_if (0, "");                                                                                                \
     313             :                 }                                                                                                                          \
     314             :                 else                                                                                                                       \
     315             :                         succeed_if (1, "");                                                                                                \
     316             :         }
     317             : 
     318             : 
     319           2 : static void checkTopOrder1 (Key ** array)
     320             : {
     321           2 :         succeed_if_top (0, "/d");
     322           2 :         succeed_if_top (1, "/c");
     323           2 :         succeed_if_top (2, "/b");
     324           2 :         succeed_if_top (3, "/a");
     325           2 : }
     326             : 
     327           2 : static void checkTopOrder2 (Key ** array)
     328             : {
     329           2 :         succeed_if_top (0, "/d");
     330           2 :         succeed_if_top (1, "/c");
     331           2 :         succeed_if_top (2, "/b");
     332           2 :         succeed_if_top (3, "/a");
     333           2 : }
     334             : 
     335           2 : static void checkTopOrder3 (Key ** array)
     336             : {
     337           2 :         succeed_if_top (0, "/b");
     338           2 :         succeed_if_top (1, "/d");
     339           2 :         succeed_if_top (2, "/c");
     340           2 :         succeed_if_top (3, "/a");
     341           2 : }
     342           2 : static void test_top (void)
     343             : {
     344           2 :         KeySet * test0 = ksNew (10, keyNew ("/a", KEY_VALUE, "whatever", KEY_END), KS_END);
     345           2 :         KeySet * test1 = ksNew (
     346             :                 10, keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
     347             :                 keyNew ("/b", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
     348             :                 keyNew ("/c", KEY_VALUE, "-", KEY_END),
     349             :                 keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_END), KS_END);
     350           2 :         KeySet * test2 = ksNew (
     351             :                 10, keyNew ("/a", KEY_VALUE, "b, d", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/d", KEY_END),
     352             :                 keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
     353             :                 keyNew ("/c", KEY_VALUE, "-", KEY_END),
     354             :                 keyNew ("/d", KEY_VALUE, "c, e", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/c", KEY_META, "dep/#1", "/e", KEY_END),
     355             :                 keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
     356             :                 keyNew ("/f", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
     357             :                 keyNew ("/g", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
     358             :                 keyNew ("/h", KEY_VALUE, "-", KEY_END), KS_END);
     359           2 :         KeySet * test3 = ksNew (
     360             :                 10, keyNew ("/5", KEY_VALUE, "11", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/11", KEY_END),
     361             :                 keyNew ("/7", KEY_VALUE, "8, 11", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/8", KEY_META, "dep/#1", "/11", KEY_END),
     362             :                 keyNew ("/3", KEY_VALUE, "8, 10", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/8", KEY_META, "dep/#1", "/10", KEY_END),
     363             :                 keyNew ("/11", KEY_VALUE, "2, 9, 10", KEY_META, "dep", "#2", KEY_META, "dep/#0", "/2", KEY_META, "dep/#1", "/9", KEY_META,
     364             :                         "dep/#2", "/10", KEY_END),
     365             :                 keyNew ("/8", KEY_VALUE, "9", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/9", KEY_END),
     366             :                 keyNew ("/2", KEY_VALUE, "-", KEY_END), keyNew ("/9", KEY_VALUE, "-", KEY_END), keyNew ("/10", KEY_VALUE, "-", KEY_END),
     367             :                 KS_END);
     368           2 :         Key ** array = elektraMalloc (ksGetSize (test1) * sizeof (Key *));
     369           2 :         memset (array, 0, ksGetSize (test1) * sizeof (Key *));
     370           2 :         elektraSortTopology (test1, array);
     371             : 
     372           2 :         checkTopArray (array, ksGetSize (test1));
     373             : 
     374           2 :         elektraRealloc ((void **) &array, ksGetSize (test2) * sizeof (Key *));
     375           2 :         memset (array, 0, ksGetSize (test2) * sizeof (Key *));
     376           2 :         elektraSortTopology (test2, array);
     377             : 
     378           2 :         checkTopArray (array, ksGetSize (test2));
     379             : 
     380           2 :         elektraRealloc ((void **) &array, ksGetSize (test3) * sizeof (Key *));
     381           2 :         memset (array, 0, ksGetSize (test3) * sizeof (Key *));
     382           2 :         elektraSortTopology (test3, array);
     383             : 
     384           2 :         checkTopArray (array, ksGetSize (test3));
     385             : 
     386           2 :         elektraRealloc ((void **) &array, ksGetSize (test0) * sizeof (Key *));
     387           2 :         memset (array, 0, ksGetSize (test0) * sizeof (Key *));
     388           2 :         elektraSortTopology (test0, array);
     389             : 
     390           2 :         checkTopArray (array, ksGetSize (test0));
     391             : 
     392           2 :         KeySet * testCycle = ksNew (10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_END),
     393             :                                     keyNew ("/b", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_END), KS_END);
     394           2 :         KeySet * testCycle2 = ksNew (
     395             :                 10, keyNew ("/a", KEY_VALUE, "b, d", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/d", KEY_END),
     396             :                 keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
     397             :                 keyNew ("/c", KEY_VALUE, "-", KEY_END),
     398             :                 keyNew ("/d", KEY_VALUE, "c, e", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/c", KEY_META, "dep/#1", "/e", KEY_END),
     399             :                 keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
     400             :                 keyNew ("/f", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
     401             :                 keyNew ("/g", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
     402             :                 keyNew ("/h", KEY_VALUE, "e", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/e", KEY_END), KS_END);
     403             : 
     404           2 :         KeySet * testCycle3 = ksNew (10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_END),
     405             :                                      keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
     406             :                                      keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_END),
     407             :                                      keyNew ("/d", KEY_VALUE, "e", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/e", KEY_END),
     408             :                                      keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
     409             :                                      keyNew ("/f", KEY_VALUE, "g", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/g", KEY_END),
     410             :                                      keyNew ("/g", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_END), KS_END);
     411           2 :         KeySet * testCycle4 =
     412           2 :                 ksNew (10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_END),
     413             :                        keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
     414             :                        keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_END),
     415             :                        keyNew ("/d", KEY_VALUE, "e", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/e", KEY_META, "dep/#1", "/g", KEY_END),
     416             :                        keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
     417             :                        keyNew ("/f", KEY_VALUE, "g", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/g", KEY_END),
     418             :                        keyNew ("/g", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_END), KS_END);
     419             : 
     420             : 
     421           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycle) * sizeof (Key *));
     422           2 :         succeed_if (elektraSortTopology (testCycle, array) == 0, "Cycle detection failed\n");
     423             : 
     424           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycle2) * sizeof (Key *));
     425           2 :         succeed_if (elektraSortTopology (testCycle2, array) == 0, "Cycle detection failed\n");
     426             : 
     427           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycle3) * sizeof (Key *));
     428           2 :         succeed_if (elektraSortTopology (testCycle3, array) == 0, "Cycle detection failed\n");
     429             : 
     430           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycle4) * sizeof (Key *));
     431           2 :         succeed_if (elektraSortTopology (testCycle4, array) == 0, "Cycle detection failed\n");
     432             : 
     433           2 :         KeySet * orderTest1 = ksNew (
     434             :                 10, keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
     435             :                 keyNew ("/b", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
     436             :                 keyNew ("/c", KEY_VALUE, "-", KEY_META, "order", "#1", KEY_END),
     437             :                 keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#0", KEY_END), KS_END);
     438           2 :         elektraRealloc ((void **) &array, ksGetSize (orderTest1) * sizeof (Key *));
     439           2 :         memset (array, 0, ksGetSize (orderTest1) * sizeof (Key *));
     440           2 :         elektraSortTopology (orderTest1, array);
     441           2 :         checkTopOrder1 (array);
     442             : 
     443             : 
     444           2 :         KeySet * orderTest2 = ksNew (
     445             :                 10, keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
     446             :                 keyNew ("/b", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_META,
     447             :                         "order", "#0", KEY_END),
     448             :                 keyNew ("/c", KEY_VALUE, "-", KEY_META, "order", "#3", KEY_END),
     449             :                 keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#1", KEY_END), KS_END);
     450           2 :         memset (array, 0, ksGetSize (orderTest2) * sizeof (Key *));
     451           2 :         elektraSortTopology (orderTest2, array);
     452           2 :         checkTopOrder2 (array);
     453             : 
     454             : 
     455           2 :         KeySet * orderTest3 = ksNew (
     456             :                 10,
     457             :                 keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/a", KEY_META, "dep/#1", "/b", KEY_META, "order",
     458             :                         "#2", KEY_END),
     459             :                 keyNew ("/b", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "#0", KEY_END),
     460             :                 keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#1", KEY_END),
     461             :                 keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#5", KEY_END), KS_END);
     462           2 :         memset (array, 0, ksGetSize (orderTest3) * sizeof (Key *));
     463           2 :         elektraSortTopology (orderTest3, array);
     464           2 :         checkTopOrder3 (array);
     465             : 
     466             : 
     467           2 :         KeySet * testCycleOrder1 = ksNew (
     468             :                 10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "1", KEY_END),
     469             :                 keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
     470             :                 keyNew ("/c", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_META, "order", "#0", KEY_END), KS_END);
     471             : 
     472           2 :         KeySet * testCycleOrder2 = ksNew (
     473             :                 10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "#2", KEY_END),
     474             :                 keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_META, "order", "#0", KEY_END),
     475             :                 keyNew ("/c", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_META, "order", "#1", KEY_END), KS_END);
     476             : 
     477           2 :         KeySet * testCycleOrder3 = ksNew (
     478             :                 10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "#2", KEY_END),
     479             :                 keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_META, "order", "#0", KEY_END),
     480             :                 keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#1", KEY_END),
     481             :                 keyNew ("/d", KEY_VALUE, "e", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/e", KEY_META, "order", "#3", KEY_END),
     482             :                 keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_META, "order", "#5", KEY_END),
     483             :                 keyNew ("/f", KEY_VALUE, "g", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/g", KEY_META, "order", "#4", KEY_END),
     484             :                 keyNew ("/g", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_META, "order", "#6", KEY_END), KS_END);
     485             : 
     486           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycleOrder1) * sizeof (Key *));
     487           2 :         succeed_if (elektraSortTopology (testCycleOrder1, array) == 0, "Cycle detection failed\n");
     488             : 
     489           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycleOrder2) * sizeof (Key *));
     490           2 :         succeed_if (elektraSortTopology (testCycleOrder2, array) == 0, "Cycle detection failed\n");
     491             : 
     492           2 :         elektraRealloc ((void **) &array, ksGetSize (testCycleOrder3) * sizeof (Key *));
     493           2 :         succeed_if (elektraSortTopology (testCycleOrder3, array) == 0, "Cycle detection failed\n");
     494             : 
     495           2 :         ksDel (test0);
     496           2 :         ksDel (test1);
     497           2 :         ksDel (test2);
     498           2 :         ksDel (test3);
     499           2 :         ksDel (testCycle);
     500           2 :         ksDel (testCycle2);
     501           2 :         ksDel (testCycle3);
     502           2 :         ksDel (testCycle4);
     503           2 :         ksDel (orderTest1);
     504           2 :         ksDel (orderTest2);
     505           2 :         ksDel (orderTest3);
     506           2 :         ksDel (testCycleOrder1);
     507           2 :         ksDel (testCycleOrder2);
     508           2 :         ksDel (testCycleOrder3);
     509           2 :         elektraFree (array);
     510           2 : }
     511           2 : int main (int argc, char ** argv)
     512             : {
     513           2 :         printf ("KEY META     TESTS\n");
     514           2 :         printf ("==================\n\n");
     515             : 
     516           2 :         init (argc, argv);
     517           2 :         test_ro ();
     518             : 
     519           2 :         test_uid ();
     520           2 :         test_comment ();
     521           2 :         test_owner ();
     522           2 :         test_mode ();
     523           2 :         test_metaKeySet ();
     524             : 
     525           2 :         test_metaArrayToKS ();
     526           2 :         test_top ();
     527           2 :         printf ("\ntest_meta RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
     528             : 
     529           2 :         return nbError;
     530             : }

Generated by: LCOV version 1.13