LCOV - code coverage report
Current view: top level - src/plugins/reference - testmod_reference.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 113 113 100.0 %
Date: 2019-09-12 12:28:41 Functions: 8 8 100.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for reference plugin
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include <stdlib.h>
      11             : #include <string.h>
      12             : 
      13             : #include <kdbmacros.h>
      14             : 
      15             : #include <tests_plugin.h>
      16             : 
      17             : #include "reference.h"
      18             : 
      19             : #define BASE_KEY "user/tests/reference"
      20             : 
      21             : #define xstr(a) str (a)
      22             : #define str(a) #a
      23             : 
      24             : #define SETUP(name)                                                                                                                        \
      25             :         printf ("test %s\n", #name);                                                                                                       \
      26             :                                                                                                                                            \
      27             :         Key * parentKey = keyNew (BASE_KEY, KEY_END);                                                                                      \
      28             :         KeySet * conf = ksNew (0, KS_END);                                                                                                 \
      29             :         PLUGIN_OPEN ("reference");
      30             : 
      31             : #define TEARDOWN()                                                                                                                         \
      32             :         keyDel (parentKey);                                                                                                                \
      33             :         PLUGIN_CLOSE ();
      34             : 
      35             : #define RESET_ERRORS() keySetMeta (parentKey, "error", NULL);
      36             : #define RESET_WARNINGS() keySetMeta (parentKey, "warnings", NULL);
      37             : 
      38             : #define RESET(NAME)                                                                                                                        \
      39             :         ksDel (NAME##_keys);                                                                                                               \
      40             :         RESET_ERRORS ();                                                                                                                   \
      41             :         RESET_WARNINGS ();
      42             : 
      43             : #define WITH_KEYS(NAME, COUNT, ...)                                                                                                        \
      44             :         struct __test * NAME = NULL;                                                                                                       \
      45             :         KeySet * NAME##_keys = ksNew (COUNT, __VA_ARGS__, KS_END);
      46             : 
      47             : #define TEST_SET(NAME, EXPECTED)                                                                                                           \
      48             :         dummy (NAME);                                                                                                                      \
      49             :         succeed_if (plugin->kdbSet (plugin, NAME##_keys, parentKey) == EXPECTED, "** " #NAME ": unexpected set result");
      50             : 
      51             : #define EXPECT_ERROR(NAME, ERROR_CODE)                                                                                                     \
      52             :         dummy (NAME);                                                                                                                      \
      53             :         succeed_if (check_error0 (parentKey, ERROR_CODE), "** " #NAME ": got wrong error: " xstr (ERROR_CODE));
      54             : 
      55             : struct __test;
      56             : 
      57             : static inline void dummy (struct __test * ks ELEKTRA_UNUSED, ...)
      58             : {
      59             : }
      60             : 
      61          18 : static bool check_error0 (const Key * parentKey, const char * expectedError)
      62             : {
      63          18 :         const Key * errorKey = keyGetMeta (parentKey, "error/number");
      64          18 :         const char * actualError = errorKey != NULL ? keyString (errorKey) : NULL;
      65          18 :         return actualError != NULL && strcmp (actualError, expectedError) == 0;
      66             : }
      67             : 
      68           2 : static void test_single_negative (void)
      69             : {
      70           2 :         SETUP (single positive)
      71             : 
      72           2 :         WITH_KEYS (full, 2,
      73             :                    keyNew (BASE_KEY "/ref/full", KEY_VALUE, BASE_KEY "/target", KEY_META, CHECK_REFERENCE_KEYNAME,
      74             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
      75             :                    keyNew (BASE_KEY "/target", KEY_END))
      76           2 :         TEST_SET (full, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
      77           2 :         RESET (full)
      78             : 
      79           2 :         WITH_KEYS (relative1, 2,
      80             :                    keyNew (BASE_KEY "/ref/relative1", KEY_VALUE, "../../target", KEY_META, CHECK_REFERENCE_KEYNAME,
      81             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
      82             :                    keyNew (BASE_KEY "/target", KEY_END))
      83           2 :         TEST_SET (relative1, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
      84           2 :         RESET (relative1)
      85             : 
      86           2 :         WITH_KEYS (relative2, 2,
      87             :                    keyNew (BASE_KEY "/ref/relative2", KEY_VALUE, "./target", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_SINGLE,
      88             :                            KEY_END),
      89             :                    keyNew (BASE_KEY "/ref/relative2/target", KEY_END))
      90           2 :         TEST_SET (relative2, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
      91           2 :         RESET (relative2)
      92             : 
      93           2 :         WITH_KEYS (relative3, 2,
      94             :                    keyNew (BASE_KEY "/ref/relative3", KEY_VALUE, "@/ref/target", KEY_META, CHECK_REFERENCE_KEYNAME,
      95             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
      96             :                    keyNew (BASE_KEY "/ref/target", KEY_END))
      97           2 :         TEST_SET (relative3, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
      98           2 :         RESET (relative3)
      99             : 
     100           2 :         WITH_KEYS (array, 5,
     101             :                    keyNew (BASE_KEY "/ref/array", KEY_VALUE, "#1", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
     102             :                    keyNew (BASE_KEY "/ref/array/#0", KEY_VALUE, BASE_KEY "/target0", KEY_END),
     103             :                    keyNew (BASE_KEY "/ref/array/#1", KEY_VALUE, BASE_KEY "/target1", KEY_END), keyNew (BASE_KEY "/target0", KEY_END),
     104             :                    keyNew (BASE_KEY "/target1", KEY_END))
     105           2 :         TEST_SET (array, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     106           2 :         RESET (array)
     107             : 
     108           2 :         TEARDOWN ()
     109           2 : }
     110             : 
     111           2 : static void test_single_positive (void)
     112             : {
     113           2 :         SETUP (single positive)
     114             : 
     115           2 :         WITH_KEYS (full_negative, 2,
     116             :                    keyNew (BASE_KEY "/ref/neg/full", KEY_VALUE, BASE_KEY "/target", KEY_META, CHECK_REFERENCE_KEYNAME,
     117             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
     118             :                    keyNew (BASE_KEY "/hidden/target", KEY_END))
     119           2 :         TEST_SET (full_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     120           2 :         EXPECT_ERROR (full_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     121           2 :         RESET (full_negative)
     122             : 
     123           2 :         WITH_KEYS (relative1_negative, 2,
     124             :                    keyNew (BASE_KEY "/ref/neg/relative1", KEY_VALUE, "../../target", KEY_META, CHECK_REFERENCE_KEYNAME,
     125             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
     126             :                    keyNew (BASE_KEY "/hidden/target", KEY_END))
     127           2 :         TEST_SET (relative1_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     128           2 :         EXPECT_ERROR (relative1_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     129           2 :         RESET (relative1_negative)
     130             : 
     131           2 :         WITH_KEYS (relative2_negative, 2,
     132             :                    keyNew (BASE_KEY "/ref/neg/relative2", KEY_VALUE, "./target", KEY_META, CHECK_REFERENCE_KEYNAME,
     133             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
     134             :                    keyNew (BASE_KEY "/hidden/ref/relative2/target", KEY_END))
     135           2 :         TEST_SET (relative2_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     136           2 :         EXPECT_ERROR (relative2_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     137           2 :         RESET (relative2_negative)
     138             : 
     139           2 :         WITH_KEYS (relative3_negative, 2,
     140             :                    keyNew (BASE_KEY "/ref/neg/relative3", KEY_VALUE, "@/ref/target", KEY_META, CHECK_REFERENCE_KEYNAME,
     141             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
     142             :                    keyNew (BASE_KEY "/hidden/ref/target", KEY_END))
     143           2 :         TEST_SET (relative3_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     144           2 :         EXPECT_ERROR (relative3_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     145           2 :         RESET (relative3_negative)
     146             : 
     147           2 :         WITH_KEYS (array_negative, 5,
     148             :                    keyNew (BASE_KEY "/ref/array", KEY_VALUE, "#1", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_SINGLE, KEY_END),
     149             :                    keyNew (BASE_KEY "/ref/array/#0", KEY_VALUE, BASE_KEY "/target0", KEY_END),
     150             :                    keyNew (BASE_KEY "/ref/array/#1", KEY_VALUE, BASE_KEY "/target1", KEY_END), keyNew (BASE_KEY "/hidden/target0", KEY_END),
     151             :                    keyNew (BASE_KEY "/hidden/target1", KEY_END))
     152           2 :         TEST_SET (array_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     153           2 :         EXPECT_ERROR (array_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     154           2 :         RESET (array_negative)
     155             : 
     156           2 :         TEARDOWN ();
     157           2 : }
     158             : 
     159           2 : static void test_recursive_positive (void)
     160             : {
     161           2 :         SETUP (recursive positive)
     162             : 
     163           2 :         WITH_KEYS (linked_list, 9, keyNew (BASE_KEY "/head", KEY_VALUE, "head", KEY_END),
     164             :                    keyNew (BASE_KEY "/head/ref", KEY_VALUE, BASE_KEY "/element0", KEY_META, CHECK_REFERENCE_KEYNAME,
     165             :                            CHECK_REFERNCE_VALUE_RECURSIVE, KEY_END),
     166             :                    keyNew (BASE_KEY "/element0", KEY_VALUE, "element0", KEY_END),
     167             :                    keyNew (BASE_KEY "/element0/ref", KEY_VALUE, BASE_KEY "/element1", KEY_END),
     168             :                    keyNew (BASE_KEY "/element1", KEY_VALUE, "element1", KEY_END),
     169             :                    keyNew (BASE_KEY "/element1/ref", KEY_VALUE, BASE_KEY "/element2", KEY_END),
     170             :                    keyNew (BASE_KEY "/element2", KEY_VALUE, "element2", KEY_END),
     171             :                    keyNew (BASE_KEY "/element2/ref", KEY_VALUE, BASE_KEY "/element3", KEY_END),
     172             :                    keyNew (BASE_KEY "/element3", KEY_VALUE, "element3", KEY_END))
     173           2 :         TEST_SET (linked_list, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     174           2 :         RESET (linked_list)
     175             : 
     176           2 :         WITH_KEYS (
     177             :                 tree, 15, keyNew (BASE_KEY "/head", KEY_VALUE, "head", KEY_END),
     178             :                 keyNew (BASE_KEY "/head/ref", KEY_VALUE, "#1", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_RECURSIVE, KEY_END),
     179             :                 keyNew (BASE_KEY "/head/ref/#0", KEY_VALUE, BASE_KEY "/element0", KEY_END),
     180             :                 keyNew (BASE_KEY "/head/ref/#1", KEY_VALUE, BASE_KEY "/element1", KEY_END),
     181             :                 keyNew (BASE_KEY "/element0", KEY_VALUE, "element0", KEY_END), keyNew (BASE_KEY "/element0/ref", KEY_VALUE, "#2", KEY_END),
     182             :                 keyNew (BASE_KEY "/element0/ref/#0", KEY_VALUE, BASE_KEY "/element00", KEY_END),
     183             :                 keyNew (BASE_KEY "/element0/ref/#1", KEY_VALUE, BASE_KEY "/element01", KEY_END),
     184             :                 keyNew (BASE_KEY "/element0/ref/#2", KEY_VALUE, BASE_KEY "/element02", KEY_END),
     185             :                 keyNew (BASE_KEY "/element1", KEY_VALUE, "element1", KEY_END),
     186             :                 keyNew (BASE_KEY "/element00", KEY_VALUE, "element00", KEY_END),
     187             :                 keyNew (BASE_KEY "/element01", KEY_VALUE, "element01", KEY_END),
     188             :                 keyNew (BASE_KEY "/element02", KEY_VALUE, "element02", KEY_END),
     189             :                 keyNew (BASE_KEY "/element02/ref", KEY_VALUE, BASE_KEY "/element020", KEY_END),
     190             :                 keyNew (BASE_KEY "/element020", KEY_VALUE, "element020", KEY_END))
     191           2 :         TEST_SET (tree, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     192           2 :         RESET (tree)
     193             : 
     194           2 :         WITH_KEYS (
     195             :                 merge, 9, keyNew (BASE_KEY "/head", KEY_VALUE, "head", KEY_END),
     196             :                 keyNew (BASE_KEY "/head/ref", KEY_VALUE, "#1", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_RECURSIVE, KEY_END),
     197             :                 keyNew (BASE_KEY "/head/ref/#0", KEY_VALUE, BASE_KEY "/element0", KEY_END),
     198             :                 keyNew (BASE_KEY "/head/ref/#1", KEY_VALUE, BASE_KEY "/element1", KEY_END),
     199             :                 keyNew (BASE_KEY "/element0", KEY_VALUE, "element0", KEY_END),
     200             :                 keyNew (BASE_KEY "/element0/ref", KEY_VALUE, BASE_KEY "/element2", KEY_END),
     201             :                 keyNew (BASE_KEY "/element1", KEY_VALUE, "element1", KEY_END),
     202             :                 keyNew (BASE_KEY "/element1/ref", KEY_VALUE, BASE_KEY "/element2", KEY_END),
     203             :                 keyNew (BASE_KEY "/element2", KEY_VALUE, "element2", KEY_END))
     204           2 :         TEST_SET (merge, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     205           2 :         RESET (merge)
     206             : 
     207           2 :         WITH_KEYS (
     208             :                 alternative, 16, keyNew (BASE_KEY "/head", KEY_VALUE, "head", KEY_END),
     209             :                 keyNew (BASE_KEY "/head/ref", KEY_VALUE, "#1", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_RECURSIVE, KEY_END),
     210             :                 keyNew (BASE_KEY "/head/ref/#0", KEY_VALUE, BASE_KEY "/element0", KEY_END),
     211             :                 keyNew (BASE_KEY "/head/ref/#1", KEY_VALUE, BASE_KEY "/element1", KEY_END),
     212             :                 keyNew (BASE_KEY "/element0", KEY_VALUE, "element0", KEY_END), keyNew (BASE_KEY "/element0/ref", KEY_VALUE, "#1", KEY_END),
     213             :                 keyNew (BASE_KEY "/element0/ref/#0", KEY_VALUE, BASE_KEY "/element2", KEY_END),
     214             :                 keyNew (BASE_KEY "/element0/ref/#1", KEY_VALUE, BASE_KEY "/element4", KEY_END),
     215             :                 keyNew (BASE_KEY "/element1", KEY_VALUE, "element1", KEY_END),
     216             :                 keyNew (BASE_KEY "/element1/altref", KEY_VALUE, BASE_KEY "/element2", KEY_META, CHECK_REFERENCE_KEYNAME,
     217             :                         CHECK_REFERNCE_VALUE_ALTERNATIVE, KEY_END),
     218             :                 keyNew (BASE_KEY "/element2", KEY_VALUE, "element2", KEY_END),
     219             :                 keyNew (BASE_KEY "/element2/altref", KEY_VALUE, BASE_KEY "/element3", KEY_END),
     220             :                 keyNew (BASE_KEY "/element3", KEY_VALUE, "element3", KEY_END),
     221             :                 keyNew (BASE_KEY "/element4", KEY_VALUE, "element4", KEY_END),
     222             :                 keyNew (BASE_KEY "/element4/ref", KEY_VALUE, BASE_KEY "/element5", KEY_END),
     223             :                 keyNew (BASE_KEY "/element5", KEY_VALUE, "element5", KEY_END))
     224           2 :         TEST_SET (alternative, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     225           2 :         RESET (alternative)
     226             : 
     227           2 :         TEARDOWN ()
     228           2 : }
     229             : 
     230           2 : static void test_recursive_negative (void)
     231             : {
     232           2 :         SETUP (recursive negative)
     233             : 
     234           2 :         WITH_KEYS (linked_list_negative, 9, keyNew (BASE_KEY "/head", KEY_VALUE, "head", KEY_END),
     235             :                    keyNew (BASE_KEY "/head/ref", KEY_VALUE, BASE_KEY "/element0", KEY_META, CHECK_REFERENCE_KEYNAME,
     236             :                            CHECK_REFERNCE_VALUE_RECURSIVE, KEY_END),
     237             :                    keyNew (BASE_KEY "/element0", KEY_VALUE, "element0", KEY_END),
     238             :                    keyNew (BASE_KEY "/element0/ref", KEY_VALUE, BASE_KEY "/element4", KEY_END),
     239             :                    keyNew (BASE_KEY "/element1", KEY_VALUE, "element1", KEY_END),
     240             :                    keyNew (BASE_KEY "/element1/ref", KEY_VALUE, BASE_KEY "/element2", KEY_END),
     241             :                    keyNew (BASE_KEY "/element2", KEY_VALUE, "element2", KEY_END),
     242             :                    keyNew (BASE_KEY "/element2/ref", KEY_VALUE, BASE_KEY "/element3", KEY_END),
     243             :                    keyNew (BASE_KEY "/element3", KEY_VALUE, "element3", KEY_END))
     244           2 :         TEST_SET (linked_list_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     245           2 :         EXPECT_ERROR (linked_list_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC);
     246           2 :         RESET (linked_list_negative)
     247             : 
     248           2 :         WITH_KEYS (linked_list_negative2, 9, keyNew (BASE_KEY "/head", KEY_VALUE, "head", KEY_END),
     249             :                    keyNew (BASE_KEY "/head/ref", KEY_VALUE, BASE_KEY "/element0", KEY_META, CHECK_REFERENCE_KEYNAME,
     250             :                            CHECK_REFERNCE_VALUE_RECURSIVE, KEY_END),
     251             :                    keyNew (BASE_KEY "/element0", KEY_VALUE, "element0", KEY_END),
     252             :                    keyNew (BASE_KEY "/element0/ref", KEY_VALUE, BASE_KEY "/element1", KEY_END),
     253             :                    keyNew (BASE_KEY "/element1", KEY_VALUE, "element1", KEY_END),
     254             :                    keyNew (BASE_KEY "/element1/ref", KEY_VALUE, BASE_KEY "/element2", KEY_END),
     255             :                    keyNew (BASE_KEY "/element2", KEY_VALUE, "element2", KEY_END),
     256             :                    keyNew (BASE_KEY "/element2/ref", KEY_VALUE, BASE_KEY "/head", KEY_END),
     257             :                    keyNew (BASE_KEY "/element3", KEY_VALUE, "element3", KEY_END))
     258           2 :         TEST_SET (linked_list_negative2, ELEKTRA_PLUGIN_STATUS_ERROR)
     259           2 :         EXPECT_ERROR (linked_list_negative2, ELEKTRA_ERROR_VALIDATION_SEMANTIC);
     260           2 :         RESET (linked_list_negative2)
     261             : 
     262           2 :         TEARDOWN ()
     263           2 : }
     264             : 
     265           2 : static void test_restriction (void)
     266             : {
     267           2 :         SETUP (restriction positive)
     268             : 
     269           2 :         WITH_KEYS (positive, 2,
     270             :                    keyNew (BASE_KEY "/ref", KEY_VALUE, BASE_KEY "/yes/target", KEY_META, CHECK_REFERENCE_KEYNAME,
     271             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_META, CHECK_REFERENCE_RESTRICT_KEYNAME, "../yes/**", KEY_END),
     272             :                    keyNew (BASE_KEY "/yes/target", KEY_END), KS_END)
     273           2 :         TEST_SET (positive, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     274           2 :         RESET (positive)
     275             : 
     276           2 :         WITH_KEYS (empty_positive, 2,
     277             :                    keyNew (BASE_KEY "/ref", KEY_VALUE, "", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_SINGLE, KEY_META,
     278             :                            CHECK_REFERENCE_RESTRICT_KEYNAME, "", KEY_END),
     279             :                    KS_END)
     280           2 :         TEST_SET (empty_positive, ELEKTRA_PLUGIN_STATUS_NO_UPDATE)
     281           2 :         RESET (empty_positive)
     282             : 
     283           2 :         WITH_KEYS (negative, 2,
     284             :                    keyNew (BASE_KEY "/ref", KEY_VALUE, BASE_KEY "/no/target", KEY_META, CHECK_REFERENCE_KEYNAME,
     285             :                            CHECK_REFERNCE_VALUE_SINGLE, KEY_META, CHECK_REFERENCE_RESTRICT_KEYNAME, "../yes/**", KEY_END),
     286             :                    keyNew (BASE_KEY "/no/target", KEY_END), KS_END)
     287           2 :         TEST_SET (negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     288           2 :         EXPECT_ERROR (negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     289           2 :         RESET (negative)
     290             : 
     291           2 :         WITH_KEYS (empty_negative, 2,
     292             :                    keyNew (BASE_KEY "/ref", KEY_VALUE, BASE_KEY "/target", KEY_META, CHECK_REFERENCE_KEYNAME, CHECK_REFERNCE_VALUE_SINGLE,
     293             :                            KEY_META, CHECK_REFERENCE_RESTRICT_KEYNAME, "", KEY_END),
     294             :                    keyNew (BASE_KEY "/target", KEY_END), KS_END)
     295           2 :         TEST_SET (empty_negative, ELEKTRA_PLUGIN_STATUS_ERROR)
     296           2 :         EXPECT_ERROR (empty_negative, ELEKTRA_ERROR_VALIDATION_SEMANTIC)
     297           2 :         RESET (empty_negative)
     298             : 
     299           2 :         TEARDOWN ()
     300           2 : }
     301             : 
     302           2 : static void test_basics (void)
     303             : {
     304           2 :         SETUP (basics)
     305             : 
     306           2 :         KeySet * ks = ksNew (0, KS_END);
     307             : 
     308           2 :         succeed_if (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_NO_UPDATE, "call to kdbGet was not successful");
     309           2 :         succeed_if (plugin->kdbSet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_NO_UPDATE, "call to kdbSet was not successful");
     310             : 
     311           2 :         ksDel (ks);
     312             : 
     313           2 :         TEARDOWN ()
     314           2 : }
     315             : 
     316             : 
     317           2 : int main (int argc, char ** argv)
     318             : {
     319           2 :         printf ("REFERENCE     TESTS\n");
     320           2 :         printf ("==================\n\n");
     321             : 
     322           2 :         init (argc, argv);
     323             : 
     324           2 :         test_basics ();
     325             : 
     326           2 :         test_single_positive ();
     327           2 :         test_single_negative ();
     328             : 
     329           2 :         test_recursive_positive ();
     330           2 :         test_recursive_negative ();
     331             : 
     332           2 :         test_restriction ();
     333             : 
     334           2 :         print_result ("testmod_reference");
     335             : 
     336           2 :         return nbError;
     337             : }

Generated by: LCOV version 1.13