LCOV - code coverage report
Current view: top level - src/plugins/glob - testmod_glob.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 167 167 100.0 %
Date: 2019-09-12 12:28:41 Functions: 11 11 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             : #ifdef HAVE_KDBCONFIG_H
      10             : #include "kdbconfig.h"
      11             : #endif
      12             : 
      13             : #include <stdio.h>
      14             : 
      15             : #include "glob.h"
      16             : #include <fnmatch.h>
      17             : #include <tests.h>
      18             : 
      19             : #include <tests_plugin.h>
      20             : 
      21             : #define NR_KEYS 1
      22             : 
      23           2 : void test_match (void)
      24             : {
      25           2 :         succeed_if (fnmatch ("user/*/to/key", "user/path/to/key", FNM_PATHNAME) == 0, "could not do simple fnmatch");
      26           2 : }
      27             : 
      28           8 : void testKeys (KeySet * ks)
      29             : {
      30           8 :         Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
      31           8 :         exit_if_fail (key, "key user/tests/glob/test1 not found");
      32           8 :         const Key * metaKey = keyGetMeta (key, "testmetakey1");
      33           8 :         exit_if_fail (metaKey, "testmetakey1 not found");
      34           8 :         succeed_if (strcmp ("testvalue1", keyValue (metaKey)) == 0, "value of metakey testmetakey1 not correct");
      35           8 :         metaKey = keyGetMeta (key, "testmetakey2");
      36           8 :         exit_if_fail (metaKey, "testmetakey2 not found");
      37           8 :         succeed_if (strcmp ("testvalue2", keyValue (metaKey)) == 0, "value of metakey testmetakey2 not correct");
      38             : 
      39           8 :         key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
      40           8 :         exit_if_fail (key, "key user/test1/subtest1 not found");
      41           8 :         succeed_if (!keyGetMeta (key, "testmetakey1"), "testmetakey1 copied to wrong key");
      42           8 :         succeed_if (!keyGetMeta (key, "testmetakey2"), "testmetakey2 copied to wrong key");
      43             : 
      44           8 :         key = ksLookupByName (ks, "user/tests/glob/test3", 0);
      45           8 :         exit_if_fail (key, "key user/tests/glob/test3 not found");
      46           8 :         metaKey = keyGetMeta (key, "testmetakey1");
      47           8 :         exit_if_fail (metaKey, "testmetakey1 not found");
      48           8 :         succeed_if (strcmp ("testvalue1", keyValue (metaKey)) == 0, "value of metakey testmetakey1 not correct");
      49           8 :         metaKey = keyGetMeta (key, "testmetakey2");
      50           8 :         exit_if_fail (metaKey, "testmetakey2 not found");
      51           8 :         succeed_if (strcmp ("testvalue2", keyValue (metaKey)) == 0, "value of metakey testmetakey2 not correct");
      52           8 : }
      53             : 
      54          14 : KeySet * createKeys (void)
      55             : {
      56          14 :         KeySet * ks = ksNew (30, keyNew ("user/tests/glob/test1", KEY_END), keyNew ("user/tests/glob/test2/subtest1", KEY_END),
      57             :                              keyNew ("user/tests/glob/test3", KEY_END), KS_END);
      58          14 :         return ks;
      59             : }
      60             : 
      61           2 : void test_zeroMatchFlags (void)
      62             : {
      63           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
      64           2 :         KeySet * conf = ksNew (20, keyNew ("user/glob/#1", KEY_VALUE, "*test1", KEY_META, "testmetakey1", "testvalue1", KEY_END),
      65             :                                /* disable default pathname globbing behaviour */
      66             :                                keyNew ("user/glob/#1/flags", KEY_VALUE, "", KEY_END), KS_END);
      67           2 :         PLUGIN_OPEN ("glob");
      68             : 
      69           2 :         KeySet * ks = createKeys ();
      70             : 
      71           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
      72           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
      73           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
      74             : 
      75             : 
      76           2 :         Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
      77           2 :         exit_if_fail (key, "key user/tests/glob/test1 not found");
      78           2 :         const Key * metaKey1 = keyGetMeta (key, "testmetakey1");
      79           2 :         exit_if_fail (metaKey1, "testmetakey1 not found");
      80           2 :         succeed_if (strcmp ("testvalue1", keyValue (metaKey1)) == 0, "value of metakey testmetakey1 not correct");
      81             : 
      82           2 :         key = ksLookupByName (ks, "user/tests/glob/test3", 0);
      83           2 :         exit_if_fail (key, "user/tests/glob/test3 not found");
      84           2 :         succeed_if (!keyGetMeta (key, "testmetakey1"), "testmetakey1 copied to wrong key");
      85             : 
      86           2 :         key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
      87           2 :         exit_if_fail (key, "user/tests/glob/test2/subtest1 not found");
      88           2 :         const Key * metaKey2 = keyGetMeta (key, "testmetakey1");
      89           2 :         exit_if_fail (metaKey2, "testmetakey1 not found");
      90           2 :         succeed_if (strcmp ("testvalue1", keyValue (metaKey2)) == 0, "value of metakey testmetakey1 not correct");
      91             : 
      92           2 :         ksDel (ks);
      93           2 :         keyDel (parentKey);
      94           2 :         PLUGIN_CLOSE ();
      95           2 : }
      96             : 
      97           2 : void test_setGlobalMatch (void)
      98             : {
      99           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
     100             :         // clang-format off
     101           2 :         KeySet *conf = ksNew (20,
     102             :                         keyNew ("user/glob/#1", KEY_VALUE, "/*",
     103             :                                         KEY_META, "testmetakey1", "testvalue1",
     104             :                                         KEY_META, "testmetakey2", "testvalue2",
     105             :                                         KEY_END),
     106             :                         KS_END);
     107             :         // clang-format on
     108           2 :         PLUGIN_OPEN ("glob");
     109             : 
     110           2 :         KeySet * ks = createKeys ();
     111             : 
     112           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
     113           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
     114           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
     115             : 
     116           2 :         testKeys (ks);
     117           2 :         ksDel (ks);
     118           2 :         keyDel (parentKey);
     119             : 
     120           2 :         PLUGIN_CLOSE ();
     121           2 : }
     122             : 
     123           2 : void test_getGlobalMatch (void)
     124             : {
     125           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
     126             :         // clang-format off
     127           2 :         KeySet *conf = ksNew (20,
     128             :                         keyNew ("user/glob/#1", KEY_VALUE, "/*",
     129             :                                         KEY_META, "testmetakey1", "testvalue1",
     130             :                                         KEY_META, "testmetakey2", "testvalue2",
     131             :                                         KEY_END),
     132             :                         KS_END);
     133             :         // clang-format on
     134           2 :         PLUGIN_OPEN ("glob");
     135             : 
     136           2 :         KeySet * ks = createKeys ();
     137             : 
     138           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     139           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     140           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     141             : 
     142           2 :         testKeys (ks);
     143           2 :         ksDel (ks);
     144           2 :         keyDel (parentKey);
     145             : 
     146           2 :         PLUGIN_CLOSE ();
     147           2 : }
     148             : 
     149           2 : void test_getDirectionMatch (void)
     150             : {
     151           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
     152             :         // clang-format off
     153           2 :         KeySet *conf = ksNew (20,
     154             :                         keyNew ("user/glob/get/#1", KEY_VALUE, "/*",
     155             :                                         KEY_META, "testmetakey1", "testvalue1",
     156             :                                         KEY_META, "testmetakey2", "testvalue2",
     157             :                                         KEY_END),
     158             :                         keyNew ("user/glob/set/#1", KEY_VALUE, "/*/*",
     159             :                                         KEY_META, "testmetakey1", "testvalue1",
     160             :                                         KEY_META, "testmetakey2", "testvalue2",
     161             :                                         KEY_END),
     162             :                         KS_END);
     163             :         // clang-format on
     164           2 :         PLUGIN_OPEN ("glob");
     165             : 
     166           2 :         KeySet * ks = createKeys ();
     167             : 
     168           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
     169           2 :         succeed_if (output_error (parentKey), "error in kdbGet");
     170           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbGet");
     171             : 
     172           2 :         testKeys (ks);
     173           2 :         ksDel (ks);
     174           2 :         keyDel (parentKey);
     175             : 
     176           2 :         PLUGIN_CLOSE ();
     177           2 : }
     178             : 
     179           2 : void test_setDirectionMatch (void)
     180             : {
     181           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
     182             :         // clang-format off
     183           2 :         KeySet *conf = ksNew (20,
     184             :                         keyNew ("user/glob/set/#1", KEY_VALUE, "/*",
     185             :                                         KEY_META, "testmetakey1", "testvalue1",
     186             :                                         KEY_META, "testmetakey2", "testvalue2",
     187             :                                         KEY_END),
     188             :                         keyNew ("user/glob/get/#1", KEY_VALUE, "/*/*",
     189             :                                         KEY_META, "testmetakey1", "testvalue1",
     190             :                                         KEY_META, "testmetakey2", "testvalue2",
     191             :                                         KEY_END),
     192             :                         KS_END);
     193             :         // clang-format on
     194           2 :         PLUGIN_OPEN ("glob");
     195             : 
     196           2 :         KeySet * ks = createKeys ();
     197             : 
     198           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
     199           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
     200           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
     201             : 
     202           2 :         testKeys (ks);
     203           2 :         ksDel (ks);
     204           2 :         keyDel (parentKey);
     205             : 
     206           2 :         PLUGIN_CLOSE ();
     207           2 : }
     208             : 
     209           2 : void test_namedMatchFlags (void)
     210             : {
     211           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
     212           2 :         KeySet * conf = ksNew (20, keyNew ("user/glob/#1", KEY_VALUE, "user/tests/glob/*", KEY_META, "testmetakey1", "testvalue1", KEY_END),
     213             :                                /* explicitly request pathname matching */
     214             :                                keyNew ("user/glob/#1/flags", KEY_VALUE, "pathname", KEY_END), KS_END);
     215           2 :         PLUGIN_OPEN ("glob");
     216             : 
     217           2 :         KeySet * ks = createKeys ();
     218             : 
     219           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
     220           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
     221           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
     222             : 
     223           2 :         Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
     224           2 :         exit_if_fail (key, "key user/tests/glob/test1 not found");
     225           2 :         const Key * metaKey1 = keyGetMeta (key, "testmetakey1");
     226           2 :         exit_if_fail (metaKey1, "testmetakey1 not found");
     227             : 
     228           2 :         key = ksLookupByName (ks, "user/tests/glob/test3", 0);
     229           2 :         exit_if_fail (key, "user/tests/glob/test3 not found");
     230           2 :         const Key * metaKey2 = keyGetMeta (key, "testmetakey1");
     231           2 :         exit_if_fail (metaKey2, "testmetakey1 not found");
     232             : 
     233           2 :         key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
     234           2 :         exit_if_fail (key, "user/tests/glob/test2/subtest1 not found");
     235           2 :         const Key * metaKey3 = keyGetMeta (key, "testmetakey1");
     236           2 :         exit_if_fail (!metaKey3, "testmetakey1 was copied to subtest1, but subtest1 should not be matched with pathname flag");
     237             : 
     238           2 :         ksDel (ks);
     239           2 :         keyDel (parentKey);
     240           2 :         PLUGIN_CLOSE ();
     241           2 : }
     242             : 
     243           2 : void test_onlyFirstMatchIsApplied (void)
     244             : {
     245           2 :         Key * parentKey = keyNew ("user/tests/glob", KEY_END);
     246             :         // clang-format off
     247           2 :         KeySet * conf = ksNew (20,
     248             :                                 keyNew ("user/glob/#1",
     249             :                                                 KEY_VALUE, "user/tests/glob/test1*",
     250             :                                                 KEY_META, "testmetakey1", "testvalue1",
     251             :                                                 KEY_END),
     252             :                                 keyNew ("user/glob/#2",
     253             :                                                 KEY_VALUE, "user/tests/glob/*",
     254             :                                                 KEY_META, "testmetakey2", "testvalue2",
     255             :                                                 KEY_END),
     256             :                                /* disable all flags */
     257             :                             keyNew ("user/glob/#1/flags",
     258             :                                         KEY_VALUE, "",
     259             :                                                 KEY_END),
     260             :                                 keyNew ("user/glob/#2/flags",
     261             :                                                 KEY_VALUE, "",
     262             :                                                 KEY_END),
     263             :                                 KS_END);
     264             :         // clang-format on
     265           2 :         PLUGIN_OPEN ("glob");
     266             : 
     267           2 :         KeySet * ks = createKeys ();
     268             : 
     269           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
     270           2 :         succeed_if (output_error (parentKey), "error in kdbSet");
     271           2 :         succeed_if (output_warnings (parentKey), "warnings in kdbSet");
     272             : 
     273           2 :         Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
     274           2 :         exit_if_fail (key, "key user/tests/glob/test1 not found");
     275           2 :         const Key * firstMatchKey = keyGetMeta (key, "testmetakey1");
     276           2 :         exit_if_fail (firstMatchKey, "testmetakey1 not found");
     277           2 :         const Key * secondMatchKey = keyGetMeta (key, "testmetakey2");
     278           2 :         exit_if_fail (!secondMatchKey, "testmetakey2 was applied to testmetakey1 although another match was already applied")
     279             : 
     280           2 :                 key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
     281           2 :         exit_if_fail (key, "user/tests/glob/test2/subtest1 not found");
     282           2 :         exit_if_fail (keyGetMeta (key, "testmetakey2"), "testmetakey2 not found");
     283             : 
     284           2 :         key = ksLookupByName (ks, "user/tests/glob/test3", 0);
     285           2 :         exit_if_fail (key, "user/tests/glob/test3 not found");
     286           2 :         exit_if_fail (keyGetMeta (key, "testmetakey2"), "testmetakey2 not found");
     287             : 
     288           2 :         ksDel (ks);
     289           2 :         keyDel (parentKey);
     290           2 :         PLUGIN_CLOSE ();
     291           2 : }
     292             : 
     293           2 : int main (int argc, char ** argv)
     294             : {
     295           2 :         printf ("GLOB      TESTS\n");
     296           2 :         printf ("====================\n\n");
     297             : 
     298           2 :         init (argc, argv);
     299             : 
     300           2 :         test_match ();
     301           2 :         test_zeroMatchFlags ();
     302           2 :         test_setGlobalMatch ();
     303           2 :         test_setDirectionMatch ();
     304           2 :         test_getGlobalMatch ();
     305           2 :         test_getDirectionMatch ();
     306           2 :         test_namedMatchFlags ();
     307           2 :         test_onlyFirstMatchIsApplied ();
     308             : 
     309           2 :         print_result ("testmod_glob");
     310             : 
     311           2 :         return nbError;
     312             : }

Generated by: LCOV version 1.13