LCOV - code coverage report
Current view: top level - src/bindings/glib/tests - testglib_keyset.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 93 93 100.0 %
Date: 2019-09-12 12:28:41 Functions: 5 5 100.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include "gelektra-keyset.h"
      10             : #include <glib-object.h>
      11             : #include <tests.h>
      12             : 
      13           1 : static void test_ctor (void)
      14             : {
      15             :         GElektraKeySet * ks;
      16             : 
      17           1 :         ks = gelektra_keyset_new (0);
      18           1 :         succeed_if (ks != NULL, "unable to create keyset");
      19           1 :         g_object_unref (ks);
      20             : 
      21           1 :         GElektraKey * key = gelektra_key_new ("user/foo", GELEKTRA_KEY_END);
      22           1 :         ks = gelektra_keyset_new (10, key, GELEKTRA_KEYSET_END);
      23           1 :         succeed_if (ks != NULL, "unable to create keyset");
      24           1 :         g_object_unref (ks);
      25             : 
      26           1 :         KeySet * cks = ksNew (0, KS_END);
      27           1 :         ks = gelektra_keyset_make (cks);
      28           1 :         succeed_if (ks->keyset == cks, "new keyset not wrapped");
      29           1 :         g_object_unref (ks);
      30           1 : }
      31             : 
      32           1 : static void test_basic (void)
      33             : {
      34             :         GElektraKeySet *ks1, *ks2;
      35             :         GElektraKey * key;
      36             : 
      37           1 :         ks1 = gelektra_keyset_new (0);
      38           1 :         succeed_if (gelektra_keyset_len (ks1) == 0, "len must be 0");
      39             : 
      40           1 :         gelektra_keyset_append (ks1, gelektra_key_new ("user/foo", GELEKTRA_KEY_END));
      41           1 :         succeed_if (gelektra_keyset_len (ks1) == 1, "len must be 1");
      42             : 
      43           1 :         ks2 = gelektra_keyset_dup (ks1);
      44           1 :         succeed_if (gelektra_keyset_len (ks2) == 1, "len must be 1");
      45             : 
      46           1 :         gelektra_keyset_clear (ks2);
      47           1 :         succeed_if (gelektra_keyset_len (ks2) == 0, "len must be 0");
      48             : 
      49           1 :         gelektra_keyset_copy (ks1, ks2);
      50           1 :         succeed_if (gelektra_keyset_len (ks2) == 1, "len must be 1 again");
      51             : 
      52           1 :         gelektra_keyset_clear (ks2);
      53           1 :         gelektra_keyset_append (ks2, gelektra_key_new ("user/bar", GELEKTRA_KEY_END));
      54           1 :         gelektra_keyset_append_keyset (ks1, ks2);
      55           1 :         succeed_if (gelektra_keyset_len (ks1) == 2, "len must be 2");
      56             : 
      57           1 :         key = gelektra_keyset_pop (ks1);
      58           1 :         succeed_if (gelektra_keyset_len (ks1) == 1, "len must be 1 again");
      59           1 :         g_object_unref (key);
      60             : 
      61           1 :         key = gelektra_key_new ("user", GELEKTRA_KEY_END);
      62           1 :         ks2 = gelektra_keyset_cut (ks1, key);
      63           1 :         succeed_if (gelektra_keyset_len (ks2) == 1, "len must be 1");
      64           1 :         g_object_unref (key);
      65           1 :         g_object_unref (ks2);
      66             : 
      67           1 :         g_object_unref (ks1);
      68           1 : }
      69             : 
      70           1 : static void test_searching (void)
      71             : {
      72             :         GElektraKeySet * ks;
      73             :         GElektraKey *key1, *key2;
      74           1 :         const char * name = "user/bar";
      75             : 
      76           1 :         key1 = gelektra_key_new (name, GELEKTRA_KEY_END);
      77           1 :         g_object_ref (key1);
      78           1 :         ks = gelektra_keyset_new (3, gelektra_key_new ("user/foo", GELEKTRA_KEY_END), key1,
      79             :                                   gelektra_key_new ("user/foobar", GELEKTRA_KEY_END), GELEKTRA_KEYSET_END);
      80             : 
      81           1 :         key2 = gelektra_keyset_lookup (ks, key1, GELEKTRA_KDB_O_NONE);
      82           1 :         succeed_if (gelektra_key_cmp (key1, key2) == 0, "lookup returned different key");
      83           1 :         g_object_unref (key2);
      84             : 
      85           1 :         key2 = gelektra_keyset_lookup_byname (ks, name, GELEKTRA_KDB_O_NONE);
      86           1 :         succeed_if (gelektra_key_cmp (key1, key2) == 0, "lookup returned different key");
      87           1 :         g_object_unref (key2);
      88             : 
      89           1 :         g_object_unref (key1);
      90           1 :         g_object_unref (ks);
      91           1 : }
      92             : 
      93           1 : static void test_iterating (void)
      94             : {
      95             :         GElektraKeySet * ks;
      96             :         GElektraKey *key1, *key2, *tmpkey;
      97             : 
      98           1 :         key1 = gelektra_key_new ("user/a", GELEKTRA_KEY_END);
      99           1 :         g_object_ref (key1);
     100           1 :         key2 = gelektra_key_new ("user/c", GELEKTRA_KEY_END);
     101           1 :         g_object_ref (key2);
     102           1 :         ks = gelektra_keyset_new (3, key1, gelektra_key_new ("user/b", GELEKTRA_KEY_END), key2, GELEKTRA_KEYSET_END);
     103             : 
     104           1 :         guint cnt = 0;
     105           1 :         gelektra_keyset_rewind (ks);
     106           5 :         while ((tmpkey = gelektra_keyset_next (ks)) != NULL)
     107             :         {
     108           3 :                 GElektraKey * curkey = gelektra_keyset_current (ks);
     109           3 :                 succeed_if (gelektra_key_cmp (tmpkey, curkey) == 0, "iterators returned different keys");
     110           3 :                 g_object_unref (curkey);
     111             : 
     112           3 :                 succeed_if (gelektra_keyset_getcursor (ks) == cnt, "cursor is at unexpected position");
     113             : 
     114           3 :                 ++cnt;
     115           3 :                 g_object_unref (tmpkey);
     116             :         }
     117           1 :         succeed_if (cnt == 3, "some keys are missing");
     118             : 
     119           1 :         tmpkey = gelektra_keyset_head (ks);
     120           1 :         succeed_if (gelektra_key_cmp (tmpkey, key1) == 0, "keyset_head returned unexpected key");
     121           1 :         g_object_unref (tmpkey);
     122             : 
     123           1 :         tmpkey = gelektra_keyset_tail (ks);
     124           1 :         succeed_if (gelektra_key_cmp (tmpkey, key2) == 0, "keyset_tail returned unexpected key");
     125           1 :         g_object_unref (tmpkey);
     126             : 
     127           1 :         tmpkey = gelektra_keyset_atcursor (ks, 0);
     128           1 :         succeed_if (gelektra_key_cmp (tmpkey, key1) == 0, "keyset_atcursor returned unexpected key");
     129           1 :         g_object_unref (tmpkey);
     130             : 
     131           1 :         gelektra_keyset_setcursor (ks, 1);
     132           1 :         succeed_if (gelektra_keyset_getcursor (ks) == 1, "cursor is at unexpected position");
     133             : 
     134           1 :         g_object_unref (key1);
     135           1 :         g_object_unref (key2);
     136           1 :         g_object_unref (ks);
     137           1 : }
     138             : 
     139           1 : int main (int argc, char ** argv)
     140             : {
     141           1 :         printf ("KEYSET TESTS\n");
     142           1 :         printf ("===============\n\n");
     143             : 
     144           1 :         init (argc, argv);
     145             : 
     146           1 :         test_ctor ();
     147           1 :         test_basic ();
     148           1 :         test_searching ();
     149           1 :         test_iterating ();
     150             : 
     151           1 :         printf ("\n%s RESULTS: %d test(s) done. %d error(s).\n", argv[0], nbTest, nbError);
     152           1 :         return nbError;
     153             : }

Generated by: LCOV version 1.13