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

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see doc/LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include "spec.h"
      10             : 
      11             : #include <tests_plugin.h>
      12             : 
      13             : #define PARENT_KEY "/tests/spec"
      14             : 
      15             : #define TEST_BEGIN                                                                                                                         \
      16             :         {                                                                                                                                  \
      17             :                 KeySet * conf = ksDup (_conf);                                                                                             \
      18             :                 PLUGIN_OPEN ("spec");                                                                                                      \
      19             :                 Key * parentKey = keyNew (PARENT_KEY, KEY_END);                                                                            \
      20             :                 bool success = 1;
      21             : 
      22             : #define TEST_END                                                                                                                           \
      23             :         success = 1;                                                                                                                       \
      24             :         keyDel (parentKey);                                                                                                                \
      25             :         PLUGIN_CLOSE ();                                                                                                                   \
      26             :         }
      27             : 
      28             : #define TEST_CHECK(expression, message)                                                                                                    \
      29             :         success = (expression);                                                                                                            \
      30             :         succeed_if (success, message);
      31             : 
      32             : #define TEST_ON_FAIL(block)                                                                                                                \
      33             :         do                                                                                                                                 \
      34             :         {                                                                                                                                  \
      35             :                 if (!success)                                                                                                              \
      36             :                 {                                                                                                                          \
      37             :                         block;                                                                                                             \
      38             :                 }                                                                                                                          \
      39             :         } while (0)
      40             : 
      41           2 : static void test_default (void)
      42             : {
      43           2 :         printf ("test default\n");
      44             : 
      45           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
      46           2 :         TEST_BEGIN
      47             :         {
      48           2 :                 KeySet * ks =
      49           2 :                         ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "default", "17", KEY_META, "othermeta", "", KEY_END), KS_END);
      50             : 
      51           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
      52           2 :                 TEST_ON_FAIL (output_error (parentKey));
      53             : 
      54           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
      55             : 
      56           2 :                 succeed_if (lookup != NULL, ".../a not found");
      57           2 :                 succeed_if_same_string (keyString (lookup), "17");
      58           2 :                 succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
      59             : 
      60           2 :                 ksDel (ks);
      61             :         }
      62           2 :         TEST_END
      63             : 
      64           2 :         TEST_BEGIN
      65             :         {
      66           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "default", "17", KEY_META, "othermeta", "", KEY_END),
      67             :                                      keyNew ("user" PARENT_KEY "/a", KEY_VALUE, "19", KEY_META, "default", "19", KEY_END), KS_END);
      68             : 
      69           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet should fail");
      70             : 
      71           2 :                 ksDel (ks);
      72             :         }
      73           2 :         TEST_END
      74           2 :         ksDel (_conf);
      75           2 : }
      76             : 
      77           2 : static void test_assign_condition (void)
      78             : {
      79           2 :         printf ("test assign/condition\n");
      80             : 
      81           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
      82             : 
      83           2 :         TEST_BEGIN
      84             :         {
      85           2 :                 KeySet * ks =
      86           2 :                         ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "assign/condition", "17", KEY_META, "othermeta", "", KEY_END),
      87             :                                KS_END);
      88             : 
      89           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
      90           2 :                 TEST_ON_FAIL (output_error (parentKey));
      91             : 
      92           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
      93             : 
      94           2 :                 succeed_if (lookup != NULL, ".../a not found");
      95           2 :                 succeed_if_same_string (keyString (lookup), "");
      96           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "assign/condition")), "17");
      97           2 :                 succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
      98             : 
      99           2 :                 ksDel (ks);
     100             :         }
     101           2 :         TEST_END
     102           2 :         ksDel (_conf);
     103           2 : }
     104             : 
     105           2 : static void test_wildcard (void)
     106             : {
     107           2 :         printf ("test wildcard (_)\n");
     108             : 
     109           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
     110             : 
     111           2 :         TEST_BEGIN
     112             :         {
     113           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/_", KEY_META, "default", "17", KEY_META, "othermeta", "", KEY_END),
     114             :                                      keyNew ("user" PARENT_KEY "/a/x", KEY_END), KS_END);
     115             : 
     116           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     117           2 :                 TEST_ON_FAIL (output_error (parentKey));
     118             : 
     119           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a/x", 0);
     120             : 
     121           2 :                 succeed_if (lookup != NULL, ".../a/x not found");
     122             :                 // succeed_if_same_string (keyString (lookup), "17"); // TODO: wildcard defaults, not possible right now
     123           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "17");
     124           2 :                 succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
     125             : 
     126           2 :                 ksDel (ks);
     127             :         }
     128           2 :         TEST_END
     129             : 
     130           2 :         TEST_BEGIN
     131             :         {
     132           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/_", KEY_META, "require/count", "2", KEY_END),
     133             :                                      keyNew ("user" PARENT_KEY "/a/x", KEY_END), keyNew ("user" PARENT_KEY "/a/y", KEY_END), KS_END);
     134             : 
     135           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     136           2 :                 TEST_ON_FAIL (output_error (parentKey));
     137             : 
     138           2 :                 ksDel (ks);
     139             :         }
     140           2 :         TEST_END
     141             : 
     142           2 :         ksDel (_conf);
     143           2 : }
     144             : 
     145           2 : static void test_require (void)
     146             : {
     147           2 :         printf ("test require\n");
     148             : 
     149           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
     150             : 
     151           2 :         TEST_BEGIN
     152             :         {
     153           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "require", "", KEY_END), KS_END);
     154             : 
     155           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     156             : 
     157           2 :                 ksDel (ks);
     158             :         }
     159           2 :         TEST_END
     160             : 
     161           2 :         TEST_BEGIN
     162             :         {
     163           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "require", "", KEY_END),
     164             :                                      keyNew ("user" PARENT_KEY "/a", KEY_END), KS_END);
     165             : 
     166           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     167           2 :                 TEST_ON_FAIL (output_error (parentKey));
     168             : 
     169           2 :                 ksDel (ks);
     170             :         }
     171           2 :         TEST_END
     172           2 :         ksDel (_conf);
     173           2 : }
     174             : 
     175           2 : static void test_array (void)
     176             : {
     177           2 :         printf ("test array\n");
     178             : 
     179           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
     180             : 
     181           2 :         TEST_BEGIN
     182             :         {
     183           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#", KEY_META, "default", "7", KEY_META, "type", "long", KEY_END),
     184             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#5", KEY_END), KS_END);
     185             : 
     186           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     187           2 :                 TEST_ON_FAIL (output_error (parentKey));
     188             : 
     189           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
     190           2 :                 succeed_if (lookup != NULL, ".../a not found");
     191           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#5");
     192           2 :                 succeed_if (keyGetMeta (lookup, "type") == NULL, "parent shouldn't have copied metadata");
     193             : 
     194           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0", 0);
     195           2 :                 succeed_if (lookup != NULL, ".../a/#0 not found");
     196           2 :                 succeed_if_same_string (keyString (lookup), "7");
     197           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     198           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
     199             : 
     200           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#1", 0);
     201           2 :                 succeed_if (lookup != NULL, ".../a/#1 not found");
     202           2 :                 succeed_if_same_string (keyString (lookup), "7");
     203           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     204           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
     205             : 
     206           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#2", 0);
     207           2 :                 succeed_if (lookup != NULL, ".../a/#2 not found");
     208           2 :                 succeed_if_same_string (keyString (lookup), "7");
     209           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     210           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
     211             : 
     212           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#3", 0);
     213           2 :                 succeed_if (lookup != NULL, ".../a/#3 not found");
     214           2 :                 succeed_if_same_string (keyString (lookup), "7");
     215           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     216           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
     217             : 
     218           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#4", 0);
     219           2 :                 succeed_if (lookup != NULL, ".../a/#4 not found");
     220           2 :                 succeed_if_same_string (keyString (lookup), "7");
     221           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     222           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
     223             : 
     224           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#5", 0);
     225           2 :                 succeed_if (lookup != NULL, ".../a/#5 not found");
     226           2 :                 succeed_if_same_string (keyString (lookup), "7");
     227           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     228           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
     229             : 
     230           2 :                 ksDel (ks);
     231             :         }
     232           2 :         TEST_END
     233             : 
     234           2 :         TEST_BEGIN
     235             :         {
     236           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
     237             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     238             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
     239             : 
     240           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     241           2 :                 TEST_ON_FAIL (output_error (parentKey));
     242             : 
     243           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
     244           2 :                 succeed_if (lookup != NULL, ".../a not found");
     245           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#0");
     246             : 
     247           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
     248           2 :                 succeed_if (lookup != NULL, ".../a/#0/b not found");
     249           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#2");
     250             : 
     251           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#0", 0);
     252           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#0 not found");
     253           2 :                 succeed_if_same_string (keyString (lookup), "7");
     254           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     255             : 
     256           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#1", 0);
     257           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#1 not found");
     258           2 :                 succeed_if_same_string (keyString (lookup), "7");
     259           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     260             : 
     261           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#2", 0);
     262           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#2 not found");
     263           2 :                 succeed_if_same_string (keyString (lookup), "7");
     264           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     265             : 
     266           2 :                 ksDel (ks);
     267             :         }
     268           2 :         TEST_END
     269             : 
     270           2 :         TEST_BEGIN
     271             :         {
     272           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
     273             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     274             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
     275             : 
     276           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     277           2 :                 TEST_ON_FAIL (output_error (parentKey));
     278             : 
     279           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
     280           2 :                 succeed_if (lookup != NULL, ".../a not found");
     281           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#0");
     282             : 
     283           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
     284           2 :                 succeed_if (lookup != NULL, ".../a/#0/b not found");
     285           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#2");
     286             : 
     287           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#0", 0);
     288           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#0 not found");
     289           2 :                 succeed_if_same_string (keyString (lookup), "7");
     290           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     291             : 
     292           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#1", 0);
     293           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#1 not found");
     294           2 :                 succeed_if_same_string (keyString (lookup), "7");
     295           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     296             : 
     297           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#2", 0);
     298           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#2 not found");
     299           2 :                 succeed_if_same_string (keyString (lookup), "7");
     300           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     301             : 
     302           2 :                 ksDel (ks);
     303             :         }
     304           2 :         TEST_END
     305             : 
     306           2 :         TEST_BEGIN
     307             :         {
     308           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
     309             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#3", KEY_END),
     310             :                                      keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     311             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
     312             : 
     313           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     314           2 :                 TEST_ON_FAIL (output_error (parentKey));
     315             : 
     316           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
     317           2 :                 succeed_if (lookup != NULL, ".../a not found");
     318           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#0");
     319             : 
     320           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
     321           2 :                 succeed_if (lookup != NULL, ".../a/#0/b not found");
     322           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#2");
     323             : 
     324           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#0", 0);
     325           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#0 not found");
     326           2 :                 succeed_if_same_string (keyString (lookup), "7");
     327           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     328             : 
     329           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#1", 0);
     330           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#1 not found");
     331           2 :                 succeed_if_same_string (keyString (lookup), "7");
     332           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     333             : 
     334           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#2", 0);
     335           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/#2 not found");
     336           2 :                 succeed_if_same_string (keyString (lookup), "7");
     337           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
     338             : 
     339           2 :                 ksDel (ks);
     340             :         }
     341           2 :         TEST_END
     342             : 
     343           2 :         TEST_BEGIN
     344             :         {
     345           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
     346             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array/min", "#3", KEY_END),
     347             :                                      keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     348             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
     349             : 
     350           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     351             : 
     352           2 :                 ksDel (ks);
     353             :         }
     354           2 :         TEST_END
     355             : 
     356           2 :         TEST_BEGIN
     357             :         {
     358           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
     359             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#3", KEY_END),
     360             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END),
     361             :                                      keyNew ("user" PARENT_KEY "/a/#0/b/c", KEY_END), KS_END);
     362             : 
     363           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     364             : 
     365           2 :                 ksDel (ks);
     366             :         }
     367           2 :         TEST_END
     368           2 :         ksDel (_conf);
     369           2 : }
     370             : 
     371           2 : static void test_require_array (void)
     372             : {
     373           2 :         printf ("test require array\n");
     374             : 
     375           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
     376             : 
     377           2 :         TEST_BEGIN
     378             :         {
     379           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "require", "", KEY_END),
     380             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     381             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#0", KEY_END), KS_END);
     382             : 
     383           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     384             : 
     385           2 :                 ksDel (ks);
     386             :         }
     387           2 :         TEST_END
     388             : 
     389           2 :         TEST_BEGIN
     390             :         {
     391           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "require", "", KEY_END),
     392             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     393             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#0", KEY_END),
     394             :                                      keyNew ("user" PARENT_KEY "/a/#0/b/#0", KEY_END), KS_END);
     395             : 
     396           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     397           2 :                 TEST_ON_FAIL (output_error (parentKey));
     398             : 
     399           2 :                 ksDel (ks);
     400             :         }
     401           2 :         TEST_END
     402             : 
     403           2 :         TEST_BEGIN
     404             :         {
     405           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "require", "", KEY_END),
     406             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     407             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#1", KEY_END),
     408             :                                      keyNew ("user" PARENT_KEY "/a/#0/b/#0", KEY_END), KS_END);
     409             : 
     410           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     411             : 
     412           2 :                 ksDel (ks);
     413             :         }
     414           2 :         TEST_END
     415           2 :         ksDel (_conf);
     416           2 : }
     417             : 
     418           2 : static void test_array_member (void)
     419             : {
     420           2 :         printf ("test array member\n");
     421             : 
     422           2 :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
     423             : 
     424           2 :         TEST_BEGIN
     425             :         {
     426           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     427             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END), KS_END);
     428             : 
     429           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     430           2 :                 TEST_ON_FAIL (output_error (parentKey));
     431             : 
     432           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
     433           2 :                 succeed_if (lookup != NULL, ".../a/#0/b not found");
     434           2 :                 succeed_if_same_string (keyString (lookup), "x");
     435           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "x");
     436             : 
     437           2 :                 ksDel (ks);
     438             :         }
     439           2 :         TEST_END
     440             : 
     441           2 :         TEST_BEGIN
     442             :         {
     443           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#", KEY_META, "default", "", KEY_END),
     444             :                                      keyNew ("user" PARENT_KEY "/a/x", KEY_END), KS_END);
     445             : 
     446           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     447             : 
     448           2 :                 ksDel (ks);
     449             :         }
     450           2 :         TEST_END
     451             : 
     452           2 :         TEST_BEGIN
     453             :         {
     454           2 :                 KeySet * ks = ksNew (10, keyNew ("user" PARENT_KEY "/a/x", KEY_VALUE, "y", KEY_END),
     455             :                                      keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     456             :                                      keyNew ("spec" PARENT_KEY "/a/#", KEY_META, "default", "x", KEY_END), KS_END);
     457             : 
     458           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     459             : 
     460           2 :                 ksDel (ks);
     461             :         }
     462           2 :         TEST_END
     463             : 
     464           2 :         TEST_BEGIN
     465             :         {
     466           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
     467             :                                      keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END), KS_END);
     468             : 
     469           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     470           2 :                 TEST_ON_FAIL (output_error (parentKey));
     471             : 
     472           2 :                 ksDel (ks);
     473             :         }
     474           2 :         TEST_END
     475             : 
     476           2 :         TEST_BEGIN
     477             :         {
     478           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     479             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
     480             :                                      keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END),
     481             :                                      keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     482             :                                      keyNew ("user" PARENT_KEY "/a/#0/b/c", KEY_VALUE, "z", KEY_END), KS_END);
     483             : 
     484           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     485           2 :                 TEST_ON_FAIL (output_error (parentKey));
     486             : 
     487           2 :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
     488           2 :                 succeed_if (lookup != NULL, ".../a/#0/b not found");
     489           2 :                 succeed_if_same_string (keyString (lookup), "x");
     490           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "x");
     491             : 
     492           2 :                 lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/c", 0);
     493           2 :                 succeed_if (lookup != NULL, ".../a/#0/b/c not found");
     494           2 :                 succeed_if_same_string (keyString (lookup), "z");
     495           2 :                 succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "y");
     496             : 
     497           2 :                 ksDel (ks);
     498             :         }
     499           2 :         TEST_END
     500             : 
     501           2 :         TEST_BEGIN
     502             :         {
     503           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
     504             :                                      keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END),
     505             :                                      keyNew ("user" PARENT_KEY "/a/x/b/c", KEY_VALUE, "z", KEY_END), KS_END);
     506             : 
     507           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     508             : 
     509           2 :                 ksDel (ks);
     510             :         }
     511           2 :         TEST_END
     512             : 
     513           2 :         TEST_BEGIN
     514             :         {
     515           2 :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     516             :                                      keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
     517             :                                      keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END),
     518             :                                      keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
     519             :                                      keyNew ("user" PARENT_KEY "/a/#0/b/c", KEY_VALUE, "z", KEY_END),
     520             :                                      keyNew ("user" PARENT_KEY "/a/x/b/c", KEY_VALUE, "z", KEY_END), KS_END);
     521             : 
     522           2 :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
     523             : 
     524           2 :                 ksDel (ks);
     525             :         }
     526           2 :         TEST_END
     527           2 :         ksDel (_conf);
     528           2 : }
     529             : 
     530             : /* TODO: find way to remove metadata safely after other plugins ran
     531             : static void test_remove_meta (void)
     532             : {
     533             :         printf ("test remove meta\n");
     534             : 
     535             :         KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
     536             : 
     537             :         TEST_BEGIN
     538             :         {
     539             :                 KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "othermeta", "", KEY_END),
     540             :                                      keyNew ("user" PARENT_KEY "/a", KEY_END), KS_END);
     541             : 
     542             :                 TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
     543             :                 TEST_ON_FAIL (output_error (parentKey));
     544             : 
     545             :                 Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
     546             : 
     547             :                 succeed_if (lookup != NULL, ".../a not found");
     548             :                 succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
     549             : 
     550             :                 TEST_CHECK (plugin->kdbSet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbSet failed");
     551             :                 TEST_ON_FAIL (output_error (parentKey));
     552             : 
     553             :                 lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
     554             : 
     555             :                 succeed_if (lookup != NULL, ".../a not found");
     556             :                 succeed_if (keyGetMeta (lookup, "othermeta") == NULL, "metadata not removed");
     557             : 
     558             :                 ksDel (ks);
     559             :         }
     560             :         TEST_END
     561             :         ksDel (_conf);
     562             : }
     563             : */
     564             : 
     565           2 : int main (int argc, char ** argv)
     566             : {
     567           2 :         printf ("SPEC     TESTS\n");
     568           2 :         printf ("==================\n\n");
     569             : 
     570           2 :         init (argc, argv);
     571             : 
     572           2 :         test_default ();
     573           2 :         test_assign_condition ();
     574           2 :         test_wildcard ();
     575           2 :         test_require ();
     576           2 :         test_array ();
     577           2 :         test_require_array ();
     578           2 :         test_array_member ();
     579             :         // test_remove_meta ();
     580             : 
     581           2 :         print_result ("testmod_spec");
     582             : 
     583           2 :         return nbError;
     584             : }

Generated by: LCOV version 1.13