LCOV - code coverage report
Current view: top level - tests/kdb - testkdb_simple.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 324 331 97.9 %
Date: 2019-09-12 12:28:41 Functions: 50 75 66.7 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for KDB
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include <keysetio.hpp>
      11             : 
      12             : #include <gtest/gtest-elektra.h>
      13             : 
      14             : 
      15          84 : class Simple : public ::testing::Test
      16             : {
      17             : protected:
      18             :         static const std::string testRoot;
      19             :         static const std::string configFile;
      20             : 
      21             :         testing::Namespaces namespaces;
      22             :         testing::MountpointPtr mp;
      23             : 
      24          84 :         Simple () : namespaces ()
      25             :         {
      26          42 :         }
      27             : 
      28          42 :         virtual void SetUp () override
      29             :         {
      30         210 :                 mp.reset (new testing::Mountpoint (testRoot, configFile));
      31          42 :         }
      32             : 
      33          42 :         virtual void TearDown () override
      34             :         {
      35          84 :                 mp.reset ();
      36          42 :         }
      37             : };
      38             : 
      39           6 : const std::string Simple::configFile = "kdbFile.dump";
      40           6 : const std::string Simple::testRoot = "/tests/kdb/";
      41             : 
      42          20 : TEST_F (Simple, GetNothing)
      43             : {
      44             :         using namespace kdb;
      45           4 :         KDB kdb;
      46           4 :         KeySet ks;
      47           2 :         kdb.get (ks, testRoot);
      48           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
      49             :         struct stat buf;
      50          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
      51             : }
      52             : 
      53          20 : TEST_F (Simple, SetNothing)
      54             : {
      55             :         using namespace kdb;
      56           4 :         KDB kdb;
      57           4 :         KeySet ks;
      58           2 :         kdb.get (ks, testRoot);
      59           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
      60           2 :         kdb.set (ks, testRoot);
      61           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
      62             :         struct stat buf;
      63          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
      64             : }
      65             : 
      66          20 : TEST_F (Simple, TryChangeAfterSet)
      67             : {
      68             :         using namespace kdb;
      69           4 :         KDB kdb;
      70           4 :         KeySet ks;
      71           6 :         std::string name = "system" + testRoot + "try_change";
      72           6 :         Key k (name, KEY_END);
      73           8 :         EXPECT_EQ (k.getName (), name);
      74           2 :         ks.append (k);
      75           6 :         EXPECT_THROW (k.setName ("user/x"), kdb::KeyInvalidName);
      76           8 :         EXPECT_EQ (k.getName (), name);
      77           2 :         kdb.get (ks, testRoot);
      78           8 :         ASSERT_EQ (ks.size (), 1) << "lost keys in get\n" << ks;
      79           2 :         kdb.set (ks, testRoot);
      80           6 :         EXPECT_THROW (k.setName ("user/x"), kdb::KeyInvalidName);
      81           8 :         EXPECT_EQ (k.getName (), name);
      82           8 :         ASSERT_EQ (ks.size (), 1) << "got no keys\n" << ks;
      83             :         struct stat buf;
      84          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), 0) << "did not find config file";
      85             : }
      86             : 
      87          20 : TEST_F (Simple, MetaInSet)
      88             : {
      89             :         using namespace kdb;
      90           4 :         KDB kdb;
      91           4 :         KeySet ks;
      92           6 :         Key parent (testRoot, KEY_END);
      93           2 :         kdb.get (ks, parent);
      94           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backend" << ks;
      95             : 
      96          10 :         ks.append (Key ("meta" + testRoot + "wrong_meta_key", KEY_META_NAME, KEY_END));
      97             : 
      98           8 :         ASSERT_EQ (ks.size (), 1) << "key not inserted:\n" << ks;
      99           2 :         kdb.set (ks, parent);
     100           2 :         printError (std::cout, parent, true, true);
     101           2 :         printWarnings (std::cout, parent, true, true);
     102           8 :         ASSERT_EQ (ks.size (), 1) << "got wrong keys:\n" << ks;
     103             :         struct stat buf;
     104          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
     105             : }
     106             : 
     107          20 : TEST_F (Simple, InvalidKeysInSet)
     108             : {
     109             :         using namespace kdb;
     110           4 :         KDB kdb;
     111           4 :         KeySet ks;
     112           6 :         Key parent (testRoot, KEY_END);
     113           2 :         kdb.get (ks, parent);
     114           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backend" << ks;
     115             : 
     116           8 :         ks.append (Key (testRoot + "wrong_cascading_key", KEY_END));
     117          10 :         ks.append (Key ("meta" + testRoot + "wrong_meta_key", KEY_META_NAME, KEY_END));
     118             : 
     119           8 :         ASSERT_EQ (ks.size (), 2) << "keys not inserted:\n" << ks;
     120           2 :         kdb.set (ks, parent);
     121           2 :         printError (std::cout, parent, true, true);
     122           2 :         printWarnings (std::cout, parent, true, true);
     123           8 :         ASSERT_EQ (ks.size (), 2) << "got wrong keys:\n" << ks;
     124             :         struct stat buf;
     125          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
     126             : }
     127             : 
     128           8 : kdb::KeySet getAll ()
     129             : {
     130             :         using namespace ckdb;
     131             :         return
     132             : #include <data_allns.c>
     133             : }
     134             : 
     135             : // TODO: replace with proper ContainerEq
     136           4 : void compareKeySet (kdb::KeySet ks1, kdb::KeySet ks2)
     137             : {
     138             :         using namespace kdb;
     139           4 :         KeySet::iterator i1 = ks1.begin ();
     140        8580 :         for (KeySet::iterator i2 = ks2.begin (); i2 != ks2.end (); ++i1, ++i2)
     141             :         {
     142       17136 :                 EXPECT_EQ (*i1, *i2);
     143             :         }
     144          12 :         EXPECT_EQ (i1, ks1.end ()) << "second iterator not at end";
     145           4 : }
     146             : 
     147          20 : TEST_F (Simple, EverythingInGetSet)
     148             : {
     149             :         using namespace kdb;
     150           4 :         KDB kdb;
     151           4 :         KeySet ks = getAll ();
     152           6 :         Key parent (testRoot, KEY_END);
     153           2 :         kdb.get (ks, parent);
     154           8 :         ASSERT_EQ (ks.size (), 714) << "did not keep" << ks;
     155             : 
     156           2 :         kdb.set (ks, parent);
     157           2 :         printError (std::cout, parent, true, true);
     158           2 :         printWarnings (std::cout, parent, true, true);
     159           8 :         ASSERT_EQ (ks.size (), 714) << "got wrong keys:\n" << ks;
     160             :         // KeySet cmp = getAll();
     161             :         // ASSERT_EQ(ks, cmp);
     162             :         // ASSERT_THAT(ks, ContainerEq(cmp));
     163           8 :         compareKeySet (ks, getAll ());
     164             :         struct stat buf;
     165          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
     166             : }
     167             : 
     168          20 : TEST_F (Simple, EverythingInSet)
     169             : {
     170             :         using namespace kdb;
     171           4 :         KDB kdb;
     172           4 :         KeySet ks;
     173           6 :         Key parent (testRoot, KEY_END);
     174           2 :         kdb.get (ks, parent);
     175           8 :         ASSERT_EQ (ks.size (), 0) << "got from freshly mounted" << ks;
     176           6 :         ks.append (getAll ());
     177           8 :         ASSERT_EQ (ks.size (), 714) << "did not keep" << ks;
     178             : 
     179           2 :         kdb.set (ks, parent);
     180           2 :         printError (std::cout, parent, true, true);
     181           2 :         printWarnings (std::cout, parent, true, true);
     182           8 :         ASSERT_EQ (ks.size (), 714) << "got wrong keys:\n" << ks;
     183             :         // KeySet cmp = getAll();
     184             :         // ASSERT_EQ(ks, cmp);
     185             :         // ASSERT_THAT(ks, ContainerEq(cmp));
     186           8 :         compareKeySet (ks, getAll ());
     187             :         struct stat buf;
     188          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
     189             : }
     190             : 
     191             : 
     192          20 : TEST_F (Simple, RemoveFile)
     193             : {
     194             :         using namespace kdb;
     195           4 :         KDB kdb;
     196           4 :         KeySet ks;
     197           2 :         kdb.get (ks, testRoot);
     198          10 :         ks.append (Key ("system" + testRoot + "remove", KEY_END));
     199           8 :         ASSERT_EQ (ks.size (), 1) << "could not append key\n" << ks;
     200           2 :         kdb.set (ks, testRoot);
     201           8 :         ASSERT_EQ (ks.size (), 1) << "key gone after kdb.set?\n" << ks;
     202             : 
     203             :         struct stat buf;
     204          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), 0) << "found no file";
     205             : 
     206           4 :         Key parentKey;
     207           2 :         kdb.close (parentKey);
     208           2 :         kdb.open (parentKey);
     209             : 
     210           2 :         kdb.get (ks, testRoot);
     211           2 :         ks.clear ();
     212           8 :         ASSERT_EQ (ks.size (), 0) << "keyset should be empty after clearing it\n" << ks;
     213           2 :         kdb.set (ks, testRoot);
     214             : 
     215          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
     216             : }
     217             : 
     218             : 
     219          14 : TEST_F (Simple, DISABLED_GetNothingEmpty)
     220             : {
     221             :         using namespace kdb;
     222           0 :         KDB kdb;
     223           0 :         KeySet ks;
     224           0 :         Key k;
     225             :         try
     226             :         {
     227           0 :                 ASSERT_EQ (kdb.get (ks, k), 1);
     228             :         }
     229           0 :         catch (std::exception const & e)
     230             :         {
     231           0 :                 std::cout << "Could not get everything from keydatabase: " << e.what () << std::endl;
     232             :         }
     233           0 :         ASSERT_EQ (k.getMeta<int> ("warnings/#00/number"), 105) << "did not get warning for empty key";
     234             :         // got everything, so make no assumption of size
     235             : }
     236             : 
     237          20 : TEST_F (Simple, GetSystem)
     238             : {
     239             :         using namespace kdb;
     240           4 :         KDB kdb;
     241           4 :         KeySet ks;
     242           6 :         Key parentKey ("system" + testRoot, KEY_END);
     243          10 :         ks.append (Key (parentKey.getName () + "/key", KEY_END));
     244           4 :         EXPECT_NE (kdb.get (ks, parentKey), -1);
     245           8 :         ASSERT_EQ (ks.size (), 1) << "no key stayed" << ks;
     246           2 :         ks.rewind ();
     247           4 :         ks.next ();
     248          10 :         EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     249          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     250             : 
     251           4 :         ASSERT_NE (kdb.set (ks, parentKey), -1);
     252           2 :         ks.rewind ();
     253           4 :         ks.next ();
     254          10 :         EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     255          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     256           2 :         kdb.close (parentKey);
     257             : 
     258           4 :         KeySet ks2;
     259           2 :         kdb.open (parentKey);
     260           2 :         kdb.get (ks2, parentKey);
     261           2 :         ks.rewind ();
     262           4 :         ks.next ();
     263          10 :         EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     264          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     265             : }
     266             : 
     267          20 : TEST_F (Simple, WrongStateSystem)
     268             : {
     269             :         using namespace kdb;
     270           4 :         KDB kdb;
     271           4 :         KeySet ks;
     272           6 :         Key parentKey ("system" + testRoot, KEY_END);
     273           4 :         EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
     274           2 :         kdb.close (parentKey);
     275           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
     276             : }
     277             : 
     278             : 
     279          20 : TEST_F (Simple, WrongStateUser)
     280             : {
     281             :         using namespace kdb;
     282           4 :         KDB kdb;
     283           4 :         KeySet ks;
     284           6 :         Key parentKey ("user" + testRoot, KEY_END);
     285           4 :         EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
     286           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
     287             : }
     288             : 
     289             : 
     290          20 : TEST_F (Simple, WrongStateCascading)
     291             : {
     292             :         using namespace kdb;
     293           4 :         KDB kdb;
     294           4 :         KeySet ks;
     295           6 :         Key parentKey (testRoot, KEY_END);
     296           4 :         EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
     297           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
     298             : }
     299             : 
     300          20 : TEST_F (Simple, GetCascading)
     301             : {
     302             :         using namespace kdb;
     303           4 :         KDB kdb;
     304           4 :         KeySet ks;
     305           6 :         Key parentKey (testRoot, KEY_END);
     306           2 :         kdb.get (ks, parentKey);
     307           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
     308             : 
     309           6 :         Key setParentKey ("system" + testRoot, KEY_END);
     310           2 :         kdb.set (ks, setParentKey);
     311           2 :         kdb.close (parentKey);
     312             : }
     313             : 
     314             : 
     315          20 : TEST_F (Simple, GetAppendCascading)
     316             : {
     317             :         using namespace kdb;
     318           4 :         KDB kdb;
     319           4 :         KeySet ks;
     320           8 :         ks.append (Key (testRoot + "key", KEY_END));
     321           6 :         Key parentKey (testRoot, KEY_END);
     322           4 :         std::string myRoot = testRoot.substr (0, testRoot.length () - 1);
     323           8 :         EXPECT_EQ (parentKey.getName (), myRoot);
     324           8 :         EXPECT_EQ (parentKey.getString (), "");
     325           2 :         kdb.get (ks, parentKey);
     326           8 :         EXPECT_EQ (parentKey.getName (), myRoot);
     327           4 :         std::string fn = parentKey.getString ();
     328           8 :         EXPECT_EQ (fn.substr (fn.find_last_of ('/') + 1), "kdbFile.dump");
     329          10 :         parentKey.setString ("");
     330             : 
     331           8 :         ASSERT_EQ (ks.size (), 1) << "no key stayed" << ks;
     332           2 :         ks.rewind ();
     333           4 :         ks.next ();
     334          10 :         EXPECT_EQ (ks.current ().getName (), "/tests/kdb/key") << "name of element in keyset wrong";
     335          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     336           2 :         kdb.set (ks, parentKey);
     337           8 :         EXPECT_EQ (parentKey.getName (), myRoot);
     338           8 :         EXPECT_EQ (parentKey.getString (), "");
     339           2 :         ks.rewind ();
     340           4 :         ks.next ();
     341          10 :         EXPECT_EQ (ks.current ().getName (), "/tests/kdb/key") << "name of element in keyset wrong";
     342          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     343           2 :         kdb.close (parentKey);
     344           8 :         EXPECT_EQ (parentKey.getName (), myRoot);
     345           8 :         EXPECT_EQ (parentKey.getString (), "");
     346             : 
     347           4 :         KeySet ks2;
     348           2 :         kdb.open (parentKey);
     349           8 :         EXPECT_EQ (parentKey.getName (), myRoot);
     350           8 :         EXPECT_EQ (parentKey.getString (), "");
     351           2 :         kdb.get (ks2, parentKey);
     352           8 :         EXPECT_EQ (parentKey.getName (), myRoot);
     353           4 :         fn = parentKey.getString ();
     354           8 :         EXPECT_EQ (fn.substr (fn.find_last_of ('/') + 1), "kdbFile.dump");
     355           8 :         ASSERT_EQ (ks2.size (), 0) << "got keys from freshly mounted backends";
     356             : }
     357             : 
     358          20 : TEST_F (Simple, GetAppendMeta)
     359             : {
     360             :         using namespace kdb;
     361           4 :         KDB kdb;
     362           4 :         KeySet ks;
     363           6 :         ks.append (Key ("meta/key", KEY_META_NAME, KEY_END));
     364           6 :         Key parentKey (testRoot, KEY_END);
     365           2 :         kdb.get (ks, parentKey);
     366           8 :         ASSERT_EQ (ks.size (), 1) << "no key stayed";
     367           2 :         ks.rewind ();
     368           4 :         ks.next ();
     369          10 :         EXPECT_EQ (ks.current ().getName (), "meta/key") << "name of element in keyset wrong";
     370          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     371           2 :         kdb.set (ks, parentKey);
     372           2 :         ks.rewind ();
     373           4 :         ks.next ();
     374          10 :         EXPECT_EQ (ks.current ().getName (), "meta/key") << "name of element in keyset wrong";
     375          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     376           2 :         kdb.close (parentKey);
     377             : 
     378           4 :         KeySet ks2;
     379           2 :         kdb.open (parentKey);
     380           2 :         kdb.get (ks2, parentKey);
     381           8 :         ASSERT_EQ (ks2.size (), 0) << "got keys from freshly mounted backends";
     382             : }
     383             : 
     384          20 : TEST_F (Simple, GetAppendNamespaces)
     385             : {
     386             :         using namespace kdb;
     387          16 :         for (size_t i = 0; i < namespaces.size (); ++i)
     388             :         {
     389          12 :                 KDB kdb;
     390          12 :                 KeySet ks;
     391          36 :                 ks.append (Key (namespaces[i].name + testRoot + "key", KEY_END));
     392           6 :                 kdb.get (ks, testRoot);
     393          24 :                 ASSERT_EQ (ks.size (), 1) << "did not got key appended first with namespace " << namespaces[i].name;
     394           6 :                 ks.rewind ();
     395          12 :                 ks.next ();
     396          48 :                 EXPECT_EQ (ks.current ().getName (), namespaces[i].name + "/tests/kdb/key") << "name of element in keyset wrong";
     397          30 :                 EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     398             :         }
     399             : }
     400             : 
     401          20 : TEST_F (Simple, SetSystemKey)
     402             : {
     403             :         using namespace kdb;
     404           4 :         KDB kdb;
     405           4 :         KeySet ks;
     406           6 :         Key parentKey (testRoot, KEY_END);
     407          10 :         ks.append (Key ("system" + testRoot + "key", KEY_END));
     408           2 :         kdb.get (ks, parentKey);
     409           8 :         ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
     410           2 :         ks.rewind ();
     411           4 :         ks.next ();
     412          16 :         EXPECT_EQ (ks.current ().getName (), "system" + testRoot + "key") << "name of element in keyset wrong";
     413          10 :         EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
     414           2 :         kdb.set (ks, parentKey);
     415           2 :         kdb.close (parentKey);
     416             : 
     417           4 :         KeySet ks2;
     418           2 :         kdb.open (parentKey);
     419           2 :         kdb.get (ks2, parentKey);
     420           8 :         ASSERT_EQ (ks2.size (), 1) << "wrong size";
     421           2 :         ks2.rewind ();
     422           4 :         ks2.next ();
     423          16 :         EXPECT_EQ (ks2.current ().getName (), "system" + testRoot + "key") << "name of element in keyset wrong";
     424          10 :         EXPECT_EQ (ks2.current ().getString (), "") << "string of element in keyset wrong";
     425             : }
     426             : 
     427          20 : TEST_F (Simple, SetSystemGetAppend)
     428             : {
     429             :         using namespace kdb;
     430           4 :         KDB kdb;
     431           4 :         KeySet ks;
     432           6 :         Key parentKey (testRoot, KEY_END);
     433          10 :         ks.append (Key ("system" + testRoot + "key", KEY_VALUE, "value1", KEY_END));
     434           4 :         ASSERT_NE (kdb.get (ks, parentKey), -1);
     435           8 :         ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
     436           2 :         ks.rewind ();
     437           4 :         ks.next ();
     438          10 :         EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     439          10 :         EXPECT_EQ (ks.current ().getString (), "value1") << "string of element in keyset wrong";
     440           6 :         ASSERT_EQ (kdb.set (ks, parentKey), 1);
     441           2 :         kdb.close (parentKey);
     442             : 
     443           4 :         KeySet ks2;
     444          10 :         ks2.append (Key ("system" + testRoot + "key", KEY_VALUE, "value2", KEY_END));
     445           2 :         kdb.open (parentKey);
     446           6 :         ASSERT_EQ (kdb.get (ks2, parentKey), 1);
     447           8 :         ASSERT_EQ (ks2.size (), 1) << "wrong size";
     448           2 :         ks2.rewind ();
     449           4 :         ks2.next ();
     450          10 :         EXPECT_EQ (ks2.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     451          10 :         EXPECT_EQ (ks2.current ().getString (), "value1") << "string of element in keyset wrong";
     452             : }
     453             : 
     454          20 : TEST_F (Simple, SetSystemGetAppend2)
     455             : {
     456             :         using namespace kdb;
     457           4 :         KDB kdb;
     458           4 :         KeySet ks;
     459           6 :         Key parentKey (testRoot, KEY_END);
     460          10 :         ks.append (Key ("system" + testRoot + "key", KEY_VALUE, "value1", KEY_END));
     461           2 :         kdb.get (ks, parentKey);
     462           8 :         ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
     463           2 :         ks.rewind ();
     464           4 :         ks.next ();
     465          10 :         EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     466          10 :         EXPECT_EQ (ks.current ().getString (), "value1") << "string of element in keyset wrong";
     467           2 :         kdb.set (ks, parentKey);
     468           2 :         kdb.close (parentKey);
     469             : 
     470           4 :         KeySet ks2;
     471          10 :         ks2.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
     472           2 :         kdb.open (parentKey);
     473           2 :         kdb.get (ks2, parentKey);
     474           2 :         ks2.rewind ();
     475           4 :         ks2.next ();
     476           8 :         ASSERT_EQ (ks2.size (), 1) << "wrong size";
     477          10 :         EXPECT_EQ (ks2.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
     478          10 :         EXPECT_EQ (ks2.current ().getString (), "value1") << "string of element in keyset wrong";
     479             : }
     480             : 
     481          20 : TEST_F (Simple, WrongParent)
     482             : {
     483             :         using namespace kdb;
     484           4 :         KDB kdb;
     485           4 :         Key parent ("meta", KEY_META_NAME, KEY_END);
     486           4 :         KeySet ks;
     487           4 :         EXPECT_THROW (kdb.set (ks, parent), kdb::KDBException);
     488           8 :         ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
     489             : }
     490             : 
     491          20 : TEST_F (Simple, TriggerError)
     492             : {
     493             :         using namespace kdb;
     494           4 :         KDB kdb;
     495           4 :         KeySet ks;
     496           6 :         EXPECT_EQ (kdb.get (ks, testRoot), 0) << "nothing to do in get";
     497          10 :         ks.append (Key ("system" + testRoot + "a", KEY_END));
     498          10 :         ks.append (Key ("system" + testRoot + "k", KEY_META, "trigger/error", "10", KEY_END));
     499          10 :         ks.append (Key ("system" + testRoot + "z", KEY_END));
     500             :         struct stat buf;
     501          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
     502           4 :         EXPECT_THROW (kdb.set (ks, testRoot), kdb::KDBException) << "could not trigger error";
     503           8 :         ASSERT_EQ (ks.size (), 3) << "key suddenly missing";
     504          16 :         EXPECT_EQ (ks.current ().getName (), "system" + testRoot + "k") << "ks should point to error key";
     505          12 :         ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "created file even though error triggered";
     506           6 : }

Generated by: LCOV version 1.13