LCOV - code coverage report
Current view: top level - src/bindings/cpp/tests - testcpp_key.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 507 511 99.2 %
Date: 2019-09-12 12:28:41 Functions: 37 72 51.4 %

          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 <tests.hpp>
      10             : 
      11             : #include <memory>
      12             : #include <stdexcept>
      13             : #include <string>
      14             : #include <vector>
      15             : 
      16          20 : TEST (key, null)
      17             : {
      18           4 :         Key key0 (static_cast<ckdb::Key *> (nullptr));
      19           6 :         succeed_if (!key0, "key should evaluate to false");
      20           6 :         succeed_if (key0.isNull (), "key should evaluate to false");
      21           6 :         succeed_if (key0.needSync (), "key should need sync");
      22             : 
      23           2 :         key0 = static_cast<ckdb::Key *> (nullptr);
      24           6 :         succeed_if (!key0, "key should evaluate to false");
      25           6 :         succeed_if (key0.isNull (), "key should evaluate to false");
      26           6 :         succeed_if (key0.needSync (), "key should need sync");
      27             : 
      28           2 :         key0.release ();
      29           6 :         succeed_if (!key0, "key should evaluate to false");
      30           6 :         succeed_if (key0.isNull (), "key should evaluate to false");
      31           6 :         succeed_if (key0.needSync (), "key should need sync");
      32             : }
      33             : 
      34             : 
      35          20 : TEST (key, typebool)
      36             : {
      37           4 :         Key k ("user/key", KEY_VALUE, "testkey", KEY_END);
      38           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      39          10 :         k.setString ("O");
      40           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      41          10 :         k.setString ("0a");
      42           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      43          10 :         k.setString ("true");
      44           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      45          10 :         k.setString ("false");
      46           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      47          10 :         k.setString ("f");
      48           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      49          10 :         k.setString ("t");
      50           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      51          10 :         k.setString ("ON");
      52           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      53          10 :         k.setString ("OFF");
      54           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      55          10 :         k.setString ("on");
      56           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      57          10 :         k.setString ("off");
      58           4 :         EXPECT_THROW (k.get<bool> (), KeyTypeConversion);
      59             : 
      60          10 :         k.setString ("0");
      61           6 :         ASSERT_TRUE (!k.get<bool> ());
      62          10 :         k.setString ("1");
      63           6 :         ASSERT_TRUE (k.get<bool> ());
      64             : }
      65             : 
      66             : 
      67          20 : TEST (key, keynew)
      68             : {
      69           2 :         char array[] = "here is some data stored";
      70             : 
      71           4 :         Key key0;
      72           4 :         succeed_if (key0, "key should evaluate to true");
      73          10 :         succeed_if (key0.getName () == "", "key0 has wrong name");
      74             : 
      75             :         // Empty key
      76           4 :         Key key1 ("", KEY_END);
      77           4 :         succeed_if (key1, "key should evaluate to true");
      78          10 :         succeed_if (key1.getName () == "", "key0 has wrong name");
      79             : 
      80             :         // Key with name
      81           4 :         Key key2 ("system/sw/test", KEY_END);
      82          10 :         succeed_if (key2.getBaseName () == "test", "wrong base name");
      83          10 :         succeed_if (key2.getName () == "system/sw/test", "key2 has wrong name");
      84             :         // succeed_if (key2.getDirName() == "system/sw", "wrong dir name");
      85           2 :         key2.copy (key0);
      86          10 :         succeed_if (key2.getName () == "", "key0 has wrong name");
      87          10 :         succeed_if (key2.getBaseName () == "", "wrong base name");
      88             :         // succeed_if (key2.getDirName() == "", "wrong dir name");
      89             : 
      90             : 
      91             :         // Key with name
      92           4 :         Key key3 ("system/sw/test", KEY_END);
      93          10 :         succeed_if (key3.getName () == "system/sw/test", "key3 has wrong name");
      94          10 :         succeed_if (key3.getBaseName () == "test", "wrong base name");
      95             :         // succeed_if (key3.getDirName() == "system/sw", "wrong dir name");
      96           8 :         key3.setName ("system/other/name");
      97          10 :         succeed_if (key3.getName () == "system/other/name", "key3 has wrong name");
      98          10 :         succeed_if (key3.getBaseName () == "name", "wrong base name");
      99             :         // succeed_if (key3.getDirName() == "system/other", "wrong dir name");
     100           8 :         key3.addBaseName ("base");
     101          10 :         succeed_if (key3.getName () == "system/other/name/base", "key3 has wrong name");
     102          10 :         succeed_if (key3.getBaseName () == "base", "wrong base name");
     103             :         // succeed_if (key3.getDirName() == "system/other/name", "wrong dir name");
     104           8 :         key3.setBaseName ("name");
     105          10 :         succeed_if (key3.getName () == "system/other/name/name", "key3 has wrong name");
     106          10 :         succeed_if (key3.getBaseName () == "name", "wrong base name");
     107             :         // succeed_if (key3.getDirName() == "system/other/name", "wrong dir name");
     108           8 :         key3.setName ("system/name");
     109          10 :         succeed_if (key3.getName () == "system/name", "key3 has wrong name");
     110          10 :         succeed_if (key3.getBaseName () == "name", "wrong base name");
     111             :         // succeed_if (key3.getDirName() == "system", "wrong dir name");
     112             : 
     113             :         // Key with slash in name name
     114           8 :         key3.setName ("system/name\\/slash");
     115          10 :         succeed_if (key3.getName () == "system/name\\/slash", "key3 has wrong name");
     116          10 :         succeed_if (key3.getBaseName () == "name/slash", "wrong base name");
     117             :         // succeed_if (key3.getDirName() == "system", "wrong dir name");
     118             : 
     119           8 :         key3.setName ("system/name/with\\/slash");
     120          10 :         succeed_if (key3.getName () == "system/name/with\\/slash", "key3 has wrong name");
     121          10 :         succeed_if (key3.getBaseName () == "with/slash", "wrong base name");
     122             :         // succeed_if (key3.getDirName() == "system/name", "wrong dir name");
     123             : 
     124           8 :         key3.setName ("system/name");
     125           8 :         key3.addName ("some\\/more");
     126          10 :         succeed_if (key3.getName () == "system/name/some\\/more", "key3 has wrong name");
     127          10 :         succeed_if (key3.getBaseName () == "some/more", "wrong base name");
     128             :         // succeed_if (key3.getDirName() == "system/name", "wrong dir name");
     129             : 
     130           8 :         key3.setName ("/name");
     131          10 :         succeed_if (key3.getName () == "/name", "key3 has wrong name");
     132             :         // succeed_if(key3.getBaseName() == "name", "wrong base name");
     133             : 
     134           8 :         key3.setName ("/name");
     135           8 :         key3.addName ("some\\/more");
     136          10 :         succeed_if (key3.getName () == "/name/some\\/more", "key3 has wrong name");
     137          10 :         succeed_if (key3.getBaseName () == "some/more", "wrong base name");
     138             :         // succeed_if (key3.getDirName() == "/name", "wrong dir name");
     139             : 
     140             :         // Key with name + value
     141           4 :         Key key4 ("system/sw/test", KEY_VALUE, "test", KEY_END);
     142          10 :         succeed_if (key4.getName () == "system/sw/test", "key4 has wrong name");
     143          10 :         succeed_if (key4.getString () == "test", "key4 has wrong value");
     144          10 :         succeed_if (key4.get<string> () == "test", "key4 has wrong value");
     145           6 :         succeed_if (key4.getStringSize () == 5, "key4 has wrong value size");
     146          10 :         key4.setString ("test");
     147          10 :         succeed_if (key4.getString () == "test", "key4 has wrong value");
     148          10 :         succeed_if (key4.get<string> () == "test", "key4 has wrong value");
     149           6 :         succeed_if (key4.getStringSize () == 5, "key4 has wrong value size");
     150             :         try
     151             :         {
     152           2 :                 key4.getBinary ();
     153           0 :                 succeed_if (false, "string key did not throw after getting binary");
     154             :         }
     155           4 :         catch (KeyTypeMismatch const & ktm)
     156             :         {
     157           6 :                 succeed_if (true, "string key did not throw after getting binary");
     158             :         }
     159             : 
     160             :         try
     161             :         {
     162           2 :                 key4.get<int> ();
     163           0 :                 succeed_if (false, "string key did not throw after int");
     164             :         }
     165           4 :         catch (KeyTypeConversion const & ktm)
     166             :         {
     167           6 :                 succeed_if (true, "string key did not throw after getting binary");
     168             :         }
     169             : 
     170          10 :         key4.setString ("1.1");
     171             :         try
     172             :         {
     173           2 :                 key4.get<int> ();
     174           0 :                 succeed_if (false, "string key did not throw after ip");
     175             :         }
     176           4 :         catch (KeyTypeConversion const & ktm)
     177             :         {
     178           6 :                 succeed_if (true, "string key did not throw after getting ip");
     179             :         }
     180             : 
     181          10 :         key4.setString ("");
     182          10 :         succeed_if (key4.getString () == "", "key4 has wrong value");
     183           6 :         succeed_if (key4.isString (), "key4 is not string");
     184           6 :         succeed_if (!key4.isBinary (), "key4 is not string");
     185          10 :         succeed_if (key4.get<string> () == "", "key4 has wrong value");
     186           6 :         succeed_if (key4.getStringSize () == 1, "key4 has wrong value size");
     187           2 :         key4.setBinary ("abc", 3);
     188           6 :         succeed_if (key4.isBinary (), "key4 is not string");
     189           6 :         succeed_if (!key4.isString (), "key4 is not string");
     190             :         try
     191             :         {
     192           2 :                 key4.getString ();
     193           0 :                 succeed_if (false, "binary key did not throw after getting string");
     194             :         }
     195           4 :         catch (KeyTypeMismatch const & ktm)
     196             :         {
     197           6 :                 succeed_if (true, "binary key did not throw after getting string");
     198             :         }
     199           8 :         std::string s ("abc");
     200           2 :         s.resize (3);
     201           8 :         succeed_if (key4.getBinary () == s, "key4 has wrong binary value");
     202           6 :         succeed_if (key4.getBinarySize () == 3, "key4 has wrong value size");
     203           2 :         s[1] = 0;
     204           2 :         key4.setBinary ("a\0c", 3);
     205           8 :         succeed_if (key4.getBinary () == s, "key4 has wrong binary value");
     206           6 :         succeed_if (key4.getBinarySize () == 3, "key4 has wrong value size");
     207             : 
     208             : #ifndef _WIN32
     209             :         // Key with name + UID/GID
     210           4 :         Key key5 ("system/sw/test", KEY_UID, 123, KEY_GID, 456, KEY_END);
     211          12 :         succeed_if (key5.getMeta<uid_t> ("uid") == 123, "key5 UID no set correctly");
     212          12 :         succeed_if (key5.getMeta<gid_t> ("gid") == 456, "key5 UID no set correctly");
     213          10 :         succeed_if (key5.getName () == "system/sw/test", "key5 has wrong name");
     214             : 
     215             :         // Key with name + MODE
     216           4 :         Key key6 ("system/sw/test", KEY_MODE, 0642, KEY_END);
     217          12 :         succeed_if (key6.getMeta<mode_t> ("mode") == 642, "key6 mode no set correctly");
     218          10 :         succeed_if (key6.getName () == "system/sw/test", "key6 has wrong name");
     219          10 :         key6.setString ("a very long string");
     220          10 :         succeed_if (key6.getString () == "a very long string", "key6 has wrong value");
     221          10 :         succeed_if (key6.get<string> () == "a very long string", "key6 has wrong value");
     222             : #endif
     223             : 
     224             :         // Key with name + owner
     225           4 :         Key key7 ("system/sw/test", KEY_OWNER, "yl", KEY_END);
     226          16 :         succeed_if (key7.getMeta<std::string> ("owner") == "yl", "key7 owner not set correctly");
     227           6 :         succeed_if (!key7.isInactive (), "key should not be inactive");
     228             : 
     229           4 :         Key key8 ("system/valid/there", KEY_BINARY, KEY_SIZE, sizeof (array), KEY_VALUE, array, KEY_END);
     230          10 :         succeed_if (key8.getName () == "system/valid/there", "key8 has wrong name");
     231           6 :         succeed_if (key8.isBinary (), "Key should be binary");
     232           6 :         succeed_if (!key8.isString (), "Key should be binary");
     233           6 :         succeed_if (key8.getBinarySize () == sizeof (array), "Value size not correct");
     234           4 :         std::string getBack = key8.getBinary ();
     235           6 :         succeed_if (memcmp (&getBack[0], array, sizeof (array)) == 0, "could not get correct value with keyGetBinary");
     236          10 :         succeed_if (key8.getBaseName () == "there", "wrong base name");
     237             : 
     238           4 :         Key key9 ("system/valid/.inactive", KEY_COMMENT, "inactive key", KEY_END);
     239           6 :         succeed_if (key9.isInactive (), "key should be inactive");
     240          16 :         succeed_if (key9.getMeta<std::string> ("comment") == "inactive key", "comment failed");
     241          10 :         succeed_if (key9.getBaseName () == ".inactive", "wrong base name");
     242             : 
     243           8 :         std::string name = "system/valid/name";
     244           6 :         Key keyA (name, KEY_END);
     245          10 :         succeed_if (keyA.getName () == "system/valid/name", "keyA has wrong name");
     246          10 :         succeed_if (keyA.getBaseName () == "name", "keyA wrong base name");
     247             : 
     248           4 :         Key keyB ("", KEY_END);
     249           2 :         keyB.setBinary (nullptr, 0);
     250           6 :         succeed_if (keyB.isBinary (), "should be binary");
     251          10 :         succeed_if (keyB.getBinary () == "", "Binary should be a nullpointer");
     252           6 :         succeed_if (keyB.getValue () == nullptr, "Binary should be a nullpointer");
     253             : 
     254           2 :         keyB.setBinary (nullptr, 1);
     255           6 :         succeed_if (keyB.isBinary (), "should be binary");
     256          10 :         succeed_if (keyB.getBinary () == "", "Binary should be a nullpointer");
     257           6 :         succeed_if (keyB.getValue () == nullptr, "Binary should be a nullpointer");
     258             : }
     259             : 
     260          20 : TEST (key, constructor)
     261             : {
     262           2 :         ckdb::Key * ck = ckdb::keyNew (nullptr);
     263           4 :         Key k = ck; // constructor with (ckdb::Key)
     264             : 
     265             :         /*
     266             :         cout << "ck:   " << (void*)ck << endl;
     267             :         cout << "k:    " << (void*)&k << endl;
     268             :         cout << "k.ck: " << (void*)k.getKey() << endl;
     269             :         */
     270             : 
     271           2 :         k.set<int> (30);
     272           6 :         succeed_if (k.get<int> () == 30, "could not get same int");
     273             : }
     274             : 
     275          20 : TEST (key, set)
     276             : {
     277             :         ckdb::Key * ck;
     278           4 :         Key k;
     279             : 
     280           2 :         ck = ckdb::keyNew (nullptr);
     281           2 :         k = ck; // operator= alias for setKey()
     282             : 
     283             :         /*
     284             :         cout << "ck:   " << (void*)ck << endl;
     285             :         cout << "k:    " << (void*)&k << endl;
     286             :         cout << "k.ck: " << (void*)k.getKey() << endl;
     287             :         */
     288             : 
     289           2 :         k.set<int> (30);
     290           6 :         succeed_if (k.get<int> () == 30, "could not get same int");
     291             : }
     292             : 
     293          20 : TEST (key, cast)
     294             : {
     295             :         ckdb::Key * ck;
     296             :         Key * k;
     297             : 
     298           2 :         ck = ckdb::keyNew (nullptr);
     299           2 :         k = reinterpret_cast<Key *> (&ck); // not copied on purpose
     300             : 
     301             :         /*
     302             :         cout << "&ck:  " << (void*)&ck << endl;
     303             :         cout << "k:    " << (void*)&k << endl;
     304             :         cout << "ck:   " << (void*)ck << endl;
     305             :         cout << "k.ck: " << (void*)k->getKey() << endl;
     306             :         */
     307             : 
     308           2 :         k->set<int> (30);
     309           6 :         succeed_if (k->get<int> () == 30, "could not get same int");
     310             : 
     311           2 :         ckdb::keyDel (ck);
     312             : }
     313             : 
     314          20 : TEST (key, value)
     315             : {
     316             :         // cout << "testing value" << endl;
     317           4 :         Key test;
     318          10 :         succeed_if (test.getString () == "", "String should be empty");
     319             : 
     320          10 :         test.setString ("23.3");
     321           6 :         succeed_if (test.get<double> () >= 23.2, "could not get same double");
     322           6 :         succeed_if (test.get<double> () <= 23.4, "could not get same double");
     323           6 :         succeed_if (test.getBinarySize () == 5, "value size not correct");
     324             : 
     325          10 :         test.setString ("401");
     326           6 :         succeed_if (test.get<int> () == 401, "could not get same int");
     327           6 :         succeed_if (test.getBinarySize () == 4, "value size not correct");
     328             : 
     329          10 :         test.setString ("mystr");
     330          10 :         succeed_if (test.get<string> () == "mystr", "could not get same string");
     331           6 :         succeed_if (test.getBinarySize () == 6, "value size not correct");
     332             : 
     333          10 :         test.setString ("myoth");
     334          10 :         succeed_if (test.get<string> () == "myoth", "could not get same string");
     335           6 :         succeed_if (test.getBinarySize () == 6, "value size not correct");
     336             : 
     337           2 :         test.set<double> (23.3);
     338          10 :         succeed_if (test.getString () == "23.3", "could not get same double");
     339           6 :         succeed_if (test.getBinarySize () == 5, "value size not correct");
     340             : 
     341           2 :         test.set<int> (401);
     342          10 :         succeed_if (test.getString () == "401", "could not get same int");
     343           6 :         succeed_if (test.getBinarySize () == 4, "value size not correct");
     344             : 
     345           8 :         test.set<string> ("mystr");
     346          10 :         succeed_if (test.getString () == "mystr", "could not get same string");
     347           6 :         succeed_if (test.getBinarySize () == 6, "value size not correct");
     348             : 
     349           8 :         test.set<string> ("myoth");
     350          10 :         succeed_if (test.getString () == "myoth", "could not get same string");
     351           6 :         succeed_if (test.getBinarySize () == 6, "value size not correct");
     352             : 
     353          14 :         test.setMeta<std::string> ("comment", "mycomment");
     354          16 :         succeed_if (test.getMeta<std::string> ("comment") == "mycomment", "could not get same comment");
     355             : }
     356             : 
     357          20 : TEST (key, exceptions)
     358             : {
     359           4 :         Key test;
     360             : 
     361             :         try
     362             :         {
     363           8 :                 test.setName ("no");
     364             :         }
     365           4 :         catch (kdb::KeyInvalidName const &)
     366             :         {
     367          10 :                 succeed_if (test.getName () == "", "not set to noname");
     368             :         }
     369             : 
     370           8 :         test.setName ("user/name");
     371          10 :         succeed_if (test.getName () == "user/name", "could not get same name");
     372             : 
     373             :         try
     374             :         {
     375           8 :                 test.setName ("no");
     376             :         }
     377           4 :         catch (kdb::KeyInvalidName const &)
     378             :         {
     379          10 :                 succeed_if (test.getName () == "", "not set to noname");
     380             :         }
     381             : }
     382             : 
     383          20 : TEST (key, name)
     384             : {
     385           4 :         Key test;
     386          10 :         succeed_if (test.getName () == "", "Name should be empty");
     387             : 
     388           8 :         test.setName ("user:markus/test");
     389          10 :         succeed_if (test.getName () == "user/test", "Wrong name");
     390          10 :         succeed_if (test.getFullName () == "user:markus/test", "Wrong full name");
     391          16 :         succeed_if (test.getMeta<std::string> ("owner") == "markus", "Wrong owner");
     392           6 :         succeed_if (test.getNameSize () == 10, "wrong name size");
     393           6 :         succeed_if (test.getFullNameSize () == 17, "wrong full name size");
     394           6 :         succeed_if (!test.isCascading (), "key is cascading");
     395           6 :         succeed_if (!test.isSpec (), "key is spec");
     396           6 :         succeed_if (!test.isProc (), "key is proc");
     397           6 :         succeed_if (!test.isDir (), "key is dir");
     398           6 :         succeed_if (test.isUser (), "key is not user");
     399           6 :         succeed_if (!test.isSystem (), "key is system");
     400             : 
     401          14 :         test.setMeta<std::string> ("owner", "gerald");
     402          10 :         succeed_if (test.getName () == "user/test", "Wrong name");
     403          10 :         succeed_if (test.getFullName () == "user:gerald/test", "Wrong full name");
     404          16 :         succeed_if (test.getMeta<std::string> ("owner") == "gerald", "Wrong owner");
     405           6 :         succeed_if (test.getNameSize () == 10, "wrong name size");
     406           6 :         succeed_if (test.getFullNameSize () == 17, "wrong full name size");
     407           6 :         succeed_if (!test.isCascading (), "key is cascading");
     408           6 :         succeed_if (!test.isSpec (), "key is spec");
     409           6 :         succeed_if (!test.isProc (), "key is proc");
     410           6 :         succeed_if (!test.isDir (), "key is dir");
     411           6 :         succeed_if (test.isUser (), "key is not user");
     412           6 :         succeed_if (!test.isSystem (), "key is system");
     413             : 
     414           8 :         test.setName ("system/test");
     415          14 :         test.setMeta<std::string> ("owner", "markus");
     416          10 :         succeed_if (test.getName () == "system/test", "Wrong name");
     417          10 :         succeed_if (test.getFullName () == "system/test", "Wrong full name");
     418          16 :         succeed_if (test.getMeta<std::string> ("owner") == "markus", "Wrong owner");
     419          16 :         succeed_if (test.getMeta<std::string> ("owner") == "markus", "Wrong owner");
     420           6 :         succeed_if (test.getNameSize () == 12, "wrong name size");
     421           6 :         succeed_if (test.getFullNameSize () == 12, "wrong full name size");
     422           6 :         succeed_if (!test.isCascading (), "key is cascading");
     423           6 :         succeed_if (!test.isSpec (), "key is spec");
     424           6 :         succeed_if (!test.isProc (), "key is proc");
     425           6 :         succeed_if (!test.isDir (), "key is dir");
     426           6 :         succeed_if (!test.isUser (), "key is not user");
     427           6 :         succeed_if (test.isSystem (), "key is system");
     428             : 
     429           8 :         test.setName ("dir/test");
     430          10 :         succeed_if (test.getName () == "dir/test", "Wrong name");
     431          10 :         succeed_if (test.getFullName () == "dir/test", "Wrong full name");
     432           6 :         succeed_if (test.getNameSize () == 9, "wrong name size");
     433           6 :         succeed_if (test.getFullNameSize () == 9, "wrong full name size");
     434           6 :         succeed_if (!test.isCascading (), "key is cascading");
     435           6 :         succeed_if (!test.isSpec (), "key is spec");
     436           6 :         succeed_if (!test.isProc (), "key is proc");
     437           6 :         succeed_if (test.isDir (), "key is not dir");
     438           6 :         succeed_if (!test.isUser (), "key is user");
     439           6 :         succeed_if (!test.isSystem (), "key is system");
     440             : 
     441           8 :         test.setName ("proc/test");
     442          10 :         succeed_if (test.getName () == "proc/test", "Wrong name");
     443          10 :         succeed_if (test.getFullName () == "proc/test", "Wrong full name");
     444           6 :         succeed_if (test.getNameSize () == 10, "wrong name size");
     445           6 :         succeed_if (test.getFullNameSize () == 10, "wrong full name size");
     446           6 :         succeed_if (!test.isCascading (), "key is cascading");
     447           6 :         succeed_if (!test.isSpec (), "key is spec");
     448           6 :         succeed_if (test.isProc (), "key is not proc");
     449           6 :         succeed_if (!test.isDir (), "key is dir");
     450           6 :         succeed_if (!test.isUser (), "key is user");
     451           6 :         succeed_if (!test.isSystem (), "key is system");
     452             : 
     453           8 :         test.setName ("spec/test");
     454          10 :         succeed_if (test.getName () == "spec/test", "Wrong name");
     455          10 :         succeed_if (test.getFullName () == "spec/test", "Wrong full name");
     456           6 :         succeed_if (test.getNameSize () == 10, "wrong name size");
     457           6 :         succeed_if (test.getFullNameSize () == 10, "wrong full name size");
     458           6 :         succeed_if (!test.isCascading (), "key is cascading");
     459           6 :         succeed_if (test.isSpec (), "key is not spec");
     460           6 :         succeed_if (!test.isProc (), "key is proc");
     461           6 :         succeed_if (!test.isDir (), "key is dir");
     462           6 :         succeed_if (!test.isUser (), "key is user");
     463           6 :         succeed_if (!test.isSystem (), "key is system");
     464             : 
     465           8 :         test.setName ("/test");
     466          10 :         succeed_if (test.getName () == "/test", "Wrong name");
     467          10 :         succeed_if (test.getFullName () == "/test", "Wrong full name");
     468           6 :         succeed_if (test.getNameSize () == 6, "wrong name size");
     469           6 :         succeed_if (test.getFullNameSize () == 6, "wrong full name size");
     470           6 :         succeed_if (test.isCascading (), "key is not cascading");
     471           6 :         succeed_if (!test.isSpec (), "key is not spec");
     472           6 :         succeed_if (!test.isProc (), "key is proc");
     473           6 :         succeed_if (!test.isDir (), "key is dir");
     474           6 :         succeed_if (!test.isUser (), "key is user");
     475           6 :         succeed_if (!test.isSystem (), "key is system");
     476             : 
     477             : 
     478           8 :         test.setName ("user/dir/test");
     479           8 :         test.setBaseName ("mykey");
     480          10 :         succeed_if (test.getName () == "user/dir/mykey", "Basename did not work");
     481           6 :         test.setName (test.getName () + "/onedeeper");                     // add basename is trivial
     482           8 :         succeed_if (test.getName ().find ('/') == 4, "user length"); // keyGetRootNameSize trivial
     483             : 
     484             :         // so we finally got a name, lets test below
     485          10 :         succeed_if (test.getName () == "user/dir/mykey/onedeeper", "Basename did not work");
     486             : 
     487          10 :         succeed_if (test.isBelow (Key ("user", KEY_END)), "key is below");
     488          10 :         succeed_if (test.isBelow (Key ("user/dir", KEY_END)), "key is below");
     489          10 :         succeed_if (test.isBelow (Key ("user/dir/mykey", KEY_END)), "key is below");
     490          10 :         succeed_if (!test.isBelow (Key ("user/dir/mykey/onedeeper", KEY_END)), "key is not below (but same)");
     491          10 :         succeed_if (!test.isBelow (Key ("user/otherdir", KEY_END)), "key is not below");
     492             : 
     493          10 :         succeed_if (test.isBelowOrSame (Key ("user", KEY_END)), "key is below");
     494          10 :         succeed_if (test.isBelowOrSame (Key ("user/dir", KEY_END)), "key is below");
     495          10 :         succeed_if (test.isBelowOrSame (Key ("user/dir/mykey", KEY_END)), "key is below");
     496          10 :         succeed_if (test.isBelowOrSame (Key ("user/dir/mykey/onedeeper", KEY_END)), "key is same");
     497          10 :         succeed_if (!test.isBelowOrSame (Key ("user/otherdir", KEY_END)), "key is not below");
     498             : 
     499          10 :         succeed_if (test.isDirectBelow (Key ("user/dir/mykey", KEY_END)), "key is direct below");
     500          10 :         succeed_if (!test.isDirectBelow (Key ("user/dir/test", KEY_END)), "key is not direct below");
     501          10 :         succeed_if (!test.isDirectBelow (Key ("user/dir", KEY_END)), "key is not direct below");
     502          10 :         succeed_if (!test.isDirectBelow (Key ("user/dir/otherdir", KEY_END)), "key is not direct below");
     503          10 :         succeed_if (!test.isDirectBelow (Key ("user/otherdir", KEY_END)), "key is not direct below");
     504          10 :         succeed_if (!test.isDirectBelow (Key ("user", KEY_END)), "key is not direct below");
     505             : 
     506           8 :         test.setName ("system/elektra");
     507          10 :         succeed_if (test.isBelow (Key ("system", KEY_END)), "system/elektra is not below system");
     508           8 :         test.setName ("system");
     509          10 :         succeed_if (!test.isBelow (Key ("system/elektra", KEY_END)), "system is below system/elektra");
     510             : }
     511             : 
     512           4 : void f (Key)
     513             : {
     514           8 :         Key h ("user/infunction", KEY_END);
     515           4 : }
     516             : 
     517          20 : TEST (key, ref)
     518             : {
     519           4 :         Key zgr1 ("user/zgr1", KEY_END);
     520             :         {
     521           4 :                 Key zgr2 ("user/zgr2", KEY_END);
     522           4 :                 Key zgr3 ("user/zgr3", KEY_END);
     523           4 :                 Key zgr4 ("user/zgr4", KEY_END);
     524           4 :                 Key zgr5 ("user/zgr5", KEY_END);
     525           2 :                 zgr2 = zgr1;
     526           2 :                 zgr3 = zgr1;
     527           2 :                 zgr4 = zgr1;
     528             :         }
     529             : 
     530           4 :         f (zgr1);
     531           4 :         f (Key ("user/passed", KEY_END));
     532             : 
     533           4 :         Key test;
     534           8 :         test.setName ("user:markus/test");
     535             : 
     536           4 :         Key ref1;
     537           2 :         ref1 = test; // operator =
     538           8 :         succeed_if (*ref1 == *test, "should point to the same object");
     539             : 
     540          10 :         succeed_if (test.getName () == "user/test", "wrong name");
     541          10 :         succeed_if (ref1.getName () == "user/test", "ref key wrong name");
     542             : 
     543           4 :         Key ref2 = test; // copy constructor
     544           8 :         succeed_if (*ref2 == *test, "should point to the same object");
     545             : 
     546          10 :         succeed_if (test.getName () == "user/test", "wrong name");
     547          10 :         succeed_if (ref2.getName () == "user/test", "ref key wrong name");
     548             : 
     549           4 :         const Key consttest ("user/test", KEY_END);
     550           4 :         Key ref3 = consttest; // const copy constructor
     551           8 :         succeed_if (*ref3 == *consttest, "should point to the same object");
     552             : 
     553          10 :         succeed_if (consttest.getName () == "user/test", "wrong name");
     554          10 :         succeed_if (ref3.getName () == "user/test", "ref key wrong name");
     555             : }
     556             : 
     557          20 : TEST (key, dup)
     558             : {
     559           4 :         Key test;
     560           8 :         test.setName ("user:markus/test");
     561             : 
     562           4 :         Key dup0 = test.dup (); // directly call of dup()
     563             : 
     564          10 :         succeed_if (test.getName () == "user/test", "wrong name");
     565          10 :         succeed_if (dup0.getName () == "user/test", "dup key wrong name");
     566             : 
     567           6 :         Key dup1 = test.dup (); // directly call of dup()
     568          10 :         succeed_if (dup1.getName () == "user/test", "dup key wrong name");
     569             : 
     570           8 :         succeed_if (*test != *dup0, "should be other key");
     571           8 :         succeed_if (*test != *dup1, "should be other key");
     572             : }
     573             : 
     574          20 : TEST (key, valid)
     575             : {
     576           4 :         Key i1;
     577           6 :         succeed_if (!i1.isValid (), "key should not be valid");
     578           4 :         succeed_if (i1, "even though it is invalid, it is still not a null key");
     579             : 
     580           4 :         Key i2 ("", KEY_END);
     581           6 :         succeed_if (!i2.isValid (), "key should not be valid");
     582           4 :         succeed_if (i2, "even though it is invalid, it is still not a null key");
     583             : 
     584           4 :         vector<string> invalid_names;
     585             :         // invalid_names.push_back ("/abc");
     586             :         // invalid_names.push_back ("/");
     587          10 :         invalid_names.push_back ("use");
     588          10 :         invalid_names.push_back ("users");
     589          10 :         invalid_names.push_back ("users:");
     590          10 :         invalid_names.push_back ("syste");
     591          10 :         invalid_names.push_back ("systems");
     592          10 :         invalid_names.push_back ("system:abc");
     593          10 :         invalid_names.push_back ("error/somthing");
     594          10 :         invalid_names.push_back (".");
     595          10 :         invalid_names.push_back ("..");
     596             : 
     597          26 :         for (auto & invalid_name : invalid_names)
     598             :         {
     599          54 :                 Key i3 (invalid_name, KEY_END);
     600          54 :                 succeed_if (!i3.isValid (), "key " + invalid_name + " should not be valid");
     601          36 :                 succeed_if (i3, "even though it is invalid, it is still not a null key");
     602             :         }
     603             : 
     604           4 :         Key v1 ("user", KEY_END);
     605           6 :         succeed_if (v1.isValid (), "key should be valid");
     606           4 :         succeed_if (v1, "should be non-null too");
     607             : 
     608           4 :         Key v2 ("system", KEY_END);
     609           6 :         succeed_if (v2.isValid (), "key should be valid");
     610           4 :         succeed_if (v2, "should be non-null too");
     611             : 
     612           4 :         vector<string> valid_names;
     613          10 :         valid_names.push_back ("user/abc");
     614          10 :         valid_names.push_back ("user/s");
     615          10 :         valid_names.push_back ("system/s");
     616          10 :         valid_names.push_back ("user/error/somthing");
     617          10 :         valid_names.push_back ("system/");
     618          10 :         valid_names.push_back ("user/.");
     619          10 :         valid_names.push_back ("system/abc/..");
     620          10 :         valid_names.push_back ("system/abc/../more");
     621             : 
     622          24 :         for (auto & valid_name : valid_names)
     623             :         {
     624          48 :                 Key v3 (valid_name, KEY_END);
     625          48 :                 succeed_if (v3.isValid (), "key should be valid");
     626          32 :                 succeed_if (v3, "should not be a null key");
     627             :         }
     628             : }
     629             : 
     630          20 : TEST (key, clear)
     631             : {
     632           4 :         Key k1 ("user", KEY_END);
     633           4 :         Key k2 = k1;
     634           4 :         Key k3 = k1;
     635             : 
     636           6 :         succeed_if (k1.isValid (), "key should be valid");
     637           6 :         succeed_if (k2.isValid (), "key should be valid");
     638           6 :         succeed_if (k3.isValid (), "key should be valid");
     639             : 
     640          10 :         succeed_if (k1.getName () == "user", "name should be user");
     641          10 :         succeed_if (k2.getName () == "user", "name should be user");
     642          10 :         succeed_if (k3.getName () == "user", "name should be user");
     643             : 
     644             : 
     645           2 :         k1.clear ();
     646             : 
     647           6 :         succeed_if (!k1.isValid (), "key should be invalid");
     648           6 :         succeed_if (!k2.isValid (), "key should be invalid");
     649           6 :         succeed_if (!k3.isValid (), "key should be invalid");
     650             : 
     651          10 :         succeed_if (k1.getName () == "", "name should be empty");
     652          10 :         succeed_if (k2.getName () == "", "name should be empty");
     653          10 :         succeed_if (k3.getName () == "", "name should be empty");
     654             : 
     655           8 :         k1.setMeta ("test_meta", "meta_value");
     656          16 :         succeed_if (k1.getMeta<std::string> ("test_meta") == "meta_value", "metadata not set correctly");
     657          16 :         succeed_if (k2.getMeta<std::string> ("test_meta") == "meta_value", "metadata not set correctly");
     658          16 :         succeed_if (k3.getMeta<std::string> ("test_meta") == "meta_value", "metadata not set correctly");
     659             : 
     660           2 :         k2.clear ();
     661             : 
     662          18 :         succeed_if (!k1.getMeta<const Key> ("test_meta"), "metadata not set correctly");
     663          18 :         succeed_if (!k2.getMeta<const Key> ("test_meta"), "metadata not set correctly");
     664          18 :         succeed_if (!k3.getMeta<const Key> ("test_meta"), "metadata not set correctly");
     665             : }
     666             : 
     667          20 : TEST (key, conversation)
     668             : {
     669           4 :         Key k1 ("user", KEY_END);
     670           2 :         ckdb::Key * ck1 = k1.getKey ();
     671           6 :         succeed_if (!strcmp (ckdb::keyName (ck1), "user"), "c key does not have correct name");
     672           6 :         succeed_if (!strcmp (ckdb::keyName (*k1), "user"), "c key does not have correct name");
     673             : 
     674           2 :         ck1 = k1.release ();
     675           6 :         succeed_if (!strcmp (ckdb::keyName (ck1), "user"), "c key does not have correct name");
     676           2 :         ckdb::keyDel (ck1);
     677             : }
     678             : 
     679          20 : TEST (key, keynamespace)
     680             : {
     681          12 :         succeed_if (Key ("user", KEY_END).getNamespace () == "user", "namespace wrong");
     682          12 :         succeed_if (Key ("user/a", KEY_END).getNamespace () == "user", "namespace wrong");
     683             :         // std::cout << Key ("user/a", KEY_END).getNamespace () << std::endl;
     684          12 :         succeed_if (Key ("user/a/b/c", KEY_END).getNamespace () == "user", "namespace wrong");
     685          12 :         succeed_if (Key ("user/a/../..", KEY_END).getNamespace () == "user", "namespace wrong");
     686          12 :         succeed_if (Key ("user/a/../../x/f/v", KEY_END).getNamespace () == "user", "namespace wrong");
     687             : 
     688          12 :         succeed_if (Key ("dir", KEY_END).getNamespace () == "dir", "namespace wrong");
     689          12 :         succeed_if (Key ("proc", KEY_END).getNamespace () == "proc", "namespace wrong");
     690          12 :         succeed_if (Key ("spec", KEY_END).getNamespace () == "spec", "namespace wrong");
     691          12 :         succeed_if (Key ("system", KEY_END).getNamespace () == "system", "namespace wrong");
     692             : 
     693          12 :         succeed_if (Key ("dir/abc", KEY_END).getNamespace () == "dir", "namespace wrong");
     694          12 :         succeed_if (Key ("proc/abc", KEY_END).getNamespace () == "proc", "namespace wrong");
     695          12 :         succeed_if (Key ("spec/abc", KEY_END).getNamespace () == "spec", "namespace wrong");
     696          12 :         succeed_if (Key ("system/abc", KEY_END).getNamespace () == "system", "namespace wrong");
     697             : 
     698          12 :         succeed_if (Key ("/", KEY_END).getNamespace () == "/", "namespace wrong");
     699          12 :         succeed_if (Key ("/abc", KEY_END).getNamespace () == "/", "namespace wrong");
     700             : }
     701             : 
     702          20 : TEST (key, comparision)
     703             : {
     704           8 :         Key ke1, ke2;
     705             : 
     706           6 :         succeed_if (ke1 == ke2, "two empty keys are not the same?");
     707           6 :         succeed_if (!(ke1 != ke2), "two empty keys are not the same?");
     708             : 
     709           6 :         Key k1 ("user/a", KEY_END), k2 ("user/b", KEY_END);
     710             : 
     711           6 :         succeed_if (ke1 < k1, "compare empty key with user/a");
     712           6 :         succeed_if (ke1 <= k1, "compare empty key with user/a");
     713           6 :         succeed_if (!(ke1 > k1), "compare empty key with user/a");
     714           6 :         succeed_if (!(ke1 >= k1), "compare empty key with user/a");
     715             : 
     716           6 :         succeed_if (ke1 < k2, "compare empty key with user/b");
     717           6 :         succeed_if (ke1 <= k2, "compare empty key with user/b");
     718           6 :         succeed_if (!(ke1 > k2), "compare empty key with user/b");
     719           6 :         succeed_if (!(ke1 >= k2), "compare empty key with user/b");
     720             : 
     721           6 :         succeed_if (k1 < k2, "compare key user/a with user/b");
     722           6 :         succeed_if (k1 <= k2, "compare key user/a with user/b");
     723           6 :         succeed_if (!(k1 > k2), "compare key user/a with user/b");
     724           6 :         succeed_if (!(k1 >= k2), "compare key user/a with user/b");
     725           6 :         succeed_if (k1 != k2, "compare key user/a with user/b");
     726           6 :         succeed_if (!(k1 == k2), "compare key user/a with user/b");
     727             : 
     728           6 :         Key ko1 ("user/a", KEY_OWNER, "markus", KEY_END), ko2 ("user/b", KEY_OWNER, "max", KEY_END);
     729             : 
     730           6 :         succeed_if (ko1 > k1, "compare key with user/a");
     731           6 :         succeed_if (ko1 >= k1, "compare key with user/a");
     732           6 :         succeed_if (!(ko1 < k1), "compare key with user/a");
     733           6 :         succeed_if (!(ko1 <= k1), "compare key with user/a");
     734             : 
     735           6 :         succeed_if (ko2 > k2, "compare key with user/b");
     736           6 :         succeed_if (ko2 >= k2, "compare key with user/b");
     737           6 :         succeed_if (!(ko2 < k2), "compare key with user/b");
     738           6 :         succeed_if (!(ko2 <= k2), "compare key with user/b");
     739             : 
     740           4 :         Key ko ("user/a", KEY_OWNER, "max", KEY_END);
     741             : 
     742           6 :         succeed_if (ko1 < ko, "compare key with user/b");
     743           6 :         succeed_if (ko1 <= ko, "compare key with user/b");
     744           6 :         succeed_if (!(ko1 > ko), "compare key with user/b");
     745           6 :         succeed_if (!(ko1 >= ko), "compare key with user/b");
     746             : 
     747           6 :         succeed_if (ko1 < ko2, "compare key user/a with     user/a owner max");
     748           6 :         succeed_if (ko1 <= ko2, "compare key user/a with    user/a owner max");
     749           6 :         succeed_if (!(ko1 > ko2), "compare key user/a with  user/a owner max");
     750           6 :         succeed_if (!(ko1 >= ko2), "compare key user/a with user/a owner max");
     751           6 :         succeed_if (ko1 != ko2, "compare key user/a with    user/a owner max");
     752           6 :         succeed_if (!(ko1 == ko2), "compare key user/a with user/a owner max");
     753             : }
     754             : 
     755             : 
     756           8 : struct C
     757             : {
     758             :         Key ks;
     759             : };
     760             : 
     761          20 : TEST (key, move)
     762             : {
     763             : 
     764           6 :         std::unique_ptr<Key> u1 (new Key ("user/key3/1", KEY_END));
     765           6 :         std::unique_ptr<Key> u2 (std::move (u1));
     766           6 :         std::unique_ptr<Key> u3 = std::move (u1);
     767             : 
     768           8 :         std::unique_ptr<C> c1 (new C);
     769           6 :         std::unique_ptr<C> c2 (std::move (c1));
     770           6 :         std::unique_ptr<C> c3 = std::move (c1);
     771           8 : }

Generated by: LCOV version 1.13