LCOV - code coverage report
Current view: top level - src/bindings/glib/tests - testglib_key.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 204 204 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             : #include "gelektra-key.h"
      10             : #include <glib-object.h>
      11             : #include <tests.h>
      12             : 
      13           1 : static void test_ctor (void)
      14             : {
      15             :         GElektraKey * key;
      16             : 
      17           1 :         key = gelektra_key_new (NULL);
      18           1 :         succeed_if (key != NULL, "unable to create key");
      19           1 :         succeed_if (!gelektra_key_isvalid (key), "key should be invalid");
      20           1 :         g_object_unref (key);
      21             : 
      22           1 :         key = g_object_new (GELEKTRA_TYPE_KEY, NULL);
      23           1 :         succeed_if (key != NULL, "unable to create key");
      24           1 :         succeed_if (!gelektra_key_isvalid (key), "key should be invalid");
      25           1 :         g_object_unref (key);
      26             : 
      27           1 :         key = gelektra_key_new ("wrongname", GELEKTRA_KEY_END);
      28           1 :         succeed_if (key != NULL, "unable to create key");
      29           1 :         succeed_if (!gelektra_key_isvalid (key), "key should be invalid");
      30           1 :         g_object_unref (key);
      31             : 
      32           1 :         Key * ckey = keyNew (NULL);
      33           1 :         key = gelektra_key_make (ckey);
      34           1 :         succeed_if (key->key == ckey, "new key not wrapped");
      35           1 :         g_object_unref (key);
      36             : 
      37           1 :         key = gelektra_key_new ("user/foo", GELEKTRA_KEY_END);
      38           1 :         succeed_if (key != NULL, "unable to create key");
      39           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      40           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      41           1 :         g_object_unref (key);
      42             : 
      43           1 :         key = gelektra_key_new ("/cascading", GELEKTRA_KEY_END);
      44           1 :         succeed_if (key != NULL, "unable to create key");
      45           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      46           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      47           1 :         g_object_unref (key);
      48             : 
      49           1 :         key = gelektra_key_new ("spec/key", GELEKTRA_KEY_END);
      50           1 :         succeed_if (key != NULL, "unable to create key");
      51           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      52           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      53           1 :         g_object_unref (key);
      54             : 
      55           1 :         key = gelektra_key_new ("proc/key", GELEKTRA_KEY_END);
      56           1 :         succeed_if (key != NULL, "unable to create key");
      57           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      58           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      59           1 :         g_object_unref (key);
      60             : 
      61           1 :         key = gelektra_key_new ("dir/key", GELEKTRA_KEY_END);
      62           1 :         succeed_if (key != NULL, "unable to create key");
      63           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      64           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      65           1 :         g_object_unref (key);
      66             : 
      67           1 :         key = gelektra_key_new ("user/key", GELEKTRA_KEY_END);
      68           1 :         succeed_if (key != NULL, "unable to create key");
      69           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      70           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      71           1 :         g_object_unref (key);
      72             : 
      73           1 :         key = gelektra_key_new ("system/key", GELEKTRA_KEY_END);
      74           1 :         succeed_if (key != NULL, "unable to create key");
      75           1 :         succeed_if (gelektra_key_isvalid (key), "key should be valid");
      76           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1");
      77           1 :         g_object_unref (key);
      78           1 : }
      79             : 
      80             : static GElektraKey * g_key = NULL;
      81             : static GElektraKey * g_bkey = NULL;
      82             : 
      83           1 : static void create_global_keys (void)
      84             : {
      85           1 :         g_key = gelektra_key_new ("user/key", GELEKTRA_KEY_VALUE, "value", GELEKTRA_KEY_OWNER, "myowner", GELEKTRA_KEY_COMMENT, "mycomment",
      86             :                                   GELEKTRA_KEY_UID, "123", GELEKTRA_KEY_GID, 456, GELEKTRA_KEY_MODE, 0644, GELEKTRA_KEY_ATIME, 123,
      87             :                                   GELEKTRA_KEY_MTIME, "456", GELEKTRA_KEY_CTIME, 789, GELEKTRA_KEY_DIR, GELEKTRA_KEY_META, "by", "manuel",
      88             :                                   GELEKTRA_KEY_END);
      89           1 :         succeed_if (g_key != NULL, "unable to create key");
      90           1 :         succeed_if (gelektra_key_isvalid (g_key), "key should be valid");
      91           1 :         succeed_if (gelektra_key_getref (g_key) == 1, "refcount should be 1");
      92             : 
      93           1 :         g_bkey = gelektra_key_new ("system/bkey", GELEKTRA_KEY_BINARY, GELEKTRA_KEY_VALUE, "bvalue\0\0", GELEKTRA_KEY_END);
      94           1 :         succeed_if (g_bkey != NULL, "unable to create key");
      95           1 :         succeed_if (gelektra_key_isvalid (g_bkey), "key should be valid");
      96           1 :         succeed_if (gelektra_key_getref (g_bkey) == 1, "refcount should be 1");
      97           1 : }
      98             : 
      99           1 : static void test_props (void)
     100             : {
     101             :         gchar *name, *basename, *fullname;
     102           1 :         g_object_get (g_key, "name", &name, "basename", &basename, "fullname", &fullname, NULL);
     103           1 :         succeed_if (!strcmp (name, "user/key"), "wrong value");
     104           1 :         succeed_if (!strcmp (basename, "key"), "wrong value");
     105           1 :         succeed_if (!strcmp (fullname, "user:myowner/key"), "wrong value");
     106           1 :         g_free (name);
     107           1 :         g_free (basename);
     108           1 :         g_free (fullname);
     109             : 
     110           1 :         GElektraKey * key = g_object_new (GELEKTRA_TYPE_KEY, NULL);
     111           1 :         gelektra_key_setname (key, "user/foo");
     112           1 :         gelektra_key_setbasename (key, "bar");
     113           1 :         g_object_get (key, "name", &name, NULL);
     114           1 :         succeed_if (!strcmp (name, "user/bar"), "wrong value");
     115           1 :         g_free (name);
     116           1 :         g_object_unref (key);
     117           1 : }
     118             : 
     119           1 : static void test_basic (void)
     120             : {
     121             :         GElektraKey * key;
     122             : 
     123           1 :         key = gelektra_key_dup (g_key);
     124           1 :         gelektra_key_incref (key);
     125           1 :         succeed_if (gelektra_key_getref (key) == 2, "refcount should be 2");
     126           1 :         succeed_if (gelektra_key_getref (g_key) == 1, "refcount should be still 1");
     127           1 :         gelektra_key_decref (key);
     128           1 :         succeed_if (gelektra_key_getref (key) == 1, "refcount should be 1 again");
     129           1 :         g_object_unref (key);
     130             : 
     131             :         gchar * name;
     132           1 :         key = gelektra_key_new ("user/bar", GELEKTRA_KEY_END);
     133           1 :         gelektra_key_copy (g_key, key);
     134           1 :         g_object_get (key, "name", &name, NULL);
     135           1 :         succeed_if (!strcmp (name, "user/key"), "wrong value");
     136           1 :         g_free (name);
     137             : 
     138           1 :         gelektra_key_clear (key);
     139           1 :         g_object_get (key, "name", &name, NULL);
     140           1 :         succeed_if (!strcmp (name, ""), "wrong value");
     141           1 :         g_free (name);
     142             : 
     143           1 :         g_object_unref (key);
     144           1 : }
     145             : 
     146           1 : static void test_operators (void)
     147             : {
     148           1 :         succeed_if (!gelektra_key_equal (g_key, g_bkey), "keys shouldn't be equal");
     149           1 :         succeed_if (gelektra_key_cmp (g_key, g_bkey) != 0, "keys shouldn't be equal");
     150             : 
     151           1 :         GElektraKey * key = gelektra_key_dup (g_key);
     152           1 :         succeed_if (gelektra_key_equal (g_key, key), "keys should be equal");
     153           1 :         succeed_if (gelektra_key_cmp (g_key, key) == 0, "keys should be equal");
     154           1 :         g_object_unref (key);
     155           1 : }
     156             : 
     157           1 : static void test_name_manipulation (void)
     158             : {
     159             :         // TODO gelektra_key_addbasename
     160           1 :         succeed_if (gelektra_key_getnamesize (g_key) == sizeof ("user/key"), "wrong size");
     161           1 :         succeed_if (gelektra_key_getbasenamesize (g_key) == sizeof ("key"), "wrong size");
     162           1 :         succeed_if (gelektra_key_getfullnamesize (g_key) == sizeof ("user:myowner/key"), "wrong size");
     163           1 : }
     164             : 
     165             : 
     166           1 : static void test_value_operations (void)
     167             : {
     168             :         gchar * data;
     169             :         void * bdata;
     170             :         gssize size;
     171             : 
     172             :         /* string value tests */
     173           1 :         size = gelektra_key_getvaluesize (g_key);
     174           1 :         succeed_if (size > 0, "wrong value size");
     175           1 :         data = g_malloc0 (size);
     176           1 :         gelektra_key_getstring (g_key, data, size);
     177           1 :         succeed_if (!strncmp (data, "value", size), "invalid key value");
     178           1 :         g_free (data);
     179             : 
     180           1 :         succeed_if (!memcmp (gelektra_key_getvalue (g_key), "value", sizeof ("value")), "invalid key value");
     181             : 
     182           1 :         gelektra_key_setstring (g_key, "value2");
     183             : 
     184           1 :         data = gelektra_key_gi_getstring (g_key);
     185           1 :         succeed_if (!strcmp (data, "value2"), "invalid key value");
     186           1 :         g_free (data);
     187             : 
     188             :         /* binary value tests */
     189           1 :         size = gelektra_key_getvaluesize (g_bkey);
     190           1 :         bdata = g_malloc0 (size);
     191           1 :         gelektra_key_getbinary (g_bkey, bdata, size);
     192           1 :         succeed_if (!memcmp (bdata, "bvalue\0\0", size), "invalid key value");
     193           1 :         g_free (bdata);
     194             : 
     195           1 :         succeed_if (!memcmp (gelektra_key_getvalue (g_bkey), "bvalue\0\0", size), "invalid key value");
     196             : 
     197           1 :         gelektra_key_setbinary (g_bkey, "bvalue2\0\0", sizeof ("bvalue2\0\0"));
     198             : 
     199           1 :         bdata = gelektra_key_gi_getbinary (g_bkey, &size);
     200           1 :         succeed_if (size == sizeof ("bvalue2\0\0"), "invalid key size");
     201           1 :         succeed_if (!memcmp (bdata, "bvalue2\0\0", size), "invalid key value");
     202           1 :         g_free (bdata);
     203           1 : }
     204             : 
     205           1 : static void test_meta_data (void)
     206             : {
     207             :         GElektraKey *meta, *key;
     208             : 
     209             :         /* get tests */
     210           1 :         succeed_if (gelektra_key_hasmeta (g_key, "by"), "no meta");
     211             : 
     212           1 :         meta = gelektra_key_getmeta (g_key, "by");
     213           1 :         succeed_if (gelektra_key_getref (meta) == 2, "refcount should be 2");
     214           1 :         succeed_if (!memcmp (gelektra_key_getvalue (meta), "manuel", sizeof ("manuel")), "invalid metavalue");
     215           1 :         g_object_unref (meta);
     216             : 
     217           1 :         guint metacnt = 0;
     218           1 :         gelektra_key_rewindmeta (g_key);
     219          11 :         while ((meta = gelektra_key_nextmeta (g_key)) != NULL)
     220             :         {
     221           9 :                 GElektraKey * curmeta = gelektra_key_currentmeta (g_key);
     222           9 :                 succeed_if (meta->key == curmeta->key, "meta iterators returned different keys");
     223           9 :                 g_object_unref (curmeta);
     224             : 
     225           9 :                 ++metacnt;
     226           9 :                 g_object_unref (meta);
     227             :         }
     228           1 :         succeed_if (metacnt == 9, "incorrect number of metadata");
     229             : 
     230           1 :         gelektra_key_setmeta (g_key, "by", "gelektra");
     231           1 :         meta = gelektra_key_getmeta (g_key, "by");
     232           1 :         succeed_if (!memcmp (gelektra_key_getvalue (meta), "gelektra", sizeof ("gelektra")), "invalid metavalue");
     233           1 :         g_object_unref (meta);
     234             : 
     235             :         /* set tests */
     236           1 :         key = g_object_new (GELEKTRA_TYPE_KEY, NULL);
     237             : 
     238           1 :         gelektra_key_copymeta (g_key, key, "by");
     239           1 :         meta = gelektra_key_getmeta (g_key, "by");
     240           1 :         succeed_if (!memcmp (gelektra_key_getvalue (meta), "gelektra", sizeof ("gelektra")), "invalid metavalue");
     241           1 :         g_object_unref (meta);
     242             : 
     243           1 :         gelektra_key_copyallmeta (g_key, key);
     244           1 :         meta = gelektra_key_getmeta (g_key, "owner");
     245           1 :         succeed_if (!memcmp (gelektra_key_getvalue (meta), "myowner", sizeof ("myowner")), "invalid metavalue");
     246           1 :         g_object_unref (meta);
     247             : 
     248           1 :         g_object_unref (key);
     249           1 : }
     250             : 
     251           1 : static void test_validating (void)
     252             : {
     253           1 :         succeed_if (!gelektra_key_isnull (g_key), "key is null");
     254           1 :         succeed_if (gelektra_key_isvalid (g_key), "key is not valid");
     255           1 :         succeed_if (gelektra_key_isuser (g_key), "key is not user");
     256           1 :         succeed_if (!gelektra_key_issystem (g_key), "key is system");
     257           1 :         succeed_if (gelektra_key_isstring (g_key), "key is not string");
     258           1 :         succeed_if (!gelektra_key_isbinary (g_key), "key is binary");
     259           1 :         succeed_if (!gelektra_key_isinactive (g_key), "key is inactive");
     260             : 
     261           1 :         succeed_if (!gelektra_key_isuser (g_bkey), "key is user");
     262           1 :         succeed_if (gelektra_key_issystem (g_bkey), "key is not system");
     263           1 :         succeed_if (!gelektra_key_isstring (g_bkey), "key is string");
     264           1 :         succeed_if (gelektra_key_isbinary (g_bkey), "key is not binary");
     265             : 
     266           1 :         GElektraKey * key = gelektra_key_new ("user/key/glib/edy", GELEKTRA_KEY_END);
     267           1 :         succeed_if (gelektra_key_isbelow (key, g_key), "key not below g_key");
     268           1 :         succeed_if (gelektra_key_isbeloworsame (key, g_key), "key not below g_key");
     269           1 :         succeed_if (gelektra_key_isbeloworsame (g_key, g_key), "key is not key :)");
     270           1 :         succeed_if (!gelektra_key_isdirectbelow (key, g_key), "key not direct below g_key");
     271           1 :         g_object_unref (key);
     272           1 : }
     273             : 
     274           1 : static void destroy_global_keys (void)
     275             : {
     276           1 :         g_object_unref (g_key);
     277           1 :         g_object_unref (g_bkey);
     278           1 : }
     279             : 
     280           1 : int main (int argc, char ** argv)
     281             : {
     282           1 :         printf ("KEY TESTS\n");
     283           1 :         printf ("===============\n\n");
     284             : 
     285           1 :         init (argc, argv);
     286             : 
     287           1 :         test_ctor ();
     288             : 
     289           1 :         create_global_keys ();
     290           1 :         test_props ();
     291           1 :         test_basic ();
     292           1 :         test_operators ();
     293           1 :         test_name_manipulation ();
     294           1 :         test_value_operations ();
     295           1 :         test_meta_data ();
     296           1 :         test_validating ();
     297           1 :         destroy_global_keys ();
     298             : 
     299           1 :         printf ("\n%s RESULTS: %d test(s) done. %d error(s).\n", argv[0], nbTest, nbError);
     300           1 :         return nbError;
     301             : }

Generated by: LCOV version 1.13