LCOV - code coverage report
Current view: top level - tests/abi - testabi_meta.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 338 339 99.7 %
Date: 2019-09-12 12:28:41 Functions: 11 11 100.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Test suite for meta information.
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <tests.h>
      10             : 
      11           2 : static void test_basic (void)
      12             : {
      13             :         Key * key;
      14           2 :         key = keyNew ("user/key_with_meta", KEY_END);
      15           2 :         exit_if_fail (key, "could not create new key");
      16           2 :         succeed_if (keyGetMeta (key, "hello") == 0, "hello was not set up to now");
      17           2 :         succeed_if (keyGetMeta (key, "error") == 0, "hello was not set up to now");
      18             : 
      19           2 :         keySetMeta (key, "hello", "hello_world");
      20           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "hello_world");
      21             : 
      22           2 :         keySetMeta (key, "mode", "0644");
      23           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "hello_world");
      24             : 
      25           2 :         keySetMeta (key, "time", "1271234264");
      26           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "hello_world");
      27           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0644");
      28           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271234264");
      29             : 
      30           2 :         keySetMeta (key, "hello", "between");
      31           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "between");
      32             : 
      33           2 :         keySetMeta (key, "hello", 0);
      34           2 :         succeed_if (keyValue (keyGetMeta (key, "hello")) == 0, "could not remove metadata");
      35             : 
      36           2 :         keySetMeta (key, "hello", "goodbye");
      37           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "goodbye"), "could not set meta information again (2x)");
      38             : 
      39           2 :         keySetMeta (key, "empty", "");
      40           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
      41             : 
      42           2 :         keySetMeta (key, "owner", "hugo");
      43           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "hugo");
      44             : 
      45           2 :         keySetMeta (key, "mode", "775");
      46           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "hugo");
      47           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "775");
      48             : 
      49           2 :         keySetMeta (key, "", "empty");
      50           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "empty");
      51             : 
      52           2 :         keySetMeta (key, "", "");
      53           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "");
      54             : 
      55           2 :         keySetMeta (key, "", 0);
      56           2 :         succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
      57             : 
      58             : 
      59           2 :         keyDel (key);
      60           2 : }
      61             : 
      62           2 : static void test_iterate (void)
      63             : {
      64             :         Key * key;
      65             : 
      66           2 :         key = keyNew ("user/test", KEY_END);
      67           2 :         exit_if_fail (key, "could not create new key");
      68           2 :         succeed_if (keyRewindMeta (key) == 0, "Could not rewind empty key");
      69           2 :         succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty");
      70           2 :         succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty");
      71             : 
      72           2 :         keySetMeta (key, "meta1", "meta_value");
      73           2 :         succeed_if (keyRewindMeta (key) == 0, "Could not rewind key");
      74           2 :         succeed_if_same_string (keyName (keyNextMeta (key)), "meta1");
      75           2 :         succeed_if_same_string (keyValue (keyCurrentMeta (key)), "meta_value");
      76             : 
      77           2 :         succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty at 2. iteration");
      78           2 :         succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty at 2. iteration");
      79             : 
      80           2 :         succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty at 3. iteration");
      81           2 :         succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty at 3. iteration");
      82             : 
      83           2 :         succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty at 4. iteration");
      84           2 :         succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty at 4. iteration");
      85             : 
      86           2 :         keyDel (key);
      87           2 : }
      88             : 
      89           2 : static void test_size (void)
      90             : {
      91             :         Key * key;
      92             :         char * buffer;
      93             : 
      94           2 :         key = keyNew ("user/test", KEY_END);
      95           2 :         exit_if_fail (key, "could not create new key");
      96           2 :         succeed_if (keyValue (keyGetMeta (key, "hello")) == 0, "hello was not set up to now");
      97           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == -1, "got wrong size for empty metavalue");
      98             : 
      99           2 :         keySetMeta (key, "hello", "hello_world");
     100           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "hello_world"), "could not receive previously set meta information");
     101           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == sizeof ("hello_world"), "got wrong size");
     102             : 
     103           2 :         keySetMeta (key, "mode", "0644");
     104           2 :         keySetMeta (key, "time", "1271234264");
     105           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "hello_world"), "meta info changed unexpectly");
     106           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0644");
     107           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "mode")) == sizeof ("0644"), "got wrong size");
     108           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271234264");
     109           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "time")) == sizeof ("1271234264"), "got wrong size");
     110             : 
     111           2 :         keySetMeta (key, "hello", "between");
     112           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "between"), "could not set meta information again");
     113           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == sizeof ("between"), "got wrong size");
     114           2 :         buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "hello")));
     115           2 :         succeed_if (keyGetString (keyGetMeta (key, "hello"), buffer, keyGetValueSize (keyGetMeta (key, "hello"))) ==
     116             :                             keyGetValueSize (keyGetMeta (key, "hello")),
     117             :                     "could not get meta");
     118           2 :         succeed_if_same_string (buffer, "between");
     119           2 :         elektraFree (buffer);
     120             : 
     121             : 
     122           2 :         keySetMeta (key, "hello", 0);
     123           2 :         succeed_if (keyValue (keyGetMeta (key, "hello")) == 0, "could not remove metadata");
     124           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == -1, "got wrong size");
     125             : 
     126           2 :         keySetMeta (key, "hello", "goodbye");
     127           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "goodbye"), "could not set meta information again (2x)");
     128           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == sizeof ("goodbye"), "got wrong size");
     129           2 :         buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "hello")));
     130           2 :         succeed_if (keyGetString (keyGetMeta (key, "hello"), buffer, keyGetValueSize (keyGetMeta (key, "hello"))) ==
     131             :                             keyGetValueSize (keyGetMeta (key, "hello")),
     132             :                     "could not get meta");
     133           2 :         succeed_if_same_string (buffer, "goodbye");
     134           2 :         elektraFree (buffer);
     135             : 
     136           2 :         keySetMeta (key, "empty", "");
     137           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
     138           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "empty")) == sizeof (""), "got wrong size");
     139           2 :         buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "empty")));
     140           2 :         succeed_if (keyGetString (keyGetMeta (key, "empty"), buffer, keyGetValueSize (keyGetMeta (key, "empty"))) ==
     141             :                             keyGetValueSize (keyGetMeta (key, "empty")),
     142             :                     "could not get meta");
     143           2 :         succeed_if_same_string (buffer, "");
     144           2 :         elektraFree (buffer);
     145             : 
     146           2 :         keySetMeta (key, "", "empty");
     147           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "empty");
     148           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "")) == sizeof ("empty"), "got wrong size");
     149           2 :         buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "")));
     150           2 :         succeed_if (keyGetString (keyGetMeta (key, ""), buffer, keyGetValueSize (keyGetMeta (key, ""))) ==
     151             :                             keyGetValueSize (keyGetMeta (key, "")),
     152             :                     "could not get meta");
     153           2 :         succeed_if_same_string (buffer, "empty");
     154           2 :         elektraFree (buffer);
     155             : 
     156           2 :         keySetMeta (key, "", "");
     157           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "");
     158           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "")) == sizeof (""), "got wrong size");
     159           2 :         buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "")));
     160           2 :         succeed_if (keyGetString (keyGetMeta (key, ""), buffer, keyGetValueSize (keyGetMeta (key, ""))) ==
     161             :                             keyGetValueSize (keyGetMeta (key, "")),
     162             :                     "could not get meta");
     163           2 :         succeed_if_same_string (buffer, "");
     164           2 :         elektraFree (buffer);
     165             : 
     166           2 :         keySetMeta (key, "", 0);
     167           2 :         succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
     168           2 :         succeed_if (keyGetValueSize (keyGetMeta (key, "")) == -1, "got wrong size");
     169             : 
     170             : 
     171           2 :         keyDel (key);
     172           2 : }
     173             : 
     174           2 : static void test_dup (void)
     175             : {
     176             :         Key * key;
     177             :         Key * dup;
     178             : 
     179           2 :         key = keyNew ("user/orig", KEY_END);
     180           2 :         succeed_if (keySetMeta (key, "test", "some_meta_test") == sizeof ("some_meta_test"), "could not set meta");
     181           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "test")), "some_meta_test");
     182             : 
     183           2 :         dup = keyDup (key);
     184           2 :         succeed_if_same_string (keyValue (keyGetMeta (dup, "test")), "some_meta_test");
     185           2 :         succeed_if (keySetMeta (dup, "test", "some_other_meta_test") == sizeof ("some_other_meta_test"), "sizeof meta test wrong");
     186           2 :         succeed_if_same_string (keyValue (keyGetMeta (dup, "test")), "some_other_meta_test");
     187           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "test")), "some_meta_test");
     188           2 :         keyDel (dup);
     189             : 
     190           2 :         keyDel (key);
     191           2 : }
     192             : 
     193             : Key * g_c;
     194             : 
     195           2 : static void j (Key * k)
     196             : {
     197           2 :         size_t size = keyGetValueSize (k);
     198           2 :         char * value = elektraMalloc (size);
     199           2 :         int bstring = keyIsString (k);
     200             : 
     201             :         // receive key g_c
     202           2 :         memcpy (value, keyValue (k), size);
     203           2 :         keyCopy (k, g_c);
     204           2 :         if (bstring)
     205           2 :                 keySetString (k, value);
     206             :         else
     207           0 :                 keySetBinary (k, value, size);
     208           2 :         elektraFree (value);
     209             :         // the caller will see the changed key k
     210             :         // with the metadata from g_c
     211           2 : }
     212             : 
     213             : static void l (Key * k)
     214             : {
     215             :         // receive g_c
     216           2 :         keyCopyMeta (k, g_c, "type");
     217             :         // the caller will see the changed key k
     218             :         // with the metadata "type" from g_c
     219             : }
     220             : 
     221           2 : static void test_examples (void)
     222             : {
     223             :         Key * key;
     224           2 :         key = keyNew (0);
     225           2 :         keySetMeta (key, "def", "abc");
     226           2 :         keySetMeta (key, "nop", "cup");
     227             : 
     228           2 :         g_c = keyNew (0);
     229           2 :         keySetMeta (g_c, "xef", "ybc");
     230           2 :         keySetMeta (g_c, "xop", "yup");
     231             : 
     232           2 :         j (key);
     233             : 
     234           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "xef")), "ybc");
     235           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "xop")), "yup");
     236           2 :         succeed_if (keyValue (keyGetMeta (key, "def")) == 0, "old metadata remained");
     237           2 :         succeed_if (keyValue (keyGetMeta (key, "nop")) == 0, "old metadata remained");
     238             : 
     239           2 :         keyDel (key);
     240           2 :         keyDel (g_c);
     241             : 
     242           2 :         key = keyNew (0);
     243           2 :         keySetMeta (key, "def", "abc");
     244           2 :         keySetMeta (key, "nop", "cup");
     245             : 
     246           2 :         g_c = keyNew (0);
     247           2 :         keySetMeta (g_c, "type", "boolean");
     248           2 :         keySetMeta (g_c, "xop", "yup");
     249             : 
     250           2 :         l (key);
     251             : 
     252           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "def")), "abc");
     253           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "nop")), "cup");
     254           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "type")), "boolean");
     255           2 :         succeed_if (keyValue (keyGetMeta (key, "xop")) == 0, "this metadata was not requested to be copied");
     256             : 
     257           2 :         keyDel (key);
     258           2 :         keyDel (g_c);
     259           2 : }
     260             : 
     261           2 : static void test_copy (void)
     262             : {
     263           2 :         printf ("Test key meta copy\n");
     264             : 
     265             :         Key * key1;
     266             :         Key * key2;
     267             : 
     268           2 :         succeed_if (key1 = keyNew (0), "could not create key");
     269           2 :         succeed_if (key2 = keyNew (0), "could not create key");
     270             : 
     271           2 :         succeed_if (keyCopyMeta (key2, key1, "nonexist") == 0, "could not do anything");
     272             : 
     273           2 :         succeed_if (keyValue (keyGetMeta (key2, "nonexist")) == 0, "should not be there");
     274             : 
     275           2 :         keyDel (key1);
     276           2 :         keyDel (key2);
     277             : 
     278             : 
     279           2 :         succeed_if (key1 = keyNew (0), "could not create key");
     280           2 :         succeed_if (key2 = keyNew (0), "could not create key");
     281             : 
     282           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
     283           2 :         succeed_if (keyCopyMeta (key2, key1, "mymeta") == 1, "could not copy metavalue");
     284           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     285           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     286           2 :         succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
     287             : 
     288           2 :         succeed_if (keyCopyMeta (key1, key2, "mymeta") == 1, "did nothing in the end");
     289           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     290           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     291           2 :         succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
     292             : 
     293           2 :         keyDel (key1);
     294           2 :         keyDel (key2);
     295             : 
     296             : 
     297           2 :         succeed_if (key1 = keyNew (0), "could not create key");
     298           2 :         succeed_if (key2 = keyNew (0), "could not create key");
     299             : 
     300           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
     301           2 :         succeed_if (keyCopyMeta (key2, key1, "mymeta") == 1, "could not copy metavalue");
     302           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     303           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     304           2 :         succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
     305             : 
     306           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
     307           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     308           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     309           2 :         succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key");
     310             : 
     311           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue2") == sizeof ("a longer metavalue2"), "could not set metavalue2");
     312           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue2");
     313           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     314           2 :         succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key (with another value)");
     315             : 
     316           2 :         keyDel (key1);
     317           2 :         keyDel (key2);
     318             : 
     319             :         Key * k;
     320             :         Key * c;
     321             : 
     322             :         // clang-format off
     323           2 :         k=keyNew ("user/metakey",
     324             :                 KEY_META, "t", "test1",
     325             :                 KEY_META, "a", "another",
     326             :                 KEY_META, "cya", "see the metadata later",
     327             :                 KEY_META, "mode", "0775",
     328             :                 KEY_END);
     329             :         // clang-format on
     330           2 :         c = keyNew ("user/metacopy", KEY_END);
     331             : 
     332           2 :         succeed_if (keyGetMeta (k, "t") != 0, "could not get metakey");
     333           2 :         succeed_if (keyGetMeta (k, "a") != 0, "could not get metakey");
     334             : 
     335           2 :         succeed_if (keyGetMeta (c, "t") == 0, "could get metakey not there");
     336           2 :         succeed_if (keyGetMeta (c, "a") == 0, "could get metakey not there");
     337             : 
     338           2 :         succeed_if (keyCopyMeta (c, k, "t") == 1, "could not copy metadata");
     339           2 :         succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
     340             : 
     341           2 :         succeed_if (keyCopyMeta (c, k, "a") == 1, "could not copy metadata");
     342           2 :         succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
     343             : 
     344           2 :         keyDel (k);
     345           2 :         keyDel (c);
     346             : 
     347             : 
     348             :         // clang-format off
     349           2 :         k=keyNew ("user/metakey",
     350             :                 KEY_META, "t", "test1",
     351             :                 KEY_META, "a", "another",
     352             :                 KEY_META, "cya", "see the metadata later",
     353             :                 KEY_META, "mode", "0775",
     354             :                 KEY_END);
     355           2 :         c=keyNew ("user/metacopy",
     356             :                 KEY_META, "t", "test1",
     357             :                 KEY_META, "a", "wrong",
     358             :                 KEY_META, "old", "will stay",
     359             :                 KEY_END);
     360             :         // clang-format on
     361             : 
     362           2 :         succeed_if (keyGetMeta (k, "t") != 0, "could not get metakey");
     363           2 :         succeed_if (keyGetMeta (k, "a") != 0, "could not get metakey");
     364             : 
     365           2 :         succeed_if (keyCopyMeta (c, k, "t") == 1, "could not copy metadata");
     366           2 :         succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
     367           2 :         succeed_if_same_string (keyValue (keyGetMeta (k, "t")), "test1");
     368           2 :         succeed_if_same_string (keyValue (keyGetMeta (c, "t")), "test1");
     369             : 
     370           2 :         succeed_if (keyCopyMeta (c, k, "a") == 1, "could not copy metadata");
     371           2 :         succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
     372           2 :         succeed_if_same_string (keyValue (keyGetMeta (k, "a")), "another");
     373           2 :         succeed_if_same_string (keyValue (keyGetMeta (c, "a")), "another");
     374             : 
     375           2 :         succeed_if_same_string (keyValue (keyGetMeta (c, "old")), "will stay");
     376           2 :         succeed_if (keyGetMeta (c, "cya") == 0, "metakey should not be there");
     377           2 :         succeed_if (keyGetMeta (c, "mode") == 0, "metakey should not be there");
     378             : 
     379           2 :         keyDel (k);
     380           2 :         keyDel (c);
     381           2 : }
     382             : 
     383           2 : static void test_new (void)
     384             : {
     385             :         Key * key;
     386             :         // clang-format off
     387           2 :         key = keyNew ("user/test",
     388             :                 KEY_META, "hello", "hello_world",
     389             :                 KEY_META, "mode", "0644",
     390             :                 KEY_META, "time", "1271234264",
     391             :                 KEY_META, "empty", "",
     392             :                 KEY_META, "", "empty",
     393             :                 KEY_END);
     394             :         // clang-format on
     395             : 
     396           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "hello_world"), "could not receive previously set meta information");
     397           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0644");
     398           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271234264");
     399           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
     400           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "empty");
     401             : 
     402           2 :         keySetMeta (key, "", "full");
     403           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "full");
     404             : 
     405           2 :         keySetMeta (key, "", 0);
     406           2 :         succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
     407             : 
     408           2 :         keyDel (key);
     409             : 
     410             :         // clang-format off
     411           2 :         key = keyNew ("user/test",
     412             :                 KEY_META, "hello", "goodbye",
     413             :                 KEY_META, "mode", "0775",
     414             :                 KEY_META, "time", "1271939923",
     415             :                 KEY_META, "empty", "",
     416             :                 KEY_META, "", "",
     417             :                 KEY_END);
     418             :         // clang-format on
     419             : 
     420           2 :         succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "goodbye"), "could not receive previously set meta information");
     421           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0775");
     422           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271939923");
     423           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
     424           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "");
     425             : 
     426           2 :         keySetMeta (key, "", "full");
     427           2 :         succeed_if_same_string (keyValue (keyGetMeta (key, "")), "full");
     428             : 
     429           2 :         keySetMeta (key, "", 0);
     430           2 :         succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
     431             : 
     432           2 :         keyDel (key);
     433           2 : }
     434             : 
     435             : 
     436           2 : static void test_copyall (void)
     437             : {
     438           2 :         printf ("Test key meta copy all\n");
     439             : 
     440             :         Key * key1;
     441             :         Key * key2;
     442             : 
     443           2 :         succeed_if (key1 = keyNew (0), "could not create key");
     444           2 :         succeed_if (key2 = keyNew (0), "could not create key");
     445             : 
     446           2 :         succeed_if (keyCopyAllMeta (key2, key1) == 0, "could not do anything");
     447             : 
     448           2 :         succeed_if (keyValue (keyGetMeta (key2, "nonexist")) == 0, "should not be there");
     449             : 
     450           2 :         keyDel (key1);
     451           2 :         keyDel (key2);
     452             : 
     453             : 
     454           2 :         succeed_if (key1 = keyNew (0), "could not create key");
     455           2 :         succeed_if (key2 = keyNew (0), "could not create key");
     456             : 
     457           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
     458           2 :         succeed_if (keyCopyAllMeta (key2, key1) == 1, "could not copy metavalue");
     459           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     460           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     461           2 :         succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
     462             : 
     463           2 :         succeed_if (keyCopyAllMeta (key1, key2) == 1, "did nothing in the end");
     464           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     465           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     466           2 :         succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
     467             : 
     468           2 :         keyDel (key1);
     469           2 :         keyDel (key2);
     470             : 
     471             : 
     472           2 :         succeed_if (key1 = keyNew (0), "could not create key");
     473           2 :         succeed_if (key2 = keyNew (0), "could not create key");
     474             : 
     475           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
     476           2 :         succeed_if (keyCopyAllMeta (key2, key1) == 1, "could not copy metavalue");
     477           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     478           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     479           2 :         succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
     480             : 
     481           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
     482           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
     483           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     484           2 :         succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key");
     485             : 
     486           2 :         succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue2") == sizeof ("a longer metavalue2"), "could not set metavalue2");
     487           2 :         succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue2");
     488           2 :         succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
     489           2 :         succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key (with another value)");
     490             : 
     491           2 :         keyDel (key1);
     492           2 :         keyDel (key2);
     493             : 
     494             :         Key * k;
     495             :         Key * c;
     496             : 
     497             :         // clang-format off
     498           2 :         k=keyNew ("user/metakey",
     499             :                 KEY_META, "t", "test1",
     500             :                 KEY_META, "a", "another",
     501             :                 KEY_META, "cya", "see the metadata later",
     502             :                 KEY_META, "mode", "0775",
     503             :                 KEY_END);
     504             :         // clang-format on
     505           2 :         c = keyNew ("user/metacopy", KEY_END);
     506             : 
     507           2 :         succeed_if (keyGetMeta (k, "t") != 0, "could not get metakey");
     508           2 :         succeed_if (keyGetMeta (k, "a") != 0, "could not get metakey");
     509             : 
     510           2 :         succeed_if (keyGetMeta (c, "t") == 0, "could get metakey not there");
     511           2 :         succeed_if (keyGetMeta (c, "a") == 0, "could get metakey not there");
     512             : 
     513           2 :         succeed_if (keyCopyAllMeta (c, k) == 1, "could not copy metadata");
     514           2 :         succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
     515           2 :         succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
     516           2 :         succeed_if (keyGetMeta (k, "cya") == keyGetMeta (c, "cya"), "not the same metadata after copy");
     517           2 :         succeed_if (keyGetMeta (k, "mode") == keyGetMeta (c, "mode"), "not the same metadata after copy");
     518           2 :         succeed_if (keyValue (keyGetMeta (k, "nonexist")) == 0, "should not be there");
     519           2 :         succeed_if (keyValue (keyGetMeta (c, "nonexist")) == 0, "should not be there");
     520             : 
     521           2 :         succeed_if (keyCopyAllMeta (c, k) == 1, "could not copy metadata (again)");
     522           2 :         succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
     523           2 :         succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
     524           2 :         succeed_if (keyGetMeta (k, "cya") == keyGetMeta (c, "cya"), "not the same metadata after copy");
     525           2 :         succeed_if (keyGetMeta (k, "mode") == keyGetMeta (c, "mode"), "not the same metadata after copy");
     526           2 :         succeed_if (keyValue (keyGetMeta (k, "nonexist")) == 0, "should not be there");
     527           2 :         succeed_if (keyValue (keyGetMeta (c, "nonexist")) == 0, "should not be there");
     528             : 
     529           2 :         keyDel (k);
     530           2 :         keyDel (c);
     531           2 : }
     532             : 
     533           2 : static void test_type (void)
     534             : {
     535             :         Key * key;
     536             : 
     537           2 :         succeed_if (key = keyNew (0), "could not create a new key");
     538           2 :         succeed_if (keyValue (keyGetMeta (key, "binary")) == 0, "wrong type after key creation");
     539           2 :         succeed_if (keySetString (key, "mystring") == sizeof ("mystring"), "could not set string");
     540           2 :         succeed_if (keyValue (keyGetMeta (key, "binary")) == 0, "wrong type after setting string");
     541           2 :         succeed_if (keySetBinary (key, "mystring", sizeof ("mystring")) == sizeof ("mystring"), "could not set binary");
     542           2 :         succeed_if (keyValue (keyGetMeta (key, "binary")) != 0, "wrong type after setting string");
     543             : 
     544           2 :         keyDel (key);
     545           2 : }
     546             : 
     547             : 
     548           2 : int main (int argc, char ** argv)
     549             : {
     550           2 :         printf ("KEY META ABI TESTS\n");
     551           2 :         printf ("==================\n\n");
     552             : 
     553           2 :         init (argc, argv);
     554           2 :         test_basic ();
     555           2 :         test_iterate ();
     556           2 :         test_size ();
     557           2 :         test_dup ();
     558           2 :         test_examples ();
     559           2 :         test_type ();
     560           2 :         test_copy ();
     561           2 :         test_new ();
     562           2 :         test_copyall ();
     563             : 
     564             : 
     565           2 :         printf ("\ntestabi_meta RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
     566             : 
     567           2 :         return nbError;
     568             : }

Generated by: LCOV version 1.13