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