LCOV - code coverage report
Current view: top level - src/plugins/keytometa - testmod_keytometa.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 247 249 99.2 %
Date: 2019-09-12 12:28:41 Functions: 15 15 100.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief A plugin that makes use of libaugeas to read and write configuration files
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #ifdef HAVE_KDBCONFIG_H
      11             : #include "kdbconfig.h"
      12             : #endif
      13             : 
      14             : /* used for asprintf */
      15             : #define _GNU_SOURCE
      16             : 
      17             : #ifdef HAVE_STDLIB_H
      18             : #include <stdlib.h>
      19             : #endif
      20             : #ifdef HAVE_STRING_H
      21             : #include <string.h>
      22             : #endif
      23             : 
      24             : #include <tests_plugin.h>
      25             : 
      26             : 
      27             : #include <stdio.h>
      28             : 
      29          12 : static Key * createMergingKey (int i)
      30             : {
      31             :         char * name;
      32             :         char * value;
      33             :         char * order;
      34          24 :         if (asprintf (&name, "user/convertkey%d", i) == -1 || asprintf (&value, "meta line %d", i) == -1 ||
      35          12 :             asprintf (&order, "%i", i) == -1)
      36             :         {
      37           0 :                 fprintf (stderr, "Unable to create key attributes");
      38           0 :                 exit (EXIT_FAILURE);
      39             :         }
      40          12 :         Key * key = keyNew (name, KEY_VALUE, value, KEY_META, "order", order, KEY_END);
      41          12 :         elektraFree (name);
      42          12 :         elektraFree (value);
      43          12 :         elektraFree (order);
      44          12 :         return key;
      45             : }
      46             : 
      47             : // clang-format off
      48           4 : static KeySet* createSimpleTestKeys(void)
      49             : {
      50             :         /* the keys to be converted are simply appended to the next
      51             :          * or the previous key.
      52             :          */
      53           4 :         return ksNew (20,
      54             :                         keyNew ("user/normalkey1",
      55             :                                         KEY_META, "order", "10", KEY_END),
      56             :                         keyNew ("user/convertkey1",
      57             :                                         KEY_VALUE, "testvalue1",
      58             :                                         KEY_META, "order", "20",
      59             :                                         KEY_META, "convert/metaname", "testmeta",
      60             :                                         KEY_META, "convert/append", "next",
      61             :                                         KEY_END),
      62             :                         keyNew ("user/normalkey2",
      63             :                                         KEY_META, "order", "30",
      64             :                                         KEY_END),
      65             :                         keyNew ("user/normalkey3",
      66             :                                         KEY_META, "order", "40",
      67             :                                         KEY_END),
      68             :                         keyNew ("user/convertkey2",
      69             :                                         KEY_VALUE, "testvalue2",
      70             :                                         KEY_META, "order", "50",
      71             :                                         KEY_META, "convert/metaname", "testmeta",
      72             :                                         KEY_META, "convert/append", "previous",
      73             :                                         KEY_END),
      74             :                         keyNew ("user/normalkey1/subkey",
      75             :                                         KEY_VALUE, "testvalue3",
      76             :                                         KEY_META, "order", "60",
      77             :                                         KEY_META, "convert/metaname", "testmeta",
      78             :                                         KEY_META, "convert/append", "parent",
      79             :                                         KEY_END),
      80             :                         KS_END);
      81             : }
      82             : 
      83           2 : static KeySet* createMergeTestkeys(void)
      84             : {
      85             :         /* the keys to be converted are merged together
      86             :          * into a single metadata
      87             :          */
      88           2 :         KeySet* ks = ksNew(0, KS_END);
      89           8 :         for (int i = 1; i <= 3; i++)
      90             :         {
      91           6 :                 Key* key = createMergingKey (i);
      92           6 :                 keySetMeta (key, "convert/metaname", "testmeta");
      93           6 :                 keySetMeta (key, "convert/append", "next");
      94           6 :                 ksAppendKey (ks, key);
      95             :         }
      96           2 :         ksAppendKey (ks,
      97             :                         keyNew ("user/normalkey1", KEY_META, "order", "10", KEY_END));
      98           2 :         ksAppendKey (ks,
      99             :                         keyNew ("user/normalkey2", KEY_META, "order", "20", KEY_END));
     100           8 :         for (int i = 30; i <= 32; i++)
     101             :         {
     102           6 :                 Key* key = createMergingKey (i);
     103           6 :                 keySetMeta (key, "convert/metaname", "testmeta");
     104           6 :                 keySetMeta (key, "convert/append", "previous");
     105           6 :                 ksAppendKey (ks, key);
     106             :         }
     107           2 :         return ks;
     108             : }
     109             : 
     110           2 : static KeySet* createSkipMergeTestKeys(void)
     111             : {
     112             :         /* the keys to be converted are interweaved with keys
     113             :          * of the other directio
     114             :          */
     115           2 :         return ksNew (20,
     116             :                         keyNew ("user/normalkey1",
     117             :                                         KEY_META, "order", "10", KEY_END),
     118             :                         keyNew ("user/convertkey1",
     119             :                                         KEY_VALUE, "meta line1",
     120             :                                         KEY_META, "order", "20",
     121             :                                         KEY_META, "convert/metaname", "testmeta",
     122             :                                         KEY_META, "convert/append", "previous",
     123             :                                         KEY_END),
     124             :                         keyNew ("user/convertkey2",
     125             :                                         KEY_VALUE, "meta line2",
     126             :                                         KEY_META, "order", "30",
     127             :                                         KEY_META, "convert/metaname", "testmeta",
     128             :                                         KEY_META, "convert/append", "next",
     129             :                                         KEY_END),
     130             :                         keyNew ("user/convertkey3",
     131             :                                         KEY_VALUE, "meta line3",
     132             :                                         KEY_META, "order", "40",
     133             :                                         KEY_META, "convert/metaname", "testmeta",
     134             :                                         KEY_META, "convert/append", "previous",
     135             :                                         KEY_END),
     136             :                         keyNew ("user/convertkey4",
     137             :                                         KEY_VALUE, "meta line4",
     138             :                                         KEY_META, "order", "50",
     139             :                                         KEY_META, "convert/metaname", "testmeta",
     140             :                                         KEY_META, "convert/append", "next",
     141             :                                         KEY_END),
     142             :                         keyNew ("user/normalkey2",
     143             :                                         KEY_META, "order", "60",
     144             :                                         KEY_END),
     145             :                         KS_END);
     146             : }
     147             : 
     148           2 : static KeySet *createParentTestKeys(void)
     149             : {
     150             : 
     151             :         /* all keys to be converted are appended to the
     152             :          * parent key of the keyset for any of the possible reasons
     153             :          */
     154           2 :         return ksNew (20,
     155             :                         keyNew ("user/parentkey1",
     156             :                                         KEY_META, "order", "10", KEY_END),
     157             :                         keyNew ("user/parentkey1/convertkeydirect",
     158             :                                         KEY_VALUE, "testvalue1",
     159             :                                         KEY_META, "order", "20",
     160             :                                         KEY_META, "convert/metaname", "testmeta",
     161             :                                         KEY_META, "convert/append", "parent",
     162             :                                         KEY_END),
     163             :                         keyNew ("user/parentkey2",
     164             :                                         KEY_META, "order", "30", KEY_END),
     165             :                         keyNew ("user/parentkey2/subparent/convertkeyhole",
     166             :                                         KEY_VALUE, "testvalue2",
     167             :                                         KEY_META, "order", "40",
     168             :                                         KEY_META, "convert/metaname", "testmeta",
     169             :                                         KEY_META, "convert/append", "parent",
     170             :                                         KEY_END),
     171             :                         keyNew ("user/parentkey3",
     172             :                                         KEY_META, "order", "50",
     173             :                                         KEY_END),
     174             :                         keyNew ("user/normalkey1",
     175             :                                         KEY_META, "order", "60",
     176             :                                         KEY_END),
     177             :                         keyNew ("user/parentkey3/convertkeyprev",
     178             :                                         KEY_VALUE, "testvalue3",
     179             :                                         KEY_META, "order", "70",
     180             :                                         KEY_META, "convert/metaname", "testmeta",
     181             :                                         KEY_META, "convert/append", "previous",
     182             :                                         KEY_META, "convert/append/samelevel", "",
     183             :                                         KEY_END),
     184             :                         keyNew ("user/parentkey4",
     185             :                                         KEY_META, "order", "80",
     186             :                                         KEY_END),
     187             :                         keyNew ("user/parentkey4/convertkeynext",
     188             :                                         KEY_VALUE, "testvalue4",
     189             :                                         KEY_META, "order", "90",
     190             :                                         KEY_META, "convert/metaname", "testmeta",
     191             :                                         KEY_META, "convert/append", "next",
     192             :                                         KEY_META, "convert/append/samelevel", "",
     193             :                                         KEY_END),
     194             :                         keyNew ("user/normalkey2",
     195             :                                         KEY_META, "order", "100",
     196             :                                         KEY_END),
     197             :                         KS_END);
     198             : }
     199             : 
     200           2 : static KeySet* createDifferentMetaNameTestKeys(void)
     201             : {
     202           2 :         return ksNew (20,
     203             :                         keyNew ("user/convertkey1",
     204             :                                         KEY_VALUE, "meta line1",
     205             :                                         KEY_META, "order", "10",
     206             :                                         KEY_META, "convert/metaname", "testmeta1",
     207             :                                         KEY_META, "convert/append", "next",
     208             :                                         KEY_END),
     209             :                         keyNew ("user/convertkey2",
     210             :                                         KEY_VALUE, "meta line2",
     211             :                                         KEY_META, "order", "20",
     212             :                                         KEY_META, "convert/metaname", "testmeta2",
     213             :                                         KEY_META, "convert/append", "next",
     214             :                                         KEY_END),
     215             :                         keyNew ("user/normalkey1",
     216             :                                         KEY_META, "order", "30",
     217             :                                         KEY_END),
     218             :                         KS_END);
     219             : }
     220             : 
     221           2 : static KeySet* createSameLevelTestKeys(void)
     222             : {
     223           2 :         return ksNew (20,
     224             :                         keyNew ("user/levelkey1",
     225             :                                         KEY_META, "order", "10",
     226             :                                         KEY_END),
     227             :                         keyNew ("user/levelkey1/convertkey1",
     228             :                                         KEY_VALUE, "convertkey1value",
     229             :                                         KEY_META, "order","20",
     230             :                                         KEY_META, "convert/metaname", "testmeta",
     231             :                                         KEY_META, "convert/append", "next",
     232             :                                         KEY_META, "convert/append/samelevel", "",
     233             :                                         KEY_END),
     234             :                         keyNew ("user/levelkey1/childkey1",
     235             :                                         KEY_META, "order", "30",
     236             :                                         KEY_END),
     237             :                         keyNew ("user/levelkey1/convertkey2",
     238             :                                         KEY_VALUE, "convertkey2value",
     239             :                                         KEY_META, "order", "40",
     240             :                                         KEY_META, "convert/metaname", "testmeta",
     241             :                                         KEY_META, "convert/append", "next",
     242             :                                         KEY_META, "convert/append/samelevel", "",
     243             :                                         KEY_END),
     244             :                         keyNew ("user/levelkey2",
     245             :                                         KEY_META, "order", "50",
     246             :                                         KEY_END),
     247             :                         KS_END);
     248             : }
     249             : // clang-format on
     250             : 
     251           2 : void test_parentAppendMode (void)
     252             : {
     253           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     254           2 :         KeySet * conf = ksNew (0, KS_END);
     255           2 :         PLUGIN_OPEN ("keytometa");
     256             : 
     257           2 :         KeySet * ks = createParentTestKeys ();
     258             : 
     259           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     260           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     261           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     262             : 
     263             :         /* parentkey1 must contain meta information generated from convertkeydirect (via parent) */
     264           2 :         Key * key = ksLookupByName (ks, "user/parentkey1", 0);
     265           2 :         succeed_if (key, "parentkey1 was removed");
     266             : 
     267           2 :         const Key * metaKey1 = keyGetMeta (key, "testmeta");
     268           2 :         succeed_if (metaKey1, "parentkey1 contained no metakey");
     269           2 :         succeed_if (!strcmp (keyString (metaKey1), "testvalue1"), "metakey of parentkey1 contained incorrect data");
     270             : 
     271             :         /* parentkey2 must contain meta information generated from convertkeyhole (via parent) */
     272           2 :         key = ksLookupByName (ks, "user/parentkey2", 0);
     273           2 :         succeed_if (key, "parentkey2 was removed");
     274             : 
     275           2 :         const Key * metaKey2 = keyGetMeta (key, "testmeta");
     276           2 :         succeed_if (metaKey2, "parentkey2 contained no metakey");
     277           2 :         succeed_if (!strcmp (keyString (metaKey2), "testvalue2"), "metakey of parentkey2 contained incorrect data");
     278             : 
     279             :         /* parentkey3 must contain meta information generated from convertkeyprev
     280             :          * (via previous append samelevel which falls back to parent) */
     281           2 :         key = ksLookupByName (ks, "user/parentkey3", 0);
     282           2 :         succeed_if (key, "parentkey3 was removed");
     283             : 
     284           2 :         const Key * metaKey3 = keyGetMeta (key, "testmeta");
     285           2 :         succeed_if (metaKey3, "parentkey3 contained no metakey");
     286           2 :         succeed_if (!strcmp (keyString (metaKey3), "testvalue3"), "metakey of parentkey3 contained incorrect data");
     287             : 
     288             :         /* normalkey1 must not contain metadata */
     289           2 :         key = ksLookupByName (ks, "user/normalkey1", 0);
     290           2 :         succeed_if (key, "normalkey1 was removed");
     291           2 :         succeed_if (!keyGetMeta (key, "testmeta"), "normalkey1 should not contain any metadata");
     292             : 
     293             :         /* parentkey4 must contain meta information generated from convertkeynext
     294             :          * (via next append samelevel which falls back to parent) */
     295           2 :         key = ksLookupByName (ks, "user/parentkey4", 0);
     296           2 :         succeed_if (key, "parentkey4 was removed");
     297             : 
     298           2 :         const Key * metaKey4 = keyGetMeta (key, "testmeta");
     299           2 :         succeed_if (metaKey4, "parentkey4 contained no metakey");
     300           2 :         succeed_if (!strcmp (keyString (metaKey4), "testvalue4"), "metakey of parentkey4 contained incorrect data");
     301             : 
     302             :         /* normalkey2 must not contain metadata */
     303           2 :         key = ksLookupByName (ks, "user/normalkey2", 0);
     304           2 :         succeed_if (key, "normalkey2 was removed");
     305           2 :         succeed_if (!keyGetMeta (key, "testmeta"), "normalkey2 should not contain any metadata");
     306             : 
     307             : 
     308           2 :         keyDel (parentKey);
     309           2 :         ksDel (ks);
     310           2 :         PLUGIN_CLOSE ();
     311           2 : }
     312             : 
     313             : 
     314           2 : void test_simpleAppendModes (void)
     315             : {
     316           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     317           2 :         KeySet * conf = ksNew (0, KS_END);
     318           2 :         PLUGIN_OPEN ("keytometa");
     319             : 
     320             : 
     321           2 :         KeySet * ks = createSimpleTestKeys ();
     322             : 
     323           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     324           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     325           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     326             : 
     327             :         /* converted keys must be removed from the result */
     328           2 :         succeed_if (!ksLookupByName (ks, "user/convertkey1", 0), "convertkey1 was not converted");
     329           2 :         succeed_if (!ksLookupByName (ks, "user/convertkey2", 0), "convertkey2 was not converted");
     330             : 
     331             :         /* normalkey2 must contain meta information generated from convertkey1 (via next) */
     332           2 :         Key * key = ksLookupByName (ks, "user/normalkey2", 0);
     333           2 :         succeed_if (key, "normalkey2 was removed");
     334             : 
     335           2 :         const Key * metaKey1 = keyGetMeta (key, "testmeta");
     336           2 :         succeed_if (metaKey1, "normalkey2 contained no metakey");
     337           2 :         succeed_if (!strcmp (keyString (metaKey1), "testvalue1"), "metakey of normalkey2 contained incorrect data");
     338             : 
     339             :         /* normalkey3 must contain meta information generated from convertkey2 (via previous) */
     340           2 :         key = ksLookupByName (ks, "user/normalkey3", 0);
     341           2 :         succeed_if (key, "normalkey3 was removed");
     342             : 
     343           2 :         const Key * metaKey2 = keyGetMeta (key, "testmeta");
     344           2 :         succeed_if (metaKey2, "normalkey3 contained no metakey");
     345           2 :         succeed_if (!strcmp (keyString (metaKey2), "testvalue2"), "metakey of normalkey3 contained incorrect data");
     346             : 
     347             :         /* normalkey1 must contain meta information generated from subkey (via parent) */
     348           2 :         key = ksLookupByName (ks, "user/normalkey1", 0);
     349           2 :         succeed_if (key, "normalkey1 was removed");
     350             : 
     351           2 :         const Key * metaKey3 = keyGetMeta (key, "testmeta");
     352           2 :         succeed_if (metaKey3, "normalkey1 contained no metakey");
     353           2 :         succeed_if (!strcmp (keyString (metaKey3), "testvalue3"), "metakey of normalkey1 contained incorrect data");
     354             : 
     355             : 
     356           2 :         keyDel (parentKey);
     357           2 :         ksDel (ks);
     358           2 :         PLUGIN_CLOSE ();
     359           2 : }
     360             : 
     361             : 
     362           2 : void test_metaMerging (void)
     363             : {
     364           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     365           2 :         KeySet * conf = ksNew (0, KS_END);
     366           2 :         PLUGIN_OPEN ("keytometa");
     367             : 
     368           2 :         KeySet * ks = createMergeTestkeys ();
     369           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     370           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     371           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     372             : 
     373           2 :         Key * key = ksLookupByName (ks, "user/normalkey1", 0);
     374           2 :         succeed_if (key, "normalkey1 was removed");
     375             : 
     376           2 :         const Key * metaKey1 = keyGetMeta (key, "testmeta");
     377           2 :         succeed_if (metaKey1, "normalkey1 contained no metakey");
     378           2 :         const char * expected1 = "meta line 1\nmeta line 2\nmeta line 3";
     379           2 :         succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey of normalkey1 contained incorrect data");
     380             : 
     381           2 :         key = ksLookupByName (ks, "user/normalkey2", 0);
     382           2 :         succeed_if (key, "normalkey2 was removed");
     383             : 
     384           2 :         const Key * metaKey2 = keyGetMeta (key, "testmeta");
     385           2 :         succeed_if (metaKey2, "normalkey2 contained no metakey");
     386           2 :         const char * expected2 = "meta line 30\nmeta line 31\nmeta line 32";
     387           2 :         succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey of normalkey2 contained incorrect data");
     388             : 
     389             :         /* change the value of the middle key */
     390           2 :         keySetMeta (key, "testmeta", "meta line 30\nchanged meta line\nmeta line 32");
     391             : 
     392           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
     393           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
     394           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
     395             : 
     396           2 :         key = ksLookupByName (ks, "user/convertkey30", 0);
     397           2 :         succeed_if (key, "convertkey30 was not restored");
     398           2 :         succeed_if (!strcmp (keyString (key), "meta line 30"), "value of convertkey30 was modified");
     399             : 
     400           2 :         key = ksLookupByName (ks, "user/convertkey31", 0);
     401           2 :         succeed_if (key, "convertkey31 was not restored");
     402           2 :         succeed_if (!strcmp (keyString (key), "changed meta line"), "meta information was not written back to convertkey31");
     403             : 
     404           2 :         key = ksLookupByName (ks, "user/convertkey32", 0);
     405           2 :         succeed_if (key, "convertkey32 was not restored");
     406           2 :         succeed_if (!strcmp (keyString (key), "meta line 32"), "value of convertkey32 was modified");
     407             : 
     408           2 :         keyDel (parentKey);
     409           2 :         ksDel (ks);
     410           2 :         PLUGIN_CLOSE ();
     411           2 : }
     412             : 
     413           2 : void test_metaSkipMerge (void)
     414             : {
     415           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     416           2 :         KeySet * conf = ksNew (0, KS_END);
     417           2 :         PLUGIN_OPEN ("keytometa");
     418             : 
     419           2 :         KeySet * ks = createSkipMergeTestKeys ();
     420           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     421           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     422           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     423             : 
     424           2 :         Key * key = ksLookupByName (ks, "user/normalkey1", 0);
     425           2 :         succeed_if (key, "normalkey1 was removed");
     426             : 
     427           2 :         const Key * metaKey1 = keyGetMeta (key, "testmeta");
     428           2 :         succeed_if (metaKey1, "normalkey1 contained no metakey");
     429           2 :         const char * expected1 = "meta line1\nmeta line3";
     430           2 :         succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey of normalkey1 contained incorrect data");
     431             : 
     432           2 :         key = ksLookupByName (ks, "user/normalkey2", 0);
     433           2 :         succeed_if (key, "normalkey2 was removed");
     434             : 
     435           2 :         const Key * metaKey2 = keyGetMeta (key, "testmeta");
     436           2 :         succeed_if (metaKey2, "normalkey2 contained no metakey");
     437           2 :         const char * expected2 = "meta line2\nmeta line4";
     438           2 :         succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey of normalkey2 contained incorrect data");
     439             : 
     440           2 :         keyDel (parentKey);
     441           2 :         ksDel (ks);
     442           2 :         PLUGIN_CLOSE ();
     443           2 : }
     444             : 
     445           2 : void test_differentMetaNames (void)
     446             : {
     447           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     448           2 :         KeySet * conf = ksNew (0, KS_END);
     449           2 :         PLUGIN_OPEN ("keytometa");
     450             : 
     451           2 :         KeySet * ks = createDifferentMetaNameTestKeys ();
     452           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     453           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     454           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     455             : 
     456           2 :         Key * key = ksLookupByName (ks, "user/normalkey1", 0);
     457           2 :         succeed_if (key, "normalkey1 was removed");
     458             : 
     459           2 :         const Key * metaKey1 = keyGetMeta (key, "testmeta1");
     460           2 :         succeed_if (metaKey1, "normalkey1 contained no meta testmeta1");
     461           2 :         const char * expected1 = "meta line1";
     462           2 :         succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey testmeta1 of normalkey1 contained incorrect data");
     463             : 
     464           2 :         const Key * metaKey2 = keyGetMeta (key, "testmeta2");
     465           2 :         succeed_if (metaKey2, "normalkey1 contained no meta testmeta1");
     466           2 :         const char * expected2 = "meta line2";
     467           2 :         succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey testmeta1 of normalkey1 contained incorrect data");
     468             : 
     469           2 :         keyDel (parentKey);
     470           2 :         ksDel (ks);
     471           2 :         PLUGIN_CLOSE ();
     472           2 : }
     473             : 
     474           2 : void test_appendSameLevel (void)
     475             : {
     476           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     477           2 :         KeySet * conf = ksNew (0, KS_END);
     478           2 :         PLUGIN_OPEN ("keytometa");
     479             : 
     480           2 :         KeySet * ks = createSameLevelTestKeys ();
     481           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     482           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     483           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     484             : 
     485             :         /* convertkey1 should be converted to childkey1 as childkey1 is on the same level as requested */
     486           2 :         Key * childKey = ksLookupByName (ks, "user/levelkey1/childkey1", 0);
     487           2 :         succeed_if (childKey, "childkey1 was removed");
     488             : 
     489           2 :         const Key * metaKey1 = keyGetMeta (childKey, "testmeta");
     490           2 :         succeed_if (metaKey1, "childkey1 contained no meta testmeta");
     491           2 :         const char * expected1 = "convertkey1value";
     492           2 :         succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey testmeta of childkey1 contained incorrect data");
     493             : 
     494             :         /* convertkey2 should be converted to levelkey as the next key in order is not on the same level */
     495           2 :         Key * levelkey1 = ksLookupByName (ks, "user/levelkey1", 0);
     496           2 :         succeed_if (levelkey1, "levelkey1 was removed");
     497             : 
     498           2 :         const Key * metaKey2 = keyGetMeta (levelkey1, "testmeta");
     499           2 :         succeed_if (metaKey2, "levelkey1 contained no meta testmeta");
     500           2 :         const char * expected2 = "convertkey2value";
     501           2 :         succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey testmeta of levelkey1 contained incorrect data");
     502             : 
     503           2 :         keyDel (parentKey);
     504           2 :         ksDel (ks);
     505           2 :         PLUGIN_CLOSE ();
     506           2 : }
     507             : 
     508           2 : void test_restoreOnSet (void)
     509             : {
     510           2 :         Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
     511           2 :         KeySet * conf = ksNew (0, KS_END);
     512           2 :         PLUGIN_OPEN ("keytometa");
     513             : 
     514           2 :         KeySet * ks = createSimpleTestKeys ();
     515             : 
     516           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     517           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     518           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     519             : 
     520           2 :         Key * key = ksLookupByName (ks, "user/normalkey2", 0);
     521           2 :         succeed_if (key, "normalkey2 was removed");
     522             : 
     523             :         /* change the meta information stored in normalkey2
     524             :          * (was generated from convertkey1)
     525             :          */
     526           2 :         keySetMeta (key, "testmeta", "changedtestvalue");
     527             : 
     528             :         /* do not touch the meta information of normalkey3
     529             :          * (was generated from convertkey2)
     530             :          */
     531             : 
     532           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
     533           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
     534           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
     535             : 
     536           2 :         key = ksLookupByName (ks, "user/convertkey1", 0);
     537           2 :         succeed_if (key, "convertkey1 was not restored");
     538           2 :         succeed_if (!strcmp (keyString (key), "changedtestvalue"), "meta information was not written back to convertkey1");
     539             : 
     540           2 :         key = ksLookupByName (ks, "user/convertkey2", 0);
     541           2 :         succeed_if (key, "convertkey2 was not restored");
     542           2 :         succeed_if (!strcmp (keyString (key), "testvalue2"), " value of convertkey2 was modified");
     543             : 
     544           2 :         key = ksLookupByName (ks, "user/normalkey1/subkey", 0);
     545           2 :         succeed_if (key, "subkey was not restored");
     546           2 :         succeed_if (!strcmp (keyString (key), "testvalue3"), " value of subkey was modified");
     547             : 
     548             : 
     549           2 :         keyDel (parentKey);
     550           2 :         ksDel (ks);
     551           2 :         PLUGIN_CLOSE ();
     552           2 : }
     553             : 
     554           2 : int main (int argc, char ** argv)
     555             : {
     556           2 :         printf ("KEYTOMETA       TESTS\n");
     557           2 :         printf ("==================\n\n");
     558             : 
     559           2 :         init (argc, argv);
     560             : 
     561           2 :         test_simpleAppendModes ();
     562           2 :         test_parentAppendMode ();
     563           2 :         test_metaMerging ();
     564           2 :         test_metaSkipMerge ();
     565           2 :         test_differentMetaNames ();
     566           2 :         test_appendSameLevel ();
     567           2 :         test_restoreOnSet ();
     568             : 
     569           2 :         print_result ("test_keytometa");
     570             : 
     571           2 :         return nbError;
     572             : }

Generated by: LCOV version 1.13