LCOV - code coverage report
Current view: top level - tests/kdb - testkdb_highlevel.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 482 485 99.4 %
Date: 2019-09-12 12:28:41 Functions: 35 46 76.1 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see doc/LICENSE.md or http://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <elektra.h>
      10             : #include <elektra/conversion.h>
      11             : 
      12             : #include <gtest/gtest-elektra.h>
      13             : #include <kdbhelper.h>
      14             : 
      15             : #define EXPECT_KEYVALUE(Key, Value) EXPECT_PRED2 (keyHasValue, Key, Value)
      16             : #define EXPECT_KEYMETA(Key, Meta, Value) EXPECT_PRED3 (keyHasMetaValue, Key, Meta, Value)
      17             : 
      18         658 : static inline bool keyHasValue (const kdb::Key & key, const std::string & value)
      19             : {
      20        1974 :         return key && key.getString () == value;
      21             : }
      22             : 
      23          48 : static inline bool keyHasMetaValue (const kdb::Key & key, const std::string & metaName, const std::string & value)
      24             : {
      25         144 :         return key && key.getMeta<std::string> (metaName) == value;
      26             : }
      27             : 
      28             : /* TODO: re-add once we have a stable public error API
      29             : constexpr const char * severityString (ElektraErrorSeverity severity)
      30             : {
      31             :         return severity == ELEKTRA_ERROR_SEVERITY_ERROR ? "ERROR" : (severity == ELEKTRA_ERROR_SEVERITY_WARNING ? "WARNING" : "FATAL");
      32             : }
      33             : 
      34             : static inline const char * severityString (ElektraError * error)
      35             : {
      36             :         return severityString (elektraErrorSeverity (error));
      37             : }
      38             : 
      39             : static std::ostream & operator<< (std::ostream & os, ElektraError ** error)
      40             : {
      41             :         if (*error != nullptr)
      42             :         {
      43             :                 os << "[" << severityString (*error) << "] (" << elektraErrorCode (*error) << ") " << elektraErrorDescription (*error)
      44             :                    << std::endl;
      45             : 
      46             :                 int kdbCode = elektraKDBErrorCode (*error);
      47             :                 if (kdbCode > 0)
      48             :                 {
      49             :                         os << "\tKDB";
      50             :                         switch (elektraKDBErrorSeverity (*error))
      51             :                         {
      52             :                         case ELEKTRA_ERROR_SEVERITY_ERROR:
      53             :                                 os << "ERROR";
      54             :                                 break;
      55             :                         case ELEKTRA_ERROR_SEVERITY_WARNING:
      56             :                                 os << "WARNING";
      57             :                                 break;
      58             :                         default:
      59             :                         case ELEKTRA_ERROR_SEVERITY_FATAL:
      60             :                                 os << "FATAL";
      61             :                                 break;
      62             :                         }
      63             : 
      64             :                         os << " " << kdbCode << " [" << elektraKDBErrorGroup (*error) << "/" << elektraKDBErrorModule (*error) << "]"
      65             :                            << ": " << elektraKDBErrorDescription (*error) << std::endl;
      66             :                         os << "\t\tReason: " << elektraKDBErrorReason (*error) << std::endl;
      67             : 
      68             :                         int warningCount = elektraKDBErrorWarningCount (*error);
      69             :                         os << "\t\t" << warningCount << " Warnings:" << std::endl;
      70             :                         for (int i = 0; i < warningCount; ++i)
      71             :                         {
      72             :                                 ElektraError * warning = elektraKDBErrorGetWarning (*error, i);
      73             :                                 os << "\t\t - Warning " << elektraKDBErrorCode (warning) << " [" << elektraKDBErrorGroup (warning) << "/"
      74             :                                    << elektraKDBErrorModule (warning) << "]: " << elektraKDBErrorDescription (warning) << std::endl;
      75             :                                 ckdb::elektraFree (warning);
      76             :                         }
      77             :                         os << "\t\tFrom Key: " << ckdb::keyName (elektraKDBErrorKey (*error)) << std::endl;
      78             :                 }
      79             : 
      80             :                 elektraErrorReset (error);
      81             :         }
      82             :         return os;
      83             : }
      84             :  */
      85             : 
      86          40 : class Highlevel : public ::testing::Test
      87             : {
      88             : protected:
      89             :         static const std::string testRoot;
      90             :         static const std::string configFile;
      91             : 
      92             :         testing::Namespaces namespaces;
      93             :         testing::MountpointPtr mp;
      94             : 
      95             :         Elektra * elektra = nullptr;
      96             : 
      97          40 :         Highlevel () : namespaces ()
      98             :         {
      99          20 :         }
     100             : 
     101          20 :         void SetUp () override
     102             :         {
     103         100 :                 mp.reset (new testing::Mountpoint (testRoot, configFile));
     104          20 :         }
     105             : 
     106          20 :         void TearDown () override
     107             :         {
     108          20 :                 closeElektra ();
     109             : 
     110          40 :                 mp.reset ();
     111          20 :         }
     112             : 
     113             :         void closeElektra ()
     114             :         {
     115          46 :                 if (elektra != nullptr)
     116             :                 {
     117          22 :                         elektraClose (elektra);
     118          22 :                         elektra = nullptr;
     119             :                 }
     120             :         }
     121             : 
     122          30 :         static void fatalErrorHandler (ElektraError * error)
     123             :         {
     124          60 :                 std::stringstream msg;
     125             :                 msg << "fatal error in test " << ::testing::UnitTest::GetInstance ()->current_test_info ()->name () << ": "
     126         150 :                     << elektraErrorDescription (error) << std::endl;
     127             : 
     128          30 :                 elektraErrorReset (&error);
     129             : 
     130          90 :                 throw std::runtime_error (msg.str ());
     131             :         }
     132             : 
     133          22 :         void createElektra (ckdb::KeySet * defaults = nullptr, ckdb::KeySet * contract = nullptr)
     134             :         {
     135          22 :                 closeElektra ();
     136             : 
     137          22 :                 ElektraError * error = nullptr;
     138          66 :                 elektra = elektraOpen (("user" + testRoot).c_str (), defaults, contract, &error);
     139             : 
     140          44 :                 ASSERT_NE (elektra, nullptr) << "elektraOpen failed" << &error << std::endl;
     141             : 
     142          22 :                 elektraFatalErrorHandler (elektra, &fatalErrorHandler);
     143             :         }
     144             : 
     145             :         template <class T>
     146          10 :         void setValues (T values)
     147             :         {
     148             :                 using namespace kdb;
     149          20 :                 KDB kdb;
     150          20 :                 KeySet config;
     151             : 
     152          10 :                 kdb.get (config, testRoot);
     153        1156 :                 for (auto & value : values)
     154             :                 {
     155        1128 :                         config.append (value);
     156             :                 }
     157          10 :                 kdb.set (config, testRoot);
     158          10 :         }
     159             : 
     160             :         void setValues (std::initializer_list<kdb::Key> values)
     161             :         {
     162           6 :                 setValues<std::initializer_list<kdb::Key>> (values);
     163             :         }
     164             : 
     165           4 :         void setArrays (std::initializer_list<std::vector<kdb::Key>> arrays)
     166             :         {
     167             :                 using namespace kdb;
     168           8 :                 KDB kdb;
     169           8 :                 KeySet config;
     170             : 
     171           4 :                 kdb.get (config, testRoot);
     172          60 :                 for (auto & array : arrays)
     173             :                 {
     174         364 :                         for (auto & value : array)
     175             :                         {
     176         156 :                                 config.append (value);
     177             :                         }
     178             :                 }
     179           4 :                 kdb.set (config, testRoot);
     180           4 :         }
     181             : 
     182        1128 :         static const inline kdb::Key makeKey (KDBType type, const char * name, const char * value)
     183             :         {
     184        3384 :                 return kdb::Key ("user" + testRoot + name, KEY_VALUE, value, KEY_META, "type", type, KEY_END);
     185             :         }
     186             : 
     187          52 :         static const std::vector<kdb::Key> makeArray (KDBType type, const char * name, const std::vector<std::string> & values)
     188             :         {
     189         156 :                 std::vector<kdb::Key> array (values.size () + 1);
     190             :                 char arrayNumber[ELEKTRA_MAX_ARRAY_SIZE];
     191         312 :                 for (size_t i = 0; i < values.size (); ++i)
     192             :                 {
     193         104 :                         ckdb::elektraWriteArrayNumber (arrayNumber, i);
     194         832 :                         array[i + 1] = kdb::Key ("user" + testRoot + name + "/" + arrayNumber, KEY_VALUE, values[i].c_str (), KEY_META,
     195         104 :                                                  "type", type, KEY_END);
     196             :                 }
     197         260 :                 array[0] = kdb::Key ("user" + testRoot + name, KEY_META, "array", arrayNumber, KEY_END);
     198          52 :                 return array;
     199             :         }
     200             : };
     201             : 
     202           6 : const std::string Highlevel::configFile = "kdbFileHighlevel.dump";
     203           6 : const std::string Highlevel::testRoot = "/tests/highlevel/"; // DO NOT use namespace here, namespace would break testing::Mountpoint
     204             : 
     205          20 : TEST_F (Highlevel, CharTestGet)
     206             : {
     207           4 :         std::vector<kdb::Key> keys;
     208         512 :         for (int i = 0x01; i <= 0xFF; ++i)
     209             :         {
     210         510 :                 auto c = static_cast<kdb_char_t> (i);
     211         510 :                 char s[] = { static_cast<char> (c), '\0' };
     212        2040 :                 auto name = "char/_" + std::to_string (c);
     213        1020 :                 keys.push_back (makeKey (KDB_TYPE_CHAR, name.c_str (), s));
     214             :         }
     215           2 :         setValues (keys);
     216             : 
     217           2 :         createElektra ();
     218             : 
     219        1022 :         for (int i = 0x01; i <= 0xFF; ++i)
     220             :         {
     221         510 :                 auto c = static_cast<kdb_char_t> (i);
     222        2040 :                 auto name = "char/_" + std::to_string (c);
     223             :                 try
     224             :                 {
     225        1530 :                         EXPECT_EQ (elektraGetChar (elektra, name.c_str ()), c) << "char " + name + " wrong";
     226             :                 }
     227           0 :                 catch (std::runtime_error &)
     228             :                 {
     229           0 :                         ADD_FAILURE () << "unexpected std::runtime_error thrown for " + name;
     230             :                 }
     231             :         }
     232           2 : }
     233             : 
     234          20 : TEST_F (Highlevel, CharTestSet)
     235             : {
     236           4 :         std::vector<kdb::Key> keys;
     237         512 :         for (int i = 0x01; i <= 0xFF; ++i)
     238             :         {
     239         510 :                 auto c = static_cast<kdb_char_t> (i);
     240        2040 :                 auto name = "char/_" + std::to_string (c);
     241        1530 :                 keys.push_back (makeKey (KDB_TYPE_CHAR, name.c_str (), c == '_' ? "0" : "_"));
     242             :         }
     243           2 :         setValues (keys);
     244             : 
     245           2 :         createElektra ();
     246             : 
     247           2 :         ElektraError * error = nullptr;
     248             : 
     249         512 :         for (int i = 0x01; i <= 0xFF; ++i)
     250             :         {
     251         510 :                 auto c = static_cast<kdb_char_t> (i);
     252        2040 :                 auto name = "char/_" + std::to_string (c);
     253        1020 :                 elektraSetChar (elektra, name.c_str (), c, &error);
     254         510 :                 if (error != nullptr)
     255             :                 {
     256           0 :                         ADD_FAILURE () << "error for char " + name;
     257             :                 }
     258             :         }
     259             : 
     260             :         using namespace kdb;
     261           4 :         KDB kdb;
     262           4 :         KeySet config;
     263             : 
     264           2 :         kdb.get (config, testRoot);
     265        1022 :         for (int i = 0x01; i <= 0xFF; ++i)
     266             :         {
     267         510 :                 auto c = static_cast<kdb_char_t> (i);
     268        2040 :                 auto name = "char/_" + std::to_string (c);
     269         510 :                 char s[] = { static_cast<char> (c), '\0' };
     270        2550 :                 EXPECT_KEYVALUE (config.lookup (testRoot + name), s) << "Wrong key value. for char " + name;
     271             :         }
     272           2 : }
     273             : 
     274          20 : TEST_F (Highlevel, IntegerBordersGet)
     275             : {
     276           2 :         setValues ({
     277             :                 makeKey (KDB_TYPE_OCTET, "octet/below", "-1"),
     278             :                 makeKey (KDB_TYPE_OCTET, "octet/min", "0"),
     279             :                 makeKey (KDB_TYPE_OCTET, "octet/max", "255"),
     280             :                 makeKey (KDB_TYPE_OCTET, "octet/above", "256"),
     281             :                 makeKey (KDB_TYPE_SHORT, "short/below", "-32769"),
     282             :                 makeKey (KDB_TYPE_SHORT, "short/min", "-32768"),
     283             :                 makeKey (KDB_TYPE_SHORT, "short/max", "32767"),
     284             :                 makeKey (KDB_TYPE_SHORT, "short/above", "32768"),
     285             :                 makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/below", "-1"),
     286             :                 makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/min", "0"),
     287             :                 makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/max", "65535"),
     288             :                 makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/above", "65536"),
     289             :                 makeKey (KDB_TYPE_LONG, "long/below", "-2147483649"),
     290             :                 makeKey (KDB_TYPE_LONG, "long/min", "-2147483648"),
     291             :                 makeKey (KDB_TYPE_LONG, "long/max", "2147483647"),
     292             :                 makeKey (KDB_TYPE_LONG, "long/above", "2147483648"),
     293             :                 makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/below", "-1"),
     294             :                 makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/min", "0"),
     295             :                 makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/max", "4294967295"),
     296             :                 makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/above", "4294967296"),
     297             :                 makeKey (KDB_TYPE_LONG_LONG, "longlong/below", "-9223372036854775809"),
     298             :                 makeKey (KDB_TYPE_LONG_LONG, "longlong/min", "-9223372036854775808"),
     299             :                 makeKey (KDB_TYPE_LONG_LONG, "longlong/max", "9223372036854775807"),
     300             :                 makeKey (KDB_TYPE_LONG_LONG, "longlong/above", "9223372036854775808"),
     301             :                 makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/below", "-1"),
     302             :                 makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/min", "0"),
     303             :                 makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/max", "18446744073709551615"),
     304             :                 makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/above", "18446744073709551616"),
     305          62 :         });
     306             : 
     307           2 :         createElektra ();
     308             : 
     309           6 :         EXPECT_EQ (elektraGetOctet (elektra, "octet/min"), 0) << "octet/min wrong";
     310           6 :         EXPECT_EQ (elektraGetOctet (elektra, "octet/max"), 0xff) << "octet/max wrong";
     311           6 :         EXPECT_EQ (elektraGetShort (elektra, "short/min"), -0x8000) << "short/min wrong";
     312           6 :         EXPECT_EQ (elektraGetShort (elektra, "short/max"), 0x7fFF) << "short/max wrong";
     313           6 :         EXPECT_EQ (elektraGetUnsignedShort (elektra, "unsignedshort/min"), 0) << "unsignedshort/min wrong";
     314           6 :         EXPECT_EQ (elektraGetUnsignedShort (elektra, "unsignedshort/max"), 0xffFF) << "unsignedshort/max wrong";
     315           6 :         EXPECT_EQ (elektraGetLong (elektra, "long/min"), -0x80000000) << "long/min wrong";
     316           6 :         EXPECT_EQ (elektraGetLong (elektra, "long/max"), 0x7fFFffFF) << "long/max wrong";
     317           6 :         EXPECT_EQ (elektraGetUnsignedLong (elektra, "unsignedlong/min"), 0) << "unsignedlong/min wrong";
     318           6 :         EXPECT_EQ (elektraGetUnsignedLong (elektra, "unsignedlong/max"), 0xffFFffFF) << "unsignedlong/max wrong";
     319           6 :         EXPECT_EQ (elektraGetLongLong (elektra, "longlong/min"), -0x8000000000000000) << "longlong/min wrong";
     320           6 :         EXPECT_EQ (elektraGetLongLong (elektra, "longlong/max"), 0x7fFFffFFffFFffFF) << "longlong/max wrong";
     321           6 :         EXPECT_EQ (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/min"), 0) << "unsignedlonglong/min wrong";
     322           6 :         EXPECT_EQ (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/max"), 0xffFFffFFffFFffFF) << "unsignedlonglong/max wrong";
     323             : 
     324           4 :         EXPECT_THROW (elektraGetOctet (elektra, "octet/below"), std::runtime_error) << "octet/below accepted";
     325           4 :         EXPECT_THROW (elektraGetOctet (elektra, "octet/above"), std::runtime_error) << "octet/above accepted";
     326           4 :         EXPECT_THROW (elektraGetShort (elektra, "short/below"), std::runtime_error) << "short/below wrong";
     327           4 :         EXPECT_THROW (elektraGetShort (elektra, "short/above"), std::runtime_error) << "short/above wrong";
     328           4 :         EXPECT_THROW (elektraGetUnsignedShort (elektra, "unsignedshort/below"), std::runtime_error) << "unsignedshort/below wrong";
     329           4 :         EXPECT_THROW (elektraGetUnsignedShort (elektra, "unsignedshort/above"), std::runtime_error) << "unsignedshort/above wrong";
     330           4 :         EXPECT_THROW (elektraGetLong (elektra, "long/below"), std::runtime_error) << "long/below wrong";
     331           4 :         EXPECT_THROW (elektraGetLong (elektra, "long/above"), std::runtime_error) << "long/above wrong";
     332           4 :         EXPECT_THROW (elektraGetUnsignedLong (elektra, "unsignedlong/below"), std::runtime_error) << "unsignedlong/below wrong";
     333           4 :         EXPECT_THROW (elektraGetUnsignedLong (elektra, "unsignedlong/above"), std::runtime_error) << "unsignedlong/above wrong";
     334           4 :         EXPECT_THROW (elektraGetLongLong (elektra, "longlong/below"), std::runtime_error) << "longlong/below wrong";
     335           4 :         EXPECT_THROW (elektraGetLongLong (elektra, "longlong/above"), std::runtime_error) << "longlong/above wrong";
     336           4 :         EXPECT_THROW (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/below"), std::runtime_error) << "unsignedlonglong/below wrong";
     337           4 :         EXPECT_THROW (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/above"), std::runtime_error) << "unsignedlonglong/above wrong";
     338           2 : }
     339             : 
     340          20 : TEST_F (Highlevel, PrimitveGetters)
     341             : {
     342           2 :         setValues ({
     343             :                 makeKey (KDB_TYPE_STRING, "stringkey", "A string"),
     344             :                 makeKey (KDB_TYPE_BOOLEAN, "booleankey", "1"),
     345             :                 makeKey (KDB_TYPE_CHAR, "charkey", "c"),
     346             :                 makeKey (KDB_TYPE_OCTET, "octetkey", "1"),
     347             :                 makeKey (KDB_TYPE_SHORT, "shortkey", "1"),
     348             :                 makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshortkey", "1"),
     349             :                 makeKey (KDB_TYPE_LONG, "longkey", "1"),
     350             :                 makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlongkey", "1"),
     351             :                 makeKey (KDB_TYPE_LONG_LONG, "longlongkey", "1"),
     352             :                 makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglongkey", "1"),
     353             :                 makeKey (KDB_TYPE_FLOAT, "floatkey", "1.1"),
     354             :                 makeKey (KDB_TYPE_DOUBLE, "doublekey", "1.1"),
     355             : 
     356             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     357             : 
     358             :                 makeKey (KDB_TYPE_LONG_DOUBLE, "longdoublekey", "1.1"),
     359             : 
     360             : #endif
     361          32 :         });
     362             : 
     363           2 :         createElektra ();
     364             : 
     365           4 :         EXPECT_STREQ (elektraGetString (elektra, "stringkey"), "A string") << "Wrong key value.";
     366           6 :         EXPECT_TRUE (elektraGetBoolean (elektra, "booleankey")) << "Wrong key value.";
     367           6 :         EXPECT_EQ (elektraGetChar (elektra, "charkey"), 'c') << "Wrong key value.";
     368           6 :         EXPECT_EQ (elektraGetOctet (elektra, "octetkey"), 1) << "Wrong key value.";
     369           6 :         EXPECT_EQ (elektraGetShort (elektra, "shortkey"), 1) << "Wrong key value.";
     370           6 :         EXPECT_EQ (elektraGetUnsignedShort (elektra, "unsignedshortkey"), 1) << "Wrong key value.";
     371           6 :         EXPECT_EQ (elektraGetLong (elektra, "longkey"), 1) << "Wrong key value.";
     372           6 :         EXPECT_EQ (elektraGetUnsignedLong (elektra, "unsignedlongkey"), 1) << "Wrong key value.";
     373           6 :         EXPECT_EQ (elektraGetLongLong (elektra, "longlongkey"), 1) << "Wrong key value.";
     374           6 :         EXPECT_EQ (elektraGetUnsignedLongLong (elektra, "unsignedlonglongkey"), 1) << "Wrong key value.";
     375             : 
     376           6 :         EXPECT_EQ (elektraGetFloat (elektra, "floatkey"), 1.1f) << "Wrong key value.";
     377           6 :         EXPECT_EQ (elektraGetDouble (elektra, "doublekey"), 1.1) << "Wrong key value.";
     378             : 
     379             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     380             : 
     381           6 :         EXPECT_EQ (elektraGetLongDouble (elektra, "longdoublekey"), 1.1L) << "Wrong key value.";
     382             : 
     383             : #endif
     384           2 : }
     385             : 
     386          20 : TEST_F (Highlevel, ArrayGetters)
     387             : {
     388           2 :         setArrays ({
     389             :                 makeArray (KDB_TYPE_STRING, "stringarraykey", { "String 1", "String 2" }),
     390             :                 makeArray (KDB_TYPE_BOOLEAN, "booleanarraykey", { "0", "1" }),
     391             :                 makeArray (KDB_TYPE_CHAR, "chararraykey", { "c", "d" }),
     392             :                 makeArray (KDB_TYPE_OCTET, "octetarraykey", { "1", "2" }),
     393             :                 makeArray (KDB_TYPE_SHORT, "shortarraykey", { "1", "-1" }),
     394             :                 makeArray (KDB_TYPE_UNSIGNED_SHORT, "unsignedshortarraykey", { "1", "2" }),
     395             :                 makeArray (KDB_TYPE_LONG, "longarraykey", { "1", "-1" }),
     396             :                 makeArray (KDB_TYPE_UNSIGNED_LONG, "unsignedlongarraykey", { "1", "2" }),
     397             :                 makeArray (KDB_TYPE_LONG_LONG, "longlongarraykey", { "1", "-1" }),
     398             :                 makeArray (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglongarraykey", { "1", "2" }),
     399             :                 makeArray (KDB_TYPE_FLOAT, "floatarraykey", { "1.1", "-2.1" }),
     400             :                 makeArray (KDB_TYPE_DOUBLE, "doublearraykey", { "1.1", "-2.1" }),
     401             : 
     402             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     403             : 
     404             :                 makeArray (KDB_TYPE_LONG_DOUBLE, "longdoublearraykey", { "1.1", "-2.1" }),
     405             : 
     406             : #endif
     407         186 :         });
     408             : 
     409           2 :         createElektra ();
     410             : 
     411             : 
     412           6 :         EXPECT_EQ (elektraArraySize (elektra, "stringarraykey"), 2) << "Wrong array size";
     413           4 :         EXPECT_STREQ (elektraGetStringArrayElement (elektra, "stringarraykey", 0), "String 1") << "Wrong key value.";
     414           4 :         EXPECT_STREQ (elektraGetStringArrayElement (elektra, "stringarraykey", 1), "String 2") << "Wrong key value.";
     415             : 
     416           6 :         EXPECT_EQ (elektraArraySize (elektra, "booleanarraykey"), 2) << "Wrong array size";
     417           6 :         EXPECT_EQ (elektraGetBooleanArrayElement (elektra, "booleanarraykey", 0), false) << "Wrong key value.";
     418           6 :         EXPECT_EQ (elektraGetBooleanArrayElement (elektra, "booleanarraykey", 1), true) << "Wrong key value.";
     419             : 
     420           6 :         EXPECT_EQ (elektraArraySize (elektra, "chararraykey"), 2) << "Wrong array size";
     421           6 :         EXPECT_EQ (elektraGetCharArrayElement (elektra, "chararraykey", 0), 'c') << "Wrong key value.";
     422           6 :         EXPECT_EQ (elektraGetCharArrayElement (elektra, "chararraykey", 1), 'd') << "Wrong key value.";
     423             : 
     424           6 :         EXPECT_EQ (elektraArraySize (elektra, "octetarraykey"), 2) << "Wrong array size";
     425           6 :         EXPECT_EQ (elektraGetOctetArrayElement (elektra, "octetarraykey", 0), 1) << "Wrong key value.";
     426           6 :         EXPECT_EQ (elektraGetOctetArrayElement (elektra, "octetarraykey", 1), 2) << "Wrong key value.";
     427             : 
     428           6 :         EXPECT_EQ (elektraArraySize (elektra, "shortarraykey"), 2) << "Wrong array size";
     429           6 :         EXPECT_EQ (elektraGetShortArrayElement (elektra, "shortarraykey", 0), 1) << "Wrong key value.";
     430           6 :         EXPECT_EQ (elektraGetShortArrayElement (elektra, "shortarraykey", 1), -1) << "Wrong key value.";
     431             : 
     432           6 :         EXPECT_EQ (elektraArraySize (elektra, "unsignedshortarraykey"), 2) << "Wrong array size";
     433           6 :         EXPECT_EQ (elektraGetUnsignedShortArrayElement (elektra, "unsignedshortarraykey", 0), 1) << "Wrong key value.";
     434           6 :         EXPECT_EQ (elektraGetUnsignedShortArrayElement (elektra, "unsignedshortarraykey", 1), 2) << "Wrong key value.";
     435             : 
     436           6 :         EXPECT_EQ (elektraArraySize (elektra, "longarraykey"), 2) << "Wrong array size";
     437           6 :         EXPECT_EQ (elektraGetLongArrayElement (elektra, "longarraykey", 0), 1) << "Wrong key value.";
     438           6 :         EXPECT_EQ (elektraGetLongArrayElement (elektra, "longarraykey", 1), -1) << "Wrong key value.";
     439             : 
     440           6 :         EXPECT_EQ (elektraArraySize (elektra, "unsignedlongarraykey"), 2) << "Wrong array size";
     441           6 :         EXPECT_EQ (elektraGetUnsignedLongArrayElement (elektra, "unsignedlongarraykey", 0), 1) << "Wrong key value.";
     442           6 :         EXPECT_EQ (elektraGetUnsignedLongArrayElement (elektra, "unsignedlongarraykey", 1), 2) << "Wrong key value.";
     443             : 
     444           6 :         EXPECT_EQ (elektraArraySize (elektra, "longlongarraykey"), 2) << "Wrong array size";
     445           6 :         EXPECT_EQ (elektraGetLongLongArrayElement (elektra, "longlongarraykey", 0), 1) << "Wrong key value.";
     446           6 :         EXPECT_EQ (elektraGetLongLongArrayElement (elektra, "longlongarraykey", 1), -1) << "Wrong key value.";
     447             : 
     448           6 :         EXPECT_EQ (elektraArraySize (elektra, "unsignedlonglongarraykey"), 2) << "Wrong array size";
     449           6 :         EXPECT_EQ (elektraGetUnsignedLongLongArrayElement (elektra, "unsignedlonglongarraykey", 0), 1) << "Wrong key value.";
     450           6 :         EXPECT_EQ (elektraGetUnsignedLongLongArrayElement (elektra, "unsignedlonglongarraykey", 1), 2) << "Wrong key value.";
     451             : 
     452           6 :         EXPECT_EQ (elektraArraySize (elektra, "floatarraykey"), 2) << "Wrong array size";
     453           6 :         EXPECT_EQ (elektraGetFloatArrayElement (elektra, "floatarraykey", 0), 1.1f) << "Wrong key value.";
     454           6 :         EXPECT_EQ (elektraGetFloatArrayElement (elektra, "floatarraykey", 1), -2.1f) << "Wrong key value.";
     455             : 
     456           6 :         EXPECT_EQ (elektraArraySize (elektra, "doublearraykey"), 2) << "Wrong array size";
     457           6 :         EXPECT_EQ (elektraGetDoubleArrayElement (elektra, "doublearraykey", 0), 1.1) << "Wrong key value.";
     458           6 :         EXPECT_EQ (elektraGetDoubleArrayElement (elektra, "doublearraykey", 1), -2.1) << "Wrong key value.";
     459             : 
     460             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     461             : 
     462           6 :         EXPECT_EQ (elektraArraySize (elektra, "longdoublearraykey"), 2) << "Wrong array size";
     463           6 :         EXPECT_EQ (elektraGetLongDoubleArrayElement (elektra, "longdoublearraykey", 0), 1.1L) << "Wrong key value.";
     464           6 :         EXPECT_EQ (elektraGetLongDoubleArrayElement (elektra, "longdoublearraykey", 1), -2.1L) << "Wrong key value.";
     465             : 
     466             : #endif
     467           2 : }
     468             : 
     469          20 : TEST_F (Highlevel, PrimitiveSetters)
     470             : {
     471           2 :         setValues ({
     472             :                 makeKey (KDB_TYPE_STRING, "stringkey", "A string"),
     473             :                 makeKey (KDB_TYPE_BOOLEAN, "booleankey", "1"),
     474             :                 makeKey (KDB_TYPE_CHAR, "charkey", "c"),
     475             :                 makeKey (KDB_TYPE_OCTET, "octetkey", "1"),
     476             :                 makeKey (KDB_TYPE_SHORT, "shortkey", "1"),
     477             :                 makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshortkey", "1"),
     478             :                 makeKey (KDB_TYPE_LONG, "longkey", "1"),
     479             :                 makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlongkey", "1"),
     480             :                 makeKey (KDB_TYPE_LONG_LONG, "longlongkey", "1"),
     481             :                 makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglongkey", "1"),
     482             :                 makeKey (KDB_TYPE_FLOAT, "floatkey", "1.1"),
     483             :                 makeKey (KDB_TYPE_DOUBLE, "doublekey", "1.1"),
     484             : 
     485             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     486             : 
     487             :                 makeKey (KDB_TYPE_LONG_DOUBLE, "longdoublekey", "1.1"),
     488             : 
     489             : #endif
     490          32 :         });
     491             : 
     492           2 :         createElektra ();
     493             : 
     494           2 :         ElektraError * error = nullptr;
     495             : 
     496             :         // Overwrite existing values.
     497           2 :         elektraSetString (elektra, "stringkey", "A string", &error);
     498           2 :         elektraSetBoolean (elektra, "booleankey", 1, &error);
     499           2 :         elektraSetChar (elektra, "charkey", 'c', &error);
     500           2 :         elektraSetOctet (elektra, "octetkey", 1, &error);
     501           2 :         elektraSetShort (elektra, "shortkey", 1, &error);
     502           2 :         elektraSetUnsignedShort (elektra, "unsignedshortkey", 1, &error);
     503           2 :         elektraSetLong (elektra, "longkey", 1, &error);
     504           2 :         elektraSetUnsignedLong (elektra, "unsignedlongkey", 1, &error);
     505           2 :         elektraSetLongLong (elektra, "longlongkey", 1, &error);
     506           2 :         elektraSetUnsignedLongLong (elektra, "unsignedlonglongkey", 1, &error);
     507           2 :         elektraSetFloat (elektra, "floatkey", 1.1f, &error);
     508           2 :         elektraSetDouble (elektra, "doublekey", 1.1, &error);
     509             : 
     510             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     511             : 
     512           2 :         elektraSetLongDouble (elektra, "longdoublekey", 1.1L, &error);
     513             : 
     514             : #endif
     515             : 
     516             :         // Add new keys.
     517           2 :         elektraSetString (elektra, "newstringkey", "A string", &error);
     518           2 :         elektraSetBoolean (elektra, "newbooleankey", 1, &error);
     519           2 :         elektraSetChar (elektra, "newcharkey", 'c', &error);
     520           2 :         elektraSetOctet (elektra, "newoctetkey", 1, &error);
     521           2 :         elektraSetShort (elektra, "newshortkey", 1, &error);
     522           2 :         elektraSetUnsignedShort (elektra, "newunsignedshortkey", 1, &error);
     523           2 :         elektraSetLong (elektra, "newlongkey", 1, &error);
     524           2 :         elektraSetUnsignedLong (elektra, "newunsignedlongkey", 1, &error);
     525           2 :         elektraSetLongLong (elektra, "newlonglongkey", 1, &error);
     526           2 :         elektraSetUnsignedLongLong (elektra, "newunsignedlonglongkey", 1, &error);
     527           2 :         elektraSetFloat (elektra, "newfloatkey", 1.1f, &error);
     528           2 :         elektraSetDouble (elektra, "newdoublekey", 1.1, &error);
     529             : 
     530             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     531             : 
     532           2 :         elektraSetLongDouble (elektra, "newlongdoublekey", 1.1L, &error);
     533             : 
     534             : #endif
     535             : 
     536           6 :         ASSERT_EQ (error, nullptr) << "A setter failed" << &error << std::endl;
     537             : 
     538           2 :         closeElektra ();
     539             : 
     540             :         // Check overwritten values.
     541             : 
     542             :         using namespace kdb;
     543           4 :         KDB kdb;
     544           4 :         KeySet config;
     545             : 
     546           2 :         kdb.get (config, testRoot);
     547          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "stringkey"), "A string") << "Wrong key value.";
     548          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "booleankey"), "1") << "Wrong key value.";
     549          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "charkey"), "c") << "Wrong key value.";
     550          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "octetkey"), "1") << "Wrong key value.";
     551          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "shortkey"), "1") << "Wrong key value.";
     552          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedshortkey"), "1") << "Wrong key value.";
     553          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longkey"), "1") << "Wrong key value.";
     554          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedlongkey"), "1") << "Wrong key value.";
     555          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longlongkey"), "1") << "Wrong key value.";
     556          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedlonglongkey"), "1") << "Wrong key value.";
     557             : 
     558             : 
     559           4 :         std::stringstream ss;
     560           6 :         ss << std::setprecision (9) << 1.1f;
     561          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "floatkey"), ss.str ()) << "Wrong key value.";
     562             : 
     563          10 :         ss.str ("");
     564           6 :         ss << std::setprecision (17) << 1.1;
     565          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "doublekey"), ss.str ()) << "Wrong key value.";
     566             : 
     567             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     568             : 
     569          10 :         ss.str ("");
     570           6 :         ss << std::setprecision (21) << 1.1L;
     571          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longdoublekey"), ss.str ()) << "Wrong key value.";
     572             : 
     573             : #endif
     574             : 
     575             :         // Check new keys.
     576          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newstringkey"), "A string") << "Wrong key value.";
     577          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newbooleankey"), "1") << "Wrong key value.";
     578          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newcharkey"), "c") << "Wrong key value.";
     579          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newoctetkey"), "1") << "Wrong key value.";
     580          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newshortkey"), "1") << "Wrong key value.";
     581          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedshortkey"), "1") << "Wrong key value.";
     582          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlongkey"), "1") << "Wrong key value.";
     583          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedlongkey"), "1") << "Wrong key value.";
     584          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlonglongkey"), "1") << "Wrong key value.";
     585          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedlonglongkey"), "1") << "Wrong key value.";
     586             : 
     587          10 :         ss.str ("");
     588           6 :         ss << std::setprecision (9) << 1.1f;
     589          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newfloatkey"), ss.str ()) << "Wrong key value.";
     590             : 
     591          10 :         ss.str ("");
     592           6 :         ss << std::setprecision (17) << 1.1;
     593          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newdoublekey"), ss.str ()) << "Wrong key value.";
     594             : 
     595             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     596             : 
     597          10 :         ss.str ("");
     598           6 :         ss << std::setprecision (21) << 1.1L;
     599          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlongdoublekey"), ss.str ()) << "Wrong key value.";
     600             : 
     601             : #endif
     602             : }
     603             : 
     604          20 : TEST_F (Highlevel, ArraySetters)
     605             : {
     606           2 :         setArrays ({
     607             :                 makeArray (KDB_TYPE_STRING, "stringarraykey", { "", "" }),
     608             :                 makeArray (KDB_TYPE_BOOLEAN, "booleanarraykey", { "", "" }),
     609             :                 makeArray (KDB_TYPE_CHAR, "chararraykey", { "", "" }),
     610             :                 makeArray (KDB_TYPE_OCTET, "octetarraykey", { "", "" }),
     611             :                 makeArray (KDB_TYPE_SHORT, "shortarraykey", { "", "" }),
     612             :                 makeArray (KDB_TYPE_UNSIGNED_SHORT, "unsignedshortarraykey", { "", "" }),
     613             :                 makeArray (KDB_TYPE_LONG, "longarraykey", { "", "" }),
     614             :                 makeArray (KDB_TYPE_UNSIGNED_LONG, "unsignedlongarraykey", { "", "" }),
     615             :                 makeArray (KDB_TYPE_LONG_LONG, "longlongarraykey", { "", "" }),
     616             :                 makeArray (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglongarraykey", { "", "" }),
     617             :                 makeArray (KDB_TYPE_FLOAT, "floatarraykey", { "", "" }),
     618             :                 makeArray (KDB_TYPE_DOUBLE, "doublearraykey", { "", "" }),
     619             : 
     620             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     621             : 
     622             :                 makeArray (KDB_TYPE_LONG_DOUBLE, "longdoublearraykey", { "", "" }),
     623             : 
     624             : #endif
     625         186 :         });
     626             : 
     627           2 :         createElektra ();
     628             : 
     629           2 :         ElektraError * error = nullptr;
     630             :         // Overwrite existing values.
     631             : 
     632           2 :         elektraSetStringArrayElement (elektra, "stringarraykey", 0, "String 1", &error);
     633           2 :         elektraSetStringArrayElement (elektra, "stringarraykey", 1, "String 2", &error);
     634             : 
     635           2 :         elektraSetBooleanArrayElement (elektra, "booleanarraykey", 0, 0, &error);
     636           2 :         elektraSetBooleanArrayElement (elektra, "booleanarraykey", 1, 1, &error);
     637             : 
     638           2 :         elektraSetCharArrayElement (elektra, "chararraykey", 0, 'c', &error);
     639           2 :         elektraSetCharArrayElement (elektra, "chararraykey", 1, 'd', &error);
     640             : 
     641           2 :         elektraSetOctetArrayElement (elektra, "octetarraykey", 0, 1, &error);
     642           2 :         elektraSetOctetArrayElement (elektra, "octetarraykey", 1, 2, &error);
     643             : 
     644           2 :         elektraSetShortArrayElement (elektra, "shortarraykey", 0, 1, &error);
     645           2 :         elektraSetShortArrayElement (elektra, "shortarraykey", 1, 2, &error);
     646             : 
     647           2 :         elektraSetUnsignedShortArrayElement (elektra, "unsignedshortarraykey", 0, 1, &error);
     648           2 :         elektraSetUnsignedShortArrayElement (elektra, "unsignedshortarraykey", 1, 2, &error);
     649             : 
     650           2 :         elektraSetLongArrayElement (elektra, "longarraykey", 0, 1, &error);
     651           2 :         elektraSetLongArrayElement (elektra, "longarraykey", 1, 2, &error);
     652             : 
     653           2 :         elektraSetUnsignedLongArrayElement (elektra, "unsignedLongarraykey", 0, 1, &error);
     654           2 :         elektraSetUnsignedLongArrayElement (elektra, "unsignedLongarraykey", 1, 2, &error);
     655             : 
     656           2 :         elektraSetLongArrayElement (elektra, "longarraykey", 0, 1, &error);
     657           2 :         elektraSetLongArrayElement (elektra, "longarraykey", 1, 2, &error);
     658             : 
     659           2 :         elektraSetUnsignedLongArrayElement (elektra, "unsignedlongarraykey", 0, 1, &error);
     660           2 :         elektraSetUnsignedLongArrayElement (elektra, "unsignedlongarraykey", 1, 2, &error);
     661             : 
     662           2 :         elektraSetLongLongArrayElement (elektra, "longlongarraykey", 0, 1, &error);
     663           2 :         elektraSetLongLongArrayElement (elektra, "longlongarraykey", 1, 2, &error);
     664             : 
     665           2 :         elektraSetUnsignedLongLongArrayElement (elektra, "unsignedlonglongarraykey", 0, 1, &error);
     666           2 :         elektraSetUnsignedLongLongArrayElement (elektra, "unsignedlonglongarraykey", 1, 2, &error);
     667             : 
     668           2 :         elektraSetFloatArrayElement (elektra, "floatarraykey", 0, 1.1f, &error);
     669           2 :         elektraSetFloatArrayElement (elektra, "floatarraykey", 1, 2.1f, &error);
     670             : 
     671           2 :         elektraSetDoubleArrayElement (elektra, "doublearraykey", 0, 1.1, &error);
     672           2 :         elektraSetDoubleArrayElement (elektra, "doublearraykey", 1, 2.1, &error);
     673             : 
     674             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     675             : 
     676           2 :         elektraSetLongDoubleArrayElement (elektra, "longdoublearraykey", 0, 1.1L, &error);
     677           2 :         elektraSetLongDoubleArrayElement (elektra, "longdoublearraykey", 1, 2.1L, &error);
     678             : 
     679             : #endif
     680             : 
     681             :         // Add new keys.
     682             : 
     683           2 :         elektraSetStringArrayElement (elektra, "newstringarraykey", 0, "String 1", &error);
     684           2 :         elektraSetStringArrayElement (elektra, "newstringarraykey", 1, "String 2", &error);
     685             : 
     686           2 :         elektraSetBooleanArrayElement (elektra, "newbooleanarraykey", 0, 0, &error);
     687           2 :         elektraSetBooleanArrayElement (elektra, "newbooleanarraykey", 1, 1, &error);
     688             : 
     689           2 :         elektraSetCharArrayElement (elektra, "newchararraykey", 0, 'c', &error);
     690           2 :         elektraSetCharArrayElement (elektra, "newchararraykey", 1, 'd', &error);
     691             : 
     692           2 :         elektraSetOctetArrayElement (elektra, "newoctetarraykey", 0, 1, &error);
     693           2 :         elektraSetOctetArrayElement (elektra, "newoctetarraykey", 1, 2, &error);
     694             : 
     695           2 :         elektraSetShortArrayElement (elektra, "newshortarraykey", 0, 1, &error);
     696           2 :         elektraSetShortArrayElement (elektra, "newshortarraykey", 1, 2, &error);
     697             : 
     698           2 :         elektraSetUnsignedShortArrayElement (elektra, "newunsignedshortarraykey", 0, 1, &error);
     699           2 :         elektraSetUnsignedShortArrayElement (elektra, "newunsignedshortarraykey", 1, 2, &error);
     700             : 
     701           2 :         elektraSetLongArrayElement (elektra, "newlongarraykey", 0, 1, &error);
     702           2 :         elektraSetLongArrayElement (elektra, "newlongarraykey", 1, 2, &error);
     703             : 
     704           2 :         elektraSetUnsignedLongArrayElement (elektra, "newunsignedLongarraykey", 0, 1, &error);
     705           2 :         elektraSetUnsignedLongArrayElement (elektra, "newunsignedLongarraykey", 1, 2, &error);
     706             : 
     707           2 :         elektraSetLongArrayElement (elektra, "newlongarraykey", 0, 1, &error);
     708           2 :         elektraSetLongArrayElement (elektra, "newlongarraykey", 1, 2, &error);
     709             : 
     710           2 :         elektraSetUnsignedLongArrayElement (elektra, "newunsignedlongarraykey", 0, 1, &error);
     711           2 :         elektraSetUnsignedLongArrayElement (elektra, "newunsignedlongarraykey", 1, 2, &error);
     712             : 
     713           2 :         elektraSetLongLongArrayElement (elektra, "newlonglongarraykey", 0, 1, &error);
     714           2 :         elektraSetLongLongArrayElement (elektra, "newlonglongarraykey", 1, 2, &error);
     715             : 
     716           2 :         elektraSetUnsignedLongLongArrayElement (elektra, "newunsignedlonglongarraykey", 0, 1, &error);
     717           2 :         elektraSetUnsignedLongLongArrayElement (elektra, "newunsignedlonglongarraykey", 1, 2, &error);
     718             : 
     719           2 :         elektraSetFloatArrayElement (elektra, "newfloatarraykey", 0, 1.1f, &error);
     720           2 :         elektraSetFloatArrayElement (elektra, "newfloatarraykey", 1, 2.1f, &error);
     721             : 
     722           2 :         elektraSetDoubleArrayElement (elektra, "newdoublearraykey", 0, 1.1, &error);
     723           2 :         elektraSetDoubleArrayElement (elektra, "newdoublearraykey", 1, 2.1, &error);
     724             : 
     725             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     726             : 
     727           2 :         elektraSetLongDoubleArrayElement (elektra, "newlongdoublearraykey", 0, 1.1L, &error);
     728           2 :         elektraSetLongDoubleArrayElement (elektra, "newlongdoublearraykey", 1, 2.1L, &error);
     729             : 
     730             : #endif
     731             : 
     732           6 :         ASSERT_EQ (error, nullptr) << "A setter failed" << &error << std::endl;
     733             : 
     734           2 :         closeElektra ();
     735             : 
     736             :         // Check overwritten values.
     737             : 
     738             :         using namespace kdb;
     739           4 :         KDB kdb;
     740           4 :         KeySet config;
     741             : 
     742           2 :         kdb.get (config, testRoot);
     743          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "stringarraykey"), "array", "#1") << "Wrong array size";
     744          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "stringarraykey/#0"), "String 1") << "Wrong key value.";
     745          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "stringarraykey/#1"), "String 2") << "Wrong key value.";
     746             : 
     747          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "booleanarraykey"), "array", "#1") << "Wrong array size";
     748          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "booleanarraykey/#0"), "0") << "Wrong key value.";
     749          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "booleanarraykey/#1"), "1") << "Wrong key value.";
     750             : 
     751          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "chararraykey"), "array", "#1") << "Wrong array size";
     752          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "chararraykey/#0"), "c") << "Wrong key value.";
     753          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "chararraykey/#1"), "d") << "Wrong key value.";
     754             : 
     755          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "octetarraykey"), "array", "#1") << "Wrong array size";
     756          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "octetarraykey/#0"), "1") << "Wrong key value.";
     757          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "octetarraykey/#1"), "2") << "Wrong key value.";
     758             : 
     759          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "shortarraykey"), "array", "#1") << "Wrong array size";
     760          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "shortarraykey/#0"), "1") << "Wrong key value.";
     761          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "shortarraykey/#1"), "2") << "Wrong key value.";
     762             : 
     763          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "unsignedshortarraykey"), "array", "#1") << "Wrong array size";
     764          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedshortarraykey/#0"), "1") << "Wrong key value.";
     765          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedshortarraykey/#1"), "2") << "Wrong key value.";
     766             : 
     767          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "longarraykey"), "array", "#1") << "Wrong array size";
     768          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longarraykey/#0"), "1") << "Wrong key value.";
     769          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longarraykey/#1"), "2") << "Wrong key value.";
     770             : 
     771          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "unsignedlongarraykey"), "array", "#1") << "Wrong array size";
     772          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedlongarraykey/#0"), "1") << "Wrong key value.";
     773          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedlongarraykey/#1"), "2") << "Wrong key value.";
     774             : 
     775          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "longlongarraykey"), "array", "#1") << "Wrong array size";
     776          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longlongarraykey/#0"), "1") << "Wrong key value.";
     777          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longlongarraykey/#1"), "2") << "Wrong key value.";
     778             : 
     779          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "unsignedlonglongarraykey"), "array", "#1") << "Wrong array size";
     780          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedlonglongarraykey/#0"), "1") << "Wrong key value.";
     781          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "unsignedlonglongarraykey/#1"), "2") << "Wrong key value.";
     782             : 
     783          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "floatarraykey"), "array", "#1") << "Wrong array size";
     784           4 :         std::stringstream ss;
     785           6 :         ss << std::setprecision (9) << 1.1f;
     786          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "floatarraykey/#0"), ss.str ()) << "Wrong key value.";
     787          10 :         ss.str ("");
     788           6 :         ss << std::setprecision (9) << 2.1f;
     789          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "floatarraykey/#1"), ss.str ()) << "Wrong key value.";
     790             : 
     791          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "doublearraykey"), "array", "#1") << "Wrong array size";
     792          10 :         ss.str ("");
     793           6 :         ss << std::setprecision (17) << 1.1;
     794          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "doublearraykey/#0"), ss.str ()) << "Wrong key value.";
     795          10 :         ss.str ("");
     796           6 :         ss << std::setprecision (17) << 2.1;
     797          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "doublearraykey/#1"), ss.str ()) << "Wrong key value.";
     798             : 
     799             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     800             : 
     801          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "longdoublearraykey"), "array", "#1") << "Wrong array size";
     802          10 :         ss.str ("");
     803           6 :         ss << std::setprecision (21) << 1.1L;
     804          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longdoublearraykey/#0"), ss.str ()) << "Wrong key value.";
     805          10 :         ss.str ("");
     806           6 :         ss << std::setprecision (21) << 2.1L;
     807          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "longdoublearraykey/#1"), ss.str ()) << "Wrong key value.";
     808             : 
     809             : #endif
     810             :         // Check new keys.
     811             : 
     812          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newstringarraykey"), "array", "#1") << "Wrong array size";
     813          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newstringarraykey/#0"), "String 1") << "Wrong key value.";
     814          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newstringarraykey/#1"), "String 2") << "Wrong key value.";
     815             : 
     816          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newbooleanarraykey"), "array", "#1") << "Wrong array size";
     817          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newbooleanarraykey/#0"), "0") << "Wrong key value.";
     818          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newbooleanarraykey/#1"), "1") << "Wrong key value.";
     819             : 
     820          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newchararraykey"), "array", "#1") << "Wrong array size";
     821          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newchararraykey/#0"), "c") << "Wrong key value.";
     822          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newchararraykey/#1"), "d") << "Wrong key value.";
     823             : 
     824          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newoctetarraykey"), "array", "#1") << "Wrong array size";
     825          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newoctetarraykey/#0"), "1") << "Wrong key value.";
     826          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newoctetarraykey/#1"), "2") << "Wrong key value.";
     827             : 
     828          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newshortarraykey"), "array", "#1") << "Wrong array size";
     829          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newshortarraykey/#0"), "1") << "Wrong key value.";
     830          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newshortarraykey/#1"), "2") << "Wrong key value.";
     831             : 
     832          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newunsignedshortarraykey"), "array", "#1") << "Wrong array size";
     833          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedshortarraykey/#0"), "1") << "Wrong key value.";
     834          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedshortarraykey/#1"), "2") << "Wrong key value.";
     835             : 
     836          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newlonglongarraykey"), "array", "#1") << "Wrong array size";
     837          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlonglongarraykey/#0"), "1") << "Wrong key value.";
     838          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlonglongarraykey/#1"), "2") << "Wrong key value.";
     839             : 
     840          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newunsignedlonglongarraykey"), "array", "#1") << "Wrong array size";
     841          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedlonglongarraykey/#0"), "1") << "Wrong key value.";
     842          10 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newunsignedlonglongarraykey/#1"), "2") << "Wrong key value.";
     843             : 
     844          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newfloatarraykey"), "array", "#1") << "Wrong array size";
     845          10 :         ss.str ("");
     846           6 :         ss << std::setprecision (9) << 1.1f;
     847          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newfloatarraykey/#0"), ss.str ()) << "Wrong key value.";
     848          10 :         ss.str ("");
     849           6 :         ss << std::setprecision (9) << 2.1f;
     850          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newfloatarraykey/#1"), ss.str ()) << "Wrong key value.";
     851             : 
     852          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newdoublearraykey"), "array", "#1") << "Wrong array size";
     853          10 :         ss.str ("");
     854           6 :         ss << std::setprecision (17) << 1.1;
     855          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newdoublearraykey/#0"), ss.str ()) << "Wrong key value.";
     856          10 :         ss.str ("");
     857           6 :         ss << std::setprecision (17) << 2.1;
     858          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newdoublearraykey/#1"), ss.str ()) << "Wrong key value.";
     859             : 
     860             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     861             : 
     862          10 :         EXPECT_KEYMETA (config.lookup (testRoot + "newlongdoublearraykey"), "array", "#1") << "Wrong array size";
     863          10 :         ss.str ("");
     864           6 :         ss << std::setprecision (21) << 1.1L;
     865          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlongdoublearraykey/#0"), ss.str ()) << "Wrong key value.";
     866          10 :         ss.str ("");
     867           6 :         ss << std::setprecision (21) << 2.1L;
     868          12 :         EXPECT_KEYVALUE (config.lookup (testRoot + "newlongdoublearraykey/#1"), ss.str ()) << "Wrong key value.";
     869             : 
     870             : #endif
     871             : }
     872             : 
     873          20 : TEST_F (Highlevel, DefaultValues)
     874             : {
     875             :         ckdb::KeySet * defaults =
     876           2 :                 ksNew (5, ckdb::keyNew ("/stringkey", KEY_VALUE, "A string", KEY_META, "type", KDB_TYPE_STRING, KEY_END), KS_END);
     877             : 
     878           2 :         createElektra (defaults);
     879             : 
     880           2 :         ElektraError * error = nullptr;
     881             : 
     882           4 :         EXPECT_STREQ (elektraGetString (elektra, "stringkey"), "A string") << "Wrong key value.";
     883             : 
     884           2 :         elektraSetString (elektra, "stringkey", "My string", &error);
     885             : 
     886           6 :         EXPECT_EQ (error, nullptr) << "elektraSet* failed" << &error << std::endl;
     887             : 
     888           4 :         EXPECT_STREQ (elektraGetString (elektra, "stringkey"), "My string") << "Wrong key value.";
     889             : 
     890           2 :         createElektra (defaults);
     891             : 
     892           4 :         ASSERT_NE (elektra, nullptr) << "elektraOpen failed" << &error << std::endl;
     893             : 
     894           4 :         EXPECT_STREQ (elektraGetString (elektra, "stringkey"), "My string") << "Wrong key value.";
     895           2 :         ckdb::ksDel (defaults);
     896             : }
     897             : 
     898          20 : TEST_F (Highlevel, Raw)
     899             : {
     900           2 :         createElektra ();
     901             : 
     902           2 :         ElektraError * error = nullptr;
     903             : 
     904           2 :         elektraSetLong (elektra, "longkey", 2, &error);
     905           2 :         elektraSetFloat (elektra, "floatkey", 2.25f, &error);
     906           2 :         elektraSetString (elektra, "stringkey", "abc", &error);
     907           2 :         elektraSetLongArrayElement (elektra, "longarray", 0, 15, &error);
     908           2 :         elektraSetLongArrayElement (elektra, "longarray", 1, 16, &error);
     909           2 :         elektraSetLongArrayElement (elektra, "longarray", 2, 17, &error);
     910           2 :         elektraSetLongArrayElement (elektra, "longarray", 3, 18, &error);
     911             : 
     912           2 :         elektraSetRawString (elektra, "rawshortkey", "2", "short", &error);
     913           2 :         elektraSetRawString (elektra, "rawdoublekey", "2.25", "double", &error);
     914           2 :         elektraSetRawString (elektra, "rawkey", "aaa", "araw", &error);
     915           2 :         elektraSetRawStringArrayElement (elektra, "rawlongarray", 0, "15", "long", &error);
     916           2 :         elektraSetRawStringArrayElement (elektra, "rawlongarray", 1, "16", "long", &error);
     917           2 :         elektraSetRawStringArrayElement (elektra, "rawarray", 4, "aadd", "ttt", &error);
     918             : 
     919           6 :         ASSERT_EQ (error, nullptr) << "elektraSet* failed: " << &error << std::endl;
     920             : 
     921           4 :         EXPECT_STREQ (elektraGetRawString (elektra, "longkey"), "2") << "Wrong key value.";
     922          14 :         EXPECT_STREQ (std::string (elektraGetRawString (elektra, "floatkey")).substr (0, 4).c_str (), "2.25") << "Wrong key value.";
     923           4 :         EXPECT_STREQ (elektraGetRawString (elektra, "stringkey"), "abc") << "Wrong key value.";
     924             : 
     925           4 :         EXPECT_STREQ (elektraGetRawStringArrayElement (elektra, "longarray", 0), "15") << "Wrong key value.";
     926           4 :         EXPECT_STREQ (elektraGetRawStringArrayElement (elektra, "longarray", 1), "16") << "Wrong key value.";
     927           4 :         EXPECT_STREQ (elektraGetRawStringArrayElement (elektra, "longarray", 2), "17") << "Wrong key value.";
     928           4 :         EXPECT_STREQ (elektraGetRawStringArrayElement (elektra, "longarray", 3), "18") << "Wrong key value.";
     929             : 
     930           6 :         EXPECT_EQ (elektraGetShort (elektra, "rawshortkey"), 2) << "Wrong key value.";
     931             : 
     932           6 :         EXPECT_EQ (elektraGetDouble (elektra, "rawdoublekey"), 2.25) << "Wrong key value.";
     933             : 
     934           6 :         EXPECT_EQ (elektraGetLongArrayElement (elektra, "rawlongarray", 0), 15) << "Wrong key value.";
     935           6 :         EXPECT_EQ (elektraGetLongArrayElement (elektra, "rawlongarray", 1), 16) << "Wrong key value.";
     936             : 
     937           4 :         EXPECT_STREQ (elektraGetRawString (elektra, "rawkey"), "aaa") << "Wrong key value.";
     938           4 :         EXPECT_STREQ (elektraGetType (elektra, "rawkey"), "araw") << "Wrong key value.";
     939             : 
     940           4 :         EXPECT_STREQ (elektraGetArrayElementType (elektra, "rawarray", 4), "ttt") << "Wrong key value.";
     941           4 :         EXPECT_STREQ (elektraGetRawStringArrayElement (elektra, "rawarray", 4), "aadd") << "Wrong key value.";
     942             : }
     943             : 
     944          20 : TEST_F (Highlevel, EnforceMetadata)
     945             : {
     946           2 :         createElektra ();
     947             : 
     948           2 :         ElektraError * error = nullptr;
     949             : 
     950           2 :         elektraSetLong (elektra, "testkey", 2, &error);
     951             : 
     952           4 :         EXPECT_NE (elektraFindKey (elektra, "testkey", "long"), nullptr);
     953             : 
     954           4 :         EXPECT_THROW (elektraFindKey (elektra, "testkey", "string"), std::runtime_error);
     955             :         // TODO: check error code once error API is public and stable
     956             : 
     957           4 :         EXPECT_NE (elektraFindKey (elektra, "testkey", nullptr), nullptr);
     958           8 : }

Generated by: LCOV version 1.13