LCOV - code coverage report
Current view: top level - tests/ctest - test_spec.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 352 352 100.0 %
Date: 2019-09-12 12:28:41 Functions: 15 15 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.h>
      10             : 
      11             : #include <kdbproposal.h>
      12             : 
      13           2 : static void test_lookupSingle (void)
      14             : {
      15           2 :         printf ("Test lookup single\n");
      16             : 
      17           2 :         Key * specKey = keyNew ("user/abc", KEY_META, "override/#0", "user/something", KEY_END);
      18           2 :         Key * k = 0;
      19           2 :         KeySet * ks = ksNew (20, k = keyNew ("user/else", KEY_END), KS_END);
      20           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
      21           2 :         keySetMeta (specKey, "fallback/#0", "user/else");
      22           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find fallback key");
      23           2 :         keySetMeta (specKey, "fallback/#0", "");
      24           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
      25           2 :         keySetMeta (specKey, "override/#0", "user/else");
      26           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find override key");
      27           2 :         keySetMeta (specKey, "override/#0", "");
      28           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
      29             : 
      30           2 :         keyDel (specKey);
      31           2 :         ksDel (ks);
      32           2 : }
      33             : 
      34           2 : static void test_lookupChain (void)
      35             : {
      36           2 :         printf ("Test lookup chain\n");
      37             : 
      38           2 :         Key * specKey = keyNew ("user/4", KEY_META, "override/#0", "user/something", KEY_END);
      39           2 :         Key * k1 = 0;
      40           2 :         Key * k2 = 0;
      41           2 :         Key * k3 = 0;
      42           2 :         Key * k4 = 0;
      43           2 :         KeySet * ks = ksNew (20, k1 = keyNew ("user/1", KEY_END), k2 = keyNew ("user/2", KEY_END), k3 = keyNew ("user/3", KEY_END),
      44             :                              k4 = keyNew ("user/4", KEY_END), KS_END);
      45             : 
      46           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
      47           2 :         keySetMeta (specKey, "override/#0", "user/else");
      48           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
      49           2 :         keySetMeta (specKey, "override/#1", "user/wrong");
      50           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
      51           2 :         keySetMeta (specKey, "override/#2", "user/3");
      52           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k3, "did not find override key");
      53           2 :         keySetMeta (specKey, "override/#1", "user/2");
      54           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k2, "found wrong key");
      55           2 :         keySetMeta (specKey, "override/#0", "user/1");
      56           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k1, "found wrong key");
      57             : 
      58           2 :         keyDel (specKey);
      59           2 :         ksDel (ks);
      60           2 : }
      61             : 
      62           2 : static void test_lookupChainLast (void)
      63             : {
      64           2 :         printf ("Test lookup chain last\n");
      65             : 
      66           2 :         Key * k1 = 0;
      67           2 :         Key * k2 = 0;
      68           2 :         Key * k3 = 0;
      69           2 :         Key * k4 = 0;
      70             :         // clang-format off
      71           2 :         KeySet *ks= ksNew(20,
      72             :                 k1 = keyNew("spec/key",
      73             :                         KEY_VALUE, "spec value",
      74             :                         KEY_META, "override/#0", "/something",
      75             :                         KEY_META, "override/#1", "/something_else",
      76             :                         KEY_META, "override/#2", "/override",
      77             :                         KEY_END),
      78             :                 k2 = keyNew("user/key", KEY_VALUE, "wrong user value", KEY_END),
      79             :                 k3 = keyNew("dir/key", KEY_VALUE, "wrong dir value", KEY_END),
      80             :                 k4 = keyNew("user/override", KEY_VALUE, "ok", KEY_END),
      81             :                 KS_END);
      82             :         // clang-format on
      83             : 
      84           2 :         Key * found = ksLookupByName (ks, "/key", 0);
      85           2 :         succeed_if (found == k4, "found wrong key");
      86           2 :         succeed_if_same_string (keyName (found), "user/override");
      87           2 :         succeed_if_same_string (keyString (found), "ok");
      88             : 
      89           2 :         Key * searchKey = keyNew ("/key", KEY_END);
      90           2 :         found = ksLookup (ks, searchKey, 0);
      91           2 :         succeed_if (found == k4, "found wrong key");
      92           2 :         succeed_if_same_string (keyName (found), "user/override");
      93           2 :         succeed_if_same_string (keyString (found), "ok");
      94           2 :         keyDel (searchKey);
      95             : 
      96           2 :         ksDel (ks);
      97           2 : }
      98             : 
      99             : 
     100           2 : static void test_lookupChainRealWorld (void)
     101             : {
     102           2 :         printf ("Test lookup chain real world\n");
     103             : 
     104           2 :         Key * k1 = 0;
     105           2 :         Key * k2 = 0;
     106           2 :         Key * k3 = 0;
     107           2 :         Key * k4 = 0;
     108             :         // clang-format off
     109           2 :         KeySet *ks= ksNew(20,
     110             :                 k1 = keyNew("spec/sw/P/current/editor",
     111             :                         KEY_META, "example", "vim",
     112             :                         KEY_META, "override/#0", "/sw/P/override/editor",
     113             :                         KEY_META, "override/#1", "/sw/override/editor",
     114             :                         KEY_META, "override/#2", "/sw/defaults/editor",
     115             :                         KEY_END),
     116             :                 k2 = keyNew("user/sw/defaults/editor", KEY_VALUE, "ok", KEY_END),
     117             :                 k3 = keyNew("dir/sw/P/current/editor", KEY_VALUE, "wrong dir value", KEY_END),
     118             :                 k4 = keyNew("user/sw/P/current/editor", KEY_VALUE, "wrong user value", KEY_END),
     119             :                 KS_END);
     120             :         // clang-format on
     121             : 
     122           2 :         Key * found = ksLookupByName (ks, "/sw/P/current/editor", 0);
     123           2 :         succeed_if (found == k2, "found wrong key");
     124           2 :         succeed_if_same_string (keyName (found), "user/sw/defaults/editor");
     125           2 :         succeed_if_same_string (keyString (found), "ok");
     126             : 
     127           2 :         Key * searchKey = keyNew ("/sw/P/current/editor", KEY_END);
     128           2 :         found = ksLookup (ks, searchKey, 0);
     129           2 :         succeed_if (found == k2, "found wrong key");
     130           2 :         succeed_if_same_string (keyName (found), "user/sw/defaults/editor");
     131           2 :         succeed_if_same_string (keyString (found), "ok");
     132           2 :         keyDel (searchKey);
     133             : 
     134           2 :         ksDel (ks);
     135           2 : }
     136             : 
     137           2 : static void test_lookupNoOverride (void)
     138             : {
     139           2 :         printf ("Test lookup with override not found\n");
     140             : 
     141             :         // clang-format off
     142           2 :         Key *specKey = keyNew("/test/lift/limit",
     143             :                         KEY_CASCADING_NAME,
     144             :                         KEY_META, "default", "1",
     145             :                         KEY_META, "override/#0", "/test/person_lift/limit",
     146             :                         KEY_META, "override/#1", "/test/material_lift/limit",
     147             :                         KEY_META, "override/#2", "/test/heavy_material_lift/limit",
     148             :                         KEY_END);
     149             :         // clang-format on
     150           2 :         Key * dup = keyDup (specKey);
     151             : 
     152           2 :         Key * k1 = 0;
     153           2 :         Key * k2 = 0;
     154           2 :         KeySet * ks = ksNew (20, k1 = keyNew ("user/test/lift/limit", KEY_VALUE, "22", KEY_END),
     155             :                              k2 = keyNew ("/test/person_lift/limit", KEY_CASCADING_NAME, KEY_VALUE, "10", KEY_END), KS_END);
     156             : 
     157           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k1, "found wrong key");
     158           2 :         succeed_if (ksLookup (ks, dup, KDB_O_SPEC) == k1, "found wrong key");
     159           2 :         elektraKeySetName (dup, "/test/lift/limit", KEY_CASCADING_NAME);
     160           2 :         succeed_if (ksLookup (ks, dup, KDB_O_SPEC) == k1, "found wrong key");
     161           2 :         succeed_if (ksLookup (ks, dup, KDB_O_SPEC | KDB_O_CREATE) == k1, "found wrong key");
     162             : 
     163           2 :         keyDel (specKey);
     164           2 :         ksDel (ks);
     165           2 :         keyDel (dup);
     166           2 : }
     167             : 
     168           2 : static void test_lookupDefault (void)
     169             : {
     170           2 :         printf ("Test lookup default\n");
     171             : 
     172           2 :         Key * specKey = keyNew ("user/abc", KEY_END);
     173           2 :         Key * k = 0;
     174           2 :         KeySet * ks = ksNew (20, KS_END);
     175             : 
     176           2 :         succeed_if (ksGetSize (ks) == 0, "wrong size");
     177           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
     178             : 
     179           2 :         keySetMeta (specKey, "default", "xyz");
     180             : 
     181           2 :         k = ksLookup (ks, specKey, KDB_O_SPEC);
     182           2 :         succeed_if (k != 0, "found no default key");
     183           2 :         succeed_if (ksGetSize (ks) == 1, "wrong size");
     184           2 :         succeed_if_same_string (keyName (k), "/abc");
     185           2 :         succeed_if_same_string (keyString (k), "xyz");
     186             : 
     187           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
     188           2 :         succeed_if (ksGetSize (ks) == 1, "wrong size");
     189           2 :         keySetMeta (specKey, "default", "");
     190           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
     191           2 :         succeed_if (ksGetSize (ks) == 1, "wrong size");
     192             : 
     193           2 :         keyDel (specKey);
     194           2 :         ksDel (ks);
     195           2 : }
     196             : 
     197           2 : static void test_lookupNoascading (void)
     198             : {
     199           2 :         printf ("Test lookup without cascading\n");
     200             : 
     201           2 :         Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_END);
     202             : 
     203           2 :         Key * d = keyDup (specKey);
     204           2 :         keySetString (d, "dup");
     205           2 :         succeed_if_same_string (keyName (specKey), "/abc");
     206           2 :         succeed_if_same_string (keyName (d), "/abc");
     207             : 
     208           2 :         succeed_if (!keyCmp (d, specKey), "comparision to duplicate failed");
     209           2 :         succeed_if_same_string (keyName (d), "/abc");
     210           2 :         succeed_if_same_string (keyName (specKey), "/abc");
     211             : 
     212           2 :         KeySet * ks = ksNew (20, d, KS_END);
     213             : 
     214           2 :         Key * k = ksLookup (ks, specKey, KDB_O_NOCASCADING);
     215           2 :         succeed_if_same_string (keyName (specKey), "/abc");
     216           2 :         succeed_if (k != 0, "did not find cascading key");
     217           2 :         succeed_if (k != specKey, "should not be specKey");
     218           2 :         succeed_if (k == d, "should be dup key");
     219             : 
     220           2 :         Key * a = keyNew (keyName (specKey), KEY_CASCADING_NAME, KEY_VALUE, "a", KEY_END);
     221           2 :         ksAppendKey (ks, a);
     222             : 
     223          12 :         for (int i = 0; i < 5; ++i)
     224             :         {
     225          10 :                 k = ksLookup (ks, specKey, KDB_O_NOCASCADING);
     226          10 :                 succeed_if (keyGetNameSize (specKey) == 5, "size of spec key wrong");
     227          10 :                 succeed_if_same_string (keyName (specKey), "/abc");
     228          10 :                 succeed_if (k != 0, "did not find cascading key");
     229          10 :                 succeed_if (k != specKey, "should not be specKey");
     230          10 :                 succeed_if (k == a, "should be dup key");
     231             : 
     232             :                 // search without cascading
     233          10 :                 k = ksLookup (ks, specKey, 0);
     234          10 :                 succeed_if (keyGetNameSize (specKey) == 5, "size of spec key wrong");
     235          10 :                 succeed_if_same_string (keyName (specKey), "/abc");
     236          10 :                 succeed_if (k != 0, "did not find cascading key");
     237          10 :                 succeed_if (k != specKey, "should not be specKey");
     238          10 :                 succeed_if (k == a, "should be dup key");
     239             :         }
     240             : 
     241           2 :         ksDel (ks);
     242           2 :         keyDel (specKey);
     243           2 : }
     244             : 
     245           2 : static void test_lookupDefaultCascading (void)
     246             : {
     247           2 :         printf ("Test lookup default with cascading\n");
     248             : 
     249           2 :         Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_END);
     250           2 :         Key * k = 0;
     251           2 :         KeySet * ks = ksNew (20, KS_END);
     252             : 
     253           2 :         succeed_if (ksGetSize (ks) == 0, "wrong size");
     254           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
     255             : 
     256           2 :         keySetMeta (specKey, "default", "xyz");
     257           2 :         k = ksLookup (ks, specKey, KDB_O_SPEC);
     258           2 :         succeed_if (k != 0, "found no default key");
     259           2 :         succeed_if (ksGetSize (ks) == 1, "wrong size");
     260           2 :         succeed_if_same_string (keyName (k), "/abc");
     261           2 :         succeed_if_same_string (keyString (k), "xyz");
     262             : 
     263           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
     264           2 :         succeed_if (ksGetSize (ks) == 1, "wrong size");
     265           2 :         keySetMeta (specKey, "default", "");
     266           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
     267           2 :         succeed_if (ksGetSize (ks) == 1, "wrong size");
     268             : 
     269           2 :         keyDel (specKey);
     270           2 :         ksDel (ks);
     271           2 : }
     272             : 
     273           2 : static void test_lookupLongChain (void)
     274             : {
     275           2 :         printf ("Test lookup long chain\n");
     276             : 
     277             :         // clang-format off
     278           2 :         Key *specKey = keyNew("user/4",
     279             :                         KEY_META, "override/#0", "user/something",
     280             :                         KEY_META, "override/#1", "user/something",
     281             :                         KEY_META, "override/#2", "user/something",
     282             :                         KEY_META, "override/#3", "user/something",
     283             :                         KEY_META, "override/#3", "user/something",
     284             :                         KEY_META, "override/#4", "user/something",
     285             :                         KEY_META, "override/#5", "user/something",
     286             :                         KEY_META, "override/#6", "user/something",
     287             :                         KEY_META, "override/#7", "user/something",
     288             :                         KEY_META, "override/#8", "user/something",
     289             :                         KEY_META, "override/#9", "user/something",
     290             :                         KEY_META, "override/#_10", "user/something",
     291             :                         KEY_META, "override/#_11", "user/something",
     292             :                         KEY_META, "override/#_12", "user/something",
     293             :                         KEY_META, "override/#_13", "user/something",
     294             :                         KEY_META, "override/#_14", "user/something",
     295             :                         KEY_META, "override/#_15", "user/something",
     296             :                         KEY_END);
     297             :         // clang-format on
     298           2 :         Key * k1 = 0;
     299           2 :         Key * k2 = 0;
     300           2 :         Key * k3 = 0;
     301           2 :         Key * k4 = 0;
     302           2 :         KeySet * ks = ksNew (20, k1 = keyNew ("user/1", KEY_END), k2 = keyNew ("user/2", KEY_END), k3 = keyNew ("user/3", KEY_END),
     303             :                              k4 = keyNew ("user/4", KEY_END), KS_END);
     304             : 
     305           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
     306           2 :         keySetMeta (specKey, "override/#_16", "user/else");
     307           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
     308           2 :         keySetMeta (specKey, "override/#_17", "user/wrong");
     309           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
     310           2 :         keySetMeta (specKey, "override/#_18", "user/3");
     311           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k3, "did not find override key");
     312           2 :         keySetMeta (specKey, "override/#_10", "user/2");
     313           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k2, "found wrong key");
     314           2 :         keySetMeta (specKey, "override/#5", "user/1");
     315           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k1, "found wrong key");
     316             : 
     317           2 :         keyDel (specKey);
     318           2 :         ksDel (ks);
     319           2 : }
     320             : 
     321           2 : static void test_lookupCascading (void)
     322             : {
     323           2 :         printf ("Test lookup cascading\n");
     324             : 
     325           2 :         Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_META, "override/#0", "/something", KEY_END);
     326           2 :         Key * k = 0;
     327           2 :         KeySet * ks = ksNew (20, k = keyNew ("user/else", KEY_END), KS_END);
     328           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
     329           2 :         keySetMeta (specKey, "fallback/#0", "/else");
     330           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find fallback key");
     331           2 :         keySetMeta (specKey, "fallback/#0", "");
     332           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
     333           2 :         keySetMeta (specKey, "override/#0", "/else");
     334           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find override key");
     335           2 :         keySetMeta (specKey, "override/#0", "");
     336           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
     337           2 :         elektraKeySetName (specKey, "/else", KEY_CASCADING_NAME);
     338           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key itself");
     339             : 
     340           2 :         keyDel (specKey);
     341           2 :         ksDel (ks);
     342           2 : }
     343             : 
     344           2 : static void test_lookupNamespace (void)
     345             : {
     346           2 :         printf ("Test lookup namespace\n");
     347             : 
     348           2 :         Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_META, "namespace/#0", "system", KEY_END);
     349           2 :         Key * k = 0;
     350             : 
     351           2 :         KeySet * ks = ksNew (20, k = keyNew ("user/abc", KEY_END), KS_END);
     352           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key of other namespace");
     353           2 :         keySetMeta (specKey, "namespace/#0", "user");
     354           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key in correct namespace");
     355           2 :         ksDel (ks);
     356             : 
     357           2 :         ks = ksNew (20, k = keyNew ("system/abc", KEY_END), KS_END);
     358           2 :         keySetMeta (specKey, "namespace/#0", "user");
     359           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key of other namespace");
     360           2 :         keySetMeta (specKey, "namespace/#0", "system");
     361           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key in correct namespace");
     362           2 :         ksDel (ks);
     363             : 
     364             : 
     365           2 :         ks = ksNew (20, keyNew ("system/abc", KEY_END), k = keyNew ("user/abc", KEY_END), KS_END);
     366           2 :         keySetMeta (specKey, "namespace/#0", "user");
     367           2 :         keySetMeta (specKey, "namespace/#1", "system");
     368           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "found wrong key of other namespace");
     369           2 :         ksDel (ks);
     370             : 
     371             : 
     372           2 :         ks = ksNew (20, k = keyNew ("system/abc", KEY_END), keyNew ("user/abc", KEY_END), KS_END);
     373           2 :         keySetMeta (specKey, "namespace/#0", "system");
     374           2 :         keySetMeta (specKey, "namespace/#1", "user");
     375           2 :         succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "found wrong key of other namespace");
     376           2 :         ksDel (ks);
     377             : 
     378           2 :         keyDel (specKey);
     379           2 : }
     380             : 
     381           2 : static void test_lookupIndirect (void)
     382             : {
     383           2 :         printf ("Test lookup by indirect spec\n");
     384             : 
     385             :         Key * s;
     386             :         Key * p;
     387             :         Key * d;
     388             :         Key * u;
     389             :         Key * y;
     390             :         Key * e;
     391           2 :         KeySet * ks =
     392             :                 ksNew (20, s = keyNew ("spec/abc", KEY_END), p = keyNew ("proc/abc", KEY_END), d = keyNew ("dir/abc", KEY_END),
     393             :                        u = keyNew ("user/abc", KEY_END), y = keyNew ("system/abc", KEY_END), e = keyNew ("system/else", KEY_END), KS_END);
     394           2 :         succeed_if (ksGetSize (ks) == 6, "wrong size");
     395             : 
     396           2 :         Key * k = ksLookupByName (ks, "/abc", 0);
     397           2 :         succeed_if (k == p, "did not find proc key");
     398             : 
     399           2 :         keySetMeta (s, "namespace/#0", "no");
     400           2 :         keySetMeta (s, "default", "80");
     401           2 :         k = ksLookupByName (ks, "/abc", 0);
     402           2 :         succeed_if (k != 0, "should find default");
     403           2 :         succeed_if (ksGetSize (ks) == 7, "default key not added");
     404           2 :         succeed_if_same_string (keyString (k), "80");
     405             : 
     406           2 :         Key * k2 = ksLookupByName (ks, "/abc", 0);
     407           2 :         succeed_if (k == k2, "did not get same default");
     408             : 
     409           2 :         keySetMeta (s, "fallback/#0", "/else");
     410           2 :         k = ksLookupByName (ks, "/abc", 0);
     411           2 :         succeed_if (k == e, "did not find else");
     412             : 
     413           2 :         keySetMeta (s, "namespace/#0", "system");
     414           2 :         k = ksLookupByName (ks, "/abc", 0);
     415           2 :         succeed_if (k == y, "did not find system key");
     416             : 
     417           2 :         keySetMeta (s, "namespace/#0", "system");
     418           2 :         keySetMeta (s, "namespace/#1", "user");
     419           2 :         k = ksLookupByName (ks, "/abc", 0);
     420           2 :         succeed_if (k == y, "did not find system key");
     421             : 
     422           2 :         keySetMeta (s, "namespace/#0", "proc");
     423           2 :         keySetMeta (s, "namespace/#1", "user");
     424           2 :         k = ksLookupByName (ks, "/abc", 0);
     425           2 :         succeed_if (k == p, "did not find proc key");
     426             : 
     427           2 :         keySetMeta (s, "override/#0", "/else");
     428           2 :         k = ksLookupByName (ks, "/abc", 0);
     429           2 :         succeed_if (k == e, "did not find override key");
     430             : 
     431           2 :         ksDel (ks);
     432           2 : }
     433             : 
     434           2 : static void test_lookupDoubleIndirect (void)
     435             : {
     436           2 :         printf ("Test lookup by double indirect spec\n");
     437             : 
     438             :         Key * s;
     439             :         Key * p;
     440             :         Key * d;
     441             :         Key * u;
     442             :         Key * y;
     443             :         Key * se;
     444             :         Key * pe;
     445           2 :         KeySet * ks = ksNew (20, se = keyNew ("spec/first", KEY_END), pe = keyNew ("proc/first", KEY_END), s = keyNew ("spec/abc", KEY_END),
     446             :                              p = keyNew ("proc/abc", KEY_END), d = keyNew ("dir/abc", KEY_END), u = keyNew ("user/abc", KEY_END),
     447             :                              y = keyNew ("system/abc", KEY_END), KS_END);
     448           2 :         succeed_if (ksGetSize (ks) == 7, "wrong size");
     449             : 
     450           2 :         Key * k = ksLookupByName (ks, "/first", 0);
     451           2 :         succeed_if (k == pe, "did not find proc key");
     452             : 
     453           2 :         keySetMeta (se, "override/#0", "/abc");
     454           2 :         k = ksLookupByName (ks, "/first", 0);
     455           2 :         succeed_if (k == p, "did not find proc/abc");
     456             : 
     457           2 :         keySetMeta (s, "namespace/#0", "system");
     458           2 :         k = ksLookupByName (ks, "/first", 0);
     459           2 :         succeed_if (k == y, "did not find system key");
     460             : 
     461           2 :         keySetMeta (s, "namespace/#0", "system");
     462           2 :         keySetMeta (s, "namespace/#1", "user");
     463           2 :         k = ksLookupByName (ks, "/first", 0);
     464           2 :         succeed_if (k == y, "did not find system key");
     465             : 
     466           2 :         keySetMeta (s, "namespace/#0", "proc");
     467           2 :         keySetMeta (s, "namespace/#1", "user");
     468           2 :         k = ksLookupByName (ks, "/first", 0);
     469           2 :         succeed_if (k == p, "did not find proc key");
     470             : 
     471           2 :         keySetMeta (s, "override/#0", "proc/first");
     472           2 :         k = ksLookupByName (ks, "/first", 0);
     473           2 :         succeed_if (k == pe, "did not find override key (double indirect)");
     474             : 
     475           2 :         ksDel (ks);
     476           2 : }
     477             : 
     478           2 : static void test_lookupDoubleIndirectDefault (void)
     479             : {
     480           2 :         printf ("Test lookup by double indirect spec with default\n");
     481             : 
     482             :         Key * s;
     483             :         Key * p;
     484             :         Key * u;
     485             :         Key * y;
     486             :         Key * se;
     487             :         Key * pe;
     488           2 :         KeySet * ks =
     489             :                 ksNew (20, se = keyNew ("spec/first", KEY_END), pe = keyNew ("proc/first", KEY_END), s = keyNew ("spec/abc", KEY_END),
     490             :                        p = keyNew ("proc/abc", KEY_END), u = keyNew ("user/abc", KEY_END), y = keyNew ("system/abc", KEY_END), KS_END);
     491           2 :         succeed_if (ksGetSize (ks) == 6, "wrong size");
     492           2 :         keySetMeta (se, "default", "default is ok");
     493           2 :         keySetMeta (s, "default", "default is NOT ok");
     494             : 
     495           2 :         Key * k = ksLookupByName (ks, "/first", 0);
     496           2 :         succeed_if (k == pe, "did not find proc key");
     497             : 
     498           2 :         keySetMeta (se, "namespace/#0", "system");
     499           2 :         k = ksLookupByName (ks, "/first", 0);
     500           2 :         succeed_if_same_string (keyString (k), "default is ok");
     501             : 
     502           2 :         keySetMeta (se, "override/#0", "/abc");
     503           2 :         k = ksLookupByName (ks, "/first", 0);
     504           2 :         succeed_if (k == p, "did not find proc/abc");
     505             : 
     506           2 :         keySetMeta (s, "namespace/#0", "system");
     507           2 :         k = ksLookupByName (ks, "/first", 0);
     508           2 :         succeed_if (k == y, "did not find system key");
     509             : 
     510           2 :         keySetMeta (s, "namespace/#0", "system");
     511           2 :         keySetMeta (s, "namespace/#1", "user");
     512           2 :         k = ksLookupByName (ks, "/first", 0);
     513           2 :         succeed_if (k == y, "did not find system key");
     514             : 
     515           2 :         keySetMeta (s, "namespace/#0", "proc");
     516           2 :         keySetMeta (s, "namespace/#1", "user");
     517           2 :         k = ksLookupByName (ks, "/first", 0);
     518           2 :         succeed_if (k == p, "did not find proc key");
     519             : 
     520           2 :         keySetMeta (s, "namespace/#0", "dir");
     521           2 :         keySetMeta (s, "namespace/#1", 0);
     522           2 :         k = ksLookupByName (ks, "/first", 0);
     523           2 :         succeed_if_same_string (keyString (k), "default is ok");
     524             : 
     525           2 :         keySetMeta (s, "override/#0", "proc/first");
     526           2 :         k = ksLookupByName (ks, "/first", 0);
     527           2 :         succeed_if (k == pe, "did not find override key (double indirect)");
     528             : 
     529           2 :         keySetMeta (s, "override/#0", "dir/first");
     530           2 :         k = ksLookupByName (ks, "/first", 0);
     531           2 :         succeed_if_same_string (keyString (k), "default is ok");
     532             : 
     533           2 :         ksDel (ks);
     534           2 : }
     535             : 
     536             : 
     537           2 : int main (int argc, char ** argv)
     538             : {
     539           2 :         printf ("SPEC  TESTS\n");
     540           2 :         printf ("==========================\n\n");
     541             : 
     542           2 :         init (argc, argv);
     543             : 
     544           2 :         test_lookupSingle ();
     545           2 :         test_lookupChain ();
     546           2 :         test_lookupChainLast ();
     547           2 :         test_lookupChainRealWorld ();
     548           2 :         test_lookupNoOverride ();
     549           2 :         test_lookupDefault ();
     550           2 :         test_lookupNoascading ();
     551           2 :         test_lookupDefaultCascading ();
     552           2 :         test_lookupLongChain ();
     553           2 :         test_lookupCascading ();
     554           2 :         test_lookupNamespace ();
     555           2 :         test_lookupIndirect ();
     556           2 :         test_lookupDoubleIndirect ();
     557           2 :         test_lookupDoubleIndirectDefault ();
     558             : 
     559           2 :         printf ("\n%s RESULTS: %d test(s) done. %d error(s).\n", argv[0], nbTest, nbError);
     560             : 
     561           2 :         return nbError;
     562             : }

Generated by: LCOV version 1.13