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 : }
|