Line data Source code
1 : /**
2 : * @file
3 : *
4 : * @brief A plugin that makes use of libaugeas to read and write configuration files
5 : *
6 : * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
7 : *
8 : */
9 :
10 : #ifdef HAVE_KDBCONFIG_H
11 : #include "kdbconfig.h"
12 : #endif
13 :
14 : /* used for asprintf */
15 : #define _GNU_SOURCE
16 :
17 : #ifdef HAVE_STDLIB_H
18 : #include <stdlib.h>
19 : #endif
20 : #ifdef HAVE_STRING_H
21 : #include <string.h>
22 : #endif
23 :
24 : #include <tests_plugin.h>
25 :
26 :
27 : #include <stdio.h>
28 :
29 12 : static Key * createMergingKey (int i)
30 : {
31 : char * name;
32 : char * value;
33 : char * order;
34 24 : if (asprintf (&name, "user/convertkey%d", i) == -1 || asprintf (&value, "meta line %d", i) == -1 ||
35 12 : asprintf (&order, "%i", i) == -1)
36 : {
37 0 : fprintf (stderr, "Unable to create key attributes");
38 0 : exit (EXIT_FAILURE);
39 : }
40 12 : Key * key = keyNew (name, KEY_VALUE, value, KEY_META, "order", order, KEY_END);
41 12 : elektraFree (name);
42 12 : elektraFree (value);
43 12 : elektraFree (order);
44 12 : return key;
45 : }
46 :
47 : // clang-format off
48 4 : static KeySet* createSimpleTestKeys(void)
49 : {
50 : /* the keys to be converted are simply appended to the next
51 : * or the previous key.
52 : */
53 4 : return ksNew (20,
54 : keyNew ("user/normalkey1",
55 : KEY_META, "order", "10", KEY_END),
56 : keyNew ("user/convertkey1",
57 : KEY_VALUE, "testvalue1",
58 : KEY_META, "order", "20",
59 : KEY_META, "convert/metaname", "testmeta",
60 : KEY_META, "convert/append", "next",
61 : KEY_END),
62 : keyNew ("user/normalkey2",
63 : KEY_META, "order", "30",
64 : KEY_END),
65 : keyNew ("user/normalkey3",
66 : KEY_META, "order", "40",
67 : KEY_END),
68 : keyNew ("user/convertkey2",
69 : KEY_VALUE, "testvalue2",
70 : KEY_META, "order", "50",
71 : KEY_META, "convert/metaname", "testmeta",
72 : KEY_META, "convert/append", "previous",
73 : KEY_END),
74 : keyNew ("user/normalkey1/subkey",
75 : KEY_VALUE, "testvalue3",
76 : KEY_META, "order", "60",
77 : KEY_META, "convert/metaname", "testmeta",
78 : KEY_META, "convert/append", "parent",
79 : KEY_END),
80 : KS_END);
81 : }
82 :
83 2 : static KeySet* createMergeTestkeys(void)
84 : {
85 : /* the keys to be converted are merged together
86 : * into a single metadata
87 : */
88 2 : KeySet* ks = ksNew(0, KS_END);
89 8 : for (int i = 1; i <= 3; i++)
90 : {
91 6 : Key* key = createMergingKey (i);
92 6 : keySetMeta (key, "convert/metaname", "testmeta");
93 6 : keySetMeta (key, "convert/append", "next");
94 6 : ksAppendKey (ks, key);
95 : }
96 2 : ksAppendKey (ks,
97 : keyNew ("user/normalkey1", KEY_META, "order", "10", KEY_END));
98 2 : ksAppendKey (ks,
99 : keyNew ("user/normalkey2", KEY_META, "order", "20", KEY_END));
100 8 : for (int i = 30; i <= 32; i++)
101 : {
102 6 : Key* key = createMergingKey (i);
103 6 : keySetMeta (key, "convert/metaname", "testmeta");
104 6 : keySetMeta (key, "convert/append", "previous");
105 6 : ksAppendKey (ks, key);
106 : }
107 2 : return ks;
108 : }
109 :
110 2 : static KeySet* createSkipMergeTestKeys(void)
111 : {
112 : /* the keys to be converted are interweaved with keys
113 : * of the other directio
114 : */
115 2 : return ksNew (20,
116 : keyNew ("user/normalkey1",
117 : KEY_META, "order", "10", KEY_END),
118 : keyNew ("user/convertkey1",
119 : KEY_VALUE, "meta line1",
120 : KEY_META, "order", "20",
121 : KEY_META, "convert/metaname", "testmeta",
122 : KEY_META, "convert/append", "previous",
123 : KEY_END),
124 : keyNew ("user/convertkey2",
125 : KEY_VALUE, "meta line2",
126 : KEY_META, "order", "30",
127 : KEY_META, "convert/metaname", "testmeta",
128 : KEY_META, "convert/append", "next",
129 : KEY_END),
130 : keyNew ("user/convertkey3",
131 : KEY_VALUE, "meta line3",
132 : KEY_META, "order", "40",
133 : KEY_META, "convert/metaname", "testmeta",
134 : KEY_META, "convert/append", "previous",
135 : KEY_END),
136 : keyNew ("user/convertkey4",
137 : KEY_VALUE, "meta line4",
138 : KEY_META, "order", "50",
139 : KEY_META, "convert/metaname", "testmeta",
140 : KEY_META, "convert/append", "next",
141 : KEY_END),
142 : keyNew ("user/normalkey2",
143 : KEY_META, "order", "60",
144 : KEY_END),
145 : KS_END);
146 : }
147 :
148 2 : static KeySet *createParentTestKeys(void)
149 : {
150 :
151 : /* all keys to be converted are appended to the
152 : * parent key of the keyset for any of the possible reasons
153 : */
154 2 : return ksNew (20,
155 : keyNew ("user/parentkey1",
156 : KEY_META, "order", "10", KEY_END),
157 : keyNew ("user/parentkey1/convertkeydirect",
158 : KEY_VALUE, "testvalue1",
159 : KEY_META, "order", "20",
160 : KEY_META, "convert/metaname", "testmeta",
161 : KEY_META, "convert/append", "parent",
162 : KEY_END),
163 : keyNew ("user/parentkey2",
164 : KEY_META, "order", "30", KEY_END),
165 : keyNew ("user/parentkey2/subparent/convertkeyhole",
166 : KEY_VALUE, "testvalue2",
167 : KEY_META, "order", "40",
168 : KEY_META, "convert/metaname", "testmeta",
169 : KEY_META, "convert/append", "parent",
170 : KEY_END),
171 : keyNew ("user/parentkey3",
172 : KEY_META, "order", "50",
173 : KEY_END),
174 : keyNew ("user/normalkey1",
175 : KEY_META, "order", "60",
176 : KEY_END),
177 : keyNew ("user/parentkey3/convertkeyprev",
178 : KEY_VALUE, "testvalue3",
179 : KEY_META, "order", "70",
180 : KEY_META, "convert/metaname", "testmeta",
181 : KEY_META, "convert/append", "previous",
182 : KEY_META, "convert/append/samelevel", "",
183 : KEY_END),
184 : keyNew ("user/parentkey4",
185 : KEY_META, "order", "80",
186 : KEY_END),
187 : keyNew ("user/parentkey4/convertkeynext",
188 : KEY_VALUE, "testvalue4",
189 : KEY_META, "order", "90",
190 : KEY_META, "convert/metaname", "testmeta",
191 : KEY_META, "convert/append", "next",
192 : KEY_META, "convert/append/samelevel", "",
193 : KEY_END),
194 : keyNew ("user/normalkey2",
195 : KEY_META, "order", "100",
196 : KEY_END),
197 : KS_END);
198 : }
199 :
200 2 : static KeySet* createDifferentMetaNameTestKeys(void)
201 : {
202 2 : return ksNew (20,
203 : keyNew ("user/convertkey1",
204 : KEY_VALUE, "meta line1",
205 : KEY_META, "order", "10",
206 : KEY_META, "convert/metaname", "testmeta1",
207 : KEY_META, "convert/append", "next",
208 : KEY_END),
209 : keyNew ("user/convertkey2",
210 : KEY_VALUE, "meta line2",
211 : KEY_META, "order", "20",
212 : KEY_META, "convert/metaname", "testmeta2",
213 : KEY_META, "convert/append", "next",
214 : KEY_END),
215 : keyNew ("user/normalkey1",
216 : KEY_META, "order", "30",
217 : KEY_END),
218 : KS_END);
219 : }
220 :
221 2 : static KeySet* createSameLevelTestKeys(void)
222 : {
223 2 : return ksNew (20,
224 : keyNew ("user/levelkey1",
225 : KEY_META, "order", "10",
226 : KEY_END),
227 : keyNew ("user/levelkey1/convertkey1",
228 : KEY_VALUE, "convertkey1value",
229 : KEY_META, "order","20",
230 : KEY_META, "convert/metaname", "testmeta",
231 : KEY_META, "convert/append", "next",
232 : KEY_META, "convert/append/samelevel", "",
233 : KEY_END),
234 : keyNew ("user/levelkey1/childkey1",
235 : KEY_META, "order", "30",
236 : KEY_END),
237 : keyNew ("user/levelkey1/convertkey2",
238 : KEY_VALUE, "convertkey2value",
239 : KEY_META, "order", "40",
240 : KEY_META, "convert/metaname", "testmeta",
241 : KEY_META, "convert/append", "next",
242 : KEY_META, "convert/append/samelevel", "",
243 : KEY_END),
244 : keyNew ("user/levelkey2",
245 : KEY_META, "order", "50",
246 : KEY_END),
247 : KS_END);
248 : }
249 : // clang-format on
250 :
251 2 : void test_parentAppendMode (void)
252 : {
253 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
254 2 : KeySet * conf = ksNew (0, KS_END);
255 2 : PLUGIN_OPEN ("keytometa");
256 :
257 2 : KeySet * ks = createParentTestKeys ();
258 :
259 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
260 2 : succeed_if (output_error (parentKey), "error in kdbGet");
261 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
262 :
263 : /* parentkey1 must contain meta information generated from convertkeydirect (via parent) */
264 2 : Key * key = ksLookupByName (ks, "user/parentkey1", 0);
265 2 : succeed_if (key, "parentkey1 was removed");
266 :
267 2 : const Key * metaKey1 = keyGetMeta (key, "testmeta");
268 2 : succeed_if (metaKey1, "parentkey1 contained no metakey");
269 2 : succeed_if (!strcmp (keyString (metaKey1), "testvalue1"), "metakey of parentkey1 contained incorrect data");
270 :
271 : /* parentkey2 must contain meta information generated from convertkeyhole (via parent) */
272 2 : key = ksLookupByName (ks, "user/parentkey2", 0);
273 2 : succeed_if (key, "parentkey2 was removed");
274 :
275 2 : const Key * metaKey2 = keyGetMeta (key, "testmeta");
276 2 : succeed_if (metaKey2, "parentkey2 contained no metakey");
277 2 : succeed_if (!strcmp (keyString (metaKey2), "testvalue2"), "metakey of parentkey2 contained incorrect data");
278 :
279 : /* parentkey3 must contain meta information generated from convertkeyprev
280 : * (via previous append samelevel which falls back to parent) */
281 2 : key = ksLookupByName (ks, "user/parentkey3", 0);
282 2 : succeed_if (key, "parentkey3 was removed");
283 :
284 2 : const Key * metaKey3 = keyGetMeta (key, "testmeta");
285 2 : succeed_if (metaKey3, "parentkey3 contained no metakey");
286 2 : succeed_if (!strcmp (keyString (metaKey3), "testvalue3"), "metakey of parentkey3 contained incorrect data");
287 :
288 : /* normalkey1 must not contain metadata */
289 2 : key = ksLookupByName (ks, "user/normalkey1", 0);
290 2 : succeed_if (key, "normalkey1 was removed");
291 2 : succeed_if (!keyGetMeta (key, "testmeta"), "normalkey1 should not contain any metadata");
292 :
293 : /* parentkey4 must contain meta information generated from convertkeynext
294 : * (via next append samelevel which falls back to parent) */
295 2 : key = ksLookupByName (ks, "user/parentkey4", 0);
296 2 : succeed_if (key, "parentkey4 was removed");
297 :
298 2 : const Key * metaKey4 = keyGetMeta (key, "testmeta");
299 2 : succeed_if (metaKey4, "parentkey4 contained no metakey");
300 2 : succeed_if (!strcmp (keyString (metaKey4), "testvalue4"), "metakey of parentkey4 contained incorrect data");
301 :
302 : /* normalkey2 must not contain metadata */
303 2 : key = ksLookupByName (ks, "user/normalkey2", 0);
304 2 : succeed_if (key, "normalkey2 was removed");
305 2 : succeed_if (!keyGetMeta (key, "testmeta"), "normalkey2 should not contain any metadata");
306 :
307 :
308 2 : keyDel (parentKey);
309 2 : ksDel (ks);
310 2 : PLUGIN_CLOSE ();
311 2 : }
312 :
313 :
314 2 : void test_simpleAppendModes (void)
315 : {
316 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
317 2 : KeySet * conf = ksNew (0, KS_END);
318 2 : PLUGIN_OPEN ("keytometa");
319 :
320 :
321 2 : KeySet * ks = createSimpleTestKeys ();
322 :
323 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
324 2 : succeed_if (output_error (parentKey), "error in kdbGet");
325 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
326 :
327 : /* converted keys must be removed from the result */
328 2 : succeed_if (!ksLookupByName (ks, "user/convertkey1", 0), "convertkey1 was not converted");
329 2 : succeed_if (!ksLookupByName (ks, "user/convertkey2", 0), "convertkey2 was not converted");
330 :
331 : /* normalkey2 must contain meta information generated from convertkey1 (via next) */
332 2 : Key * key = ksLookupByName (ks, "user/normalkey2", 0);
333 2 : succeed_if (key, "normalkey2 was removed");
334 :
335 2 : const Key * metaKey1 = keyGetMeta (key, "testmeta");
336 2 : succeed_if (metaKey1, "normalkey2 contained no metakey");
337 2 : succeed_if (!strcmp (keyString (metaKey1), "testvalue1"), "metakey of normalkey2 contained incorrect data");
338 :
339 : /* normalkey3 must contain meta information generated from convertkey2 (via previous) */
340 2 : key = ksLookupByName (ks, "user/normalkey3", 0);
341 2 : succeed_if (key, "normalkey3 was removed");
342 :
343 2 : const Key * metaKey2 = keyGetMeta (key, "testmeta");
344 2 : succeed_if (metaKey2, "normalkey3 contained no metakey");
345 2 : succeed_if (!strcmp (keyString (metaKey2), "testvalue2"), "metakey of normalkey3 contained incorrect data");
346 :
347 : /* normalkey1 must contain meta information generated from subkey (via parent) */
348 2 : key = ksLookupByName (ks, "user/normalkey1", 0);
349 2 : succeed_if (key, "normalkey1 was removed");
350 :
351 2 : const Key * metaKey3 = keyGetMeta (key, "testmeta");
352 2 : succeed_if (metaKey3, "normalkey1 contained no metakey");
353 2 : succeed_if (!strcmp (keyString (metaKey3), "testvalue3"), "metakey of normalkey1 contained incorrect data");
354 :
355 :
356 2 : keyDel (parentKey);
357 2 : ksDel (ks);
358 2 : PLUGIN_CLOSE ();
359 2 : }
360 :
361 :
362 2 : void test_metaMerging (void)
363 : {
364 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
365 2 : KeySet * conf = ksNew (0, KS_END);
366 2 : PLUGIN_OPEN ("keytometa");
367 :
368 2 : KeySet * ks = createMergeTestkeys ();
369 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
370 2 : succeed_if (output_error (parentKey), "error in kdbGet");
371 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
372 :
373 2 : Key * key = ksLookupByName (ks, "user/normalkey1", 0);
374 2 : succeed_if (key, "normalkey1 was removed");
375 :
376 2 : const Key * metaKey1 = keyGetMeta (key, "testmeta");
377 2 : succeed_if (metaKey1, "normalkey1 contained no metakey");
378 2 : const char * expected1 = "meta line 1\nmeta line 2\nmeta line 3";
379 2 : succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey of normalkey1 contained incorrect data");
380 :
381 2 : key = ksLookupByName (ks, "user/normalkey2", 0);
382 2 : succeed_if (key, "normalkey2 was removed");
383 :
384 2 : const Key * metaKey2 = keyGetMeta (key, "testmeta");
385 2 : succeed_if (metaKey2, "normalkey2 contained no metakey");
386 2 : const char * expected2 = "meta line 30\nmeta line 31\nmeta line 32";
387 2 : succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey of normalkey2 contained incorrect data");
388 :
389 : /* change the value of the middle key */
390 2 : keySetMeta (key, "testmeta", "meta line 30\nchanged meta line\nmeta line 32");
391 :
392 2 : succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
393 2 : succeed_if (output_error (parentKey), "error in kdbSet");
394 2 : succeed_if (output_warnings (parentKey), "warnings in kdbSet");
395 :
396 2 : key = ksLookupByName (ks, "user/convertkey30", 0);
397 2 : succeed_if (key, "convertkey30 was not restored");
398 2 : succeed_if (!strcmp (keyString (key), "meta line 30"), "value of convertkey30 was modified");
399 :
400 2 : key = ksLookupByName (ks, "user/convertkey31", 0);
401 2 : succeed_if (key, "convertkey31 was not restored");
402 2 : succeed_if (!strcmp (keyString (key), "changed meta line"), "meta information was not written back to convertkey31");
403 :
404 2 : key = ksLookupByName (ks, "user/convertkey32", 0);
405 2 : succeed_if (key, "convertkey32 was not restored");
406 2 : succeed_if (!strcmp (keyString (key), "meta line 32"), "value of convertkey32 was modified");
407 :
408 2 : keyDel (parentKey);
409 2 : ksDel (ks);
410 2 : PLUGIN_CLOSE ();
411 2 : }
412 :
413 2 : void test_metaSkipMerge (void)
414 : {
415 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
416 2 : KeySet * conf = ksNew (0, KS_END);
417 2 : PLUGIN_OPEN ("keytometa");
418 :
419 2 : KeySet * ks = createSkipMergeTestKeys ();
420 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
421 2 : succeed_if (output_error (parentKey), "error in kdbGet");
422 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
423 :
424 2 : Key * key = ksLookupByName (ks, "user/normalkey1", 0);
425 2 : succeed_if (key, "normalkey1 was removed");
426 :
427 2 : const Key * metaKey1 = keyGetMeta (key, "testmeta");
428 2 : succeed_if (metaKey1, "normalkey1 contained no metakey");
429 2 : const char * expected1 = "meta line1\nmeta line3";
430 2 : succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey of normalkey1 contained incorrect data");
431 :
432 2 : key = ksLookupByName (ks, "user/normalkey2", 0);
433 2 : succeed_if (key, "normalkey2 was removed");
434 :
435 2 : const Key * metaKey2 = keyGetMeta (key, "testmeta");
436 2 : succeed_if (metaKey2, "normalkey2 contained no metakey");
437 2 : const char * expected2 = "meta line2\nmeta line4";
438 2 : succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey of normalkey2 contained incorrect data");
439 :
440 2 : keyDel (parentKey);
441 2 : ksDel (ks);
442 2 : PLUGIN_CLOSE ();
443 2 : }
444 :
445 2 : void test_differentMetaNames (void)
446 : {
447 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
448 2 : KeySet * conf = ksNew (0, KS_END);
449 2 : PLUGIN_OPEN ("keytometa");
450 :
451 2 : KeySet * ks = createDifferentMetaNameTestKeys ();
452 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
453 2 : succeed_if (output_error (parentKey), "error in kdbGet");
454 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
455 :
456 2 : Key * key = ksLookupByName (ks, "user/normalkey1", 0);
457 2 : succeed_if (key, "normalkey1 was removed");
458 :
459 2 : const Key * metaKey1 = keyGetMeta (key, "testmeta1");
460 2 : succeed_if (metaKey1, "normalkey1 contained no meta testmeta1");
461 2 : const char * expected1 = "meta line1";
462 2 : succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey testmeta1 of normalkey1 contained incorrect data");
463 :
464 2 : const Key * metaKey2 = keyGetMeta (key, "testmeta2");
465 2 : succeed_if (metaKey2, "normalkey1 contained no meta testmeta1");
466 2 : const char * expected2 = "meta line2";
467 2 : succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey testmeta1 of normalkey1 contained incorrect data");
468 :
469 2 : keyDel (parentKey);
470 2 : ksDel (ks);
471 2 : PLUGIN_CLOSE ();
472 2 : }
473 :
474 2 : void test_appendSameLevel (void)
475 : {
476 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
477 2 : KeySet * conf = ksNew (0, KS_END);
478 2 : PLUGIN_OPEN ("keytometa");
479 :
480 2 : KeySet * ks = createSameLevelTestKeys ();
481 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
482 2 : succeed_if (output_error (parentKey), "error in kdbGet");
483 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
484 :
485 : /* convertkey1 should be converted to childkey1 as childkey1 is on the same level as requested */
486 2 : Key * childKey = ksLookupByName (ks, "user/levelkey1/childkey1", 0);
487 2 : succeed_if (childKey, "childkey1 was removed");
488 :
489 2 : const Key * metaKey1 = keyGetMeta (childKey, "testmeta");
490 2 : succeed_if (metaKey1, "childkey1 contained no meta testmeta");
491 2 : const char * expected1 = "convertkey1value";
492 2 : succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey testmeta of childkey1 contained incorrect data");
493 :
494 : /* convertkey2 should be converted to levelkey as the next key in order is not on the same level */
495 2 : Key * levelkey1 = ksLookupByName (ks, "user/levelkey1", 0);
496 2 : succeed_if (levelkey1, "levelkey1 was removed");
497 :
498 2 : const Key * metaKey2 = keyGetMeta (levelkey1, "testmeta");
499 2 : succeed_if (metaKey2, "levelkey1 contained no meta testmeta");
500 2 : const char * expected2 = "convertkey2value";
501 2 : succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey testmeta of levelkey1 contained incorrect data");
502 :
503 2 : keyDel (parentKey);
504 2 : ksDel (ks);
505 2 : PLUGIN_CLOSE ();
506 2 : }
507 :
508 2 : void test_restoreOnSet (void)
509 : {
510 2 : Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
511 2 : KeySet * conf = ksNew (0, KS_END);
512 2 : PLUGIN_OPEN ("keytometa");
513 :
514 2 : KeySet * ks = createSimpleTestKeys ();
515 :
516 2 : succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
517 2 : succeed_if (output_error (parentKey), "error in kdbGet");
518 2 : succeed_if (output_warnings (parentKey), "warnings in kdbGet");
519 :
520 2 : Key * key = ksLookupByName (ks, "user/normalkey2", 0);
521 2 : succeed_if (key, "normalkey2 was removed");
522 :
523 : /* change the meta information stored in normalkey2
524 : * (was generated from convertkey1)
525 : */
526 2 : keySetMeta (key, "testmeta", "changedtestvalue");
527 :
528 : /* do not touch the meta information of normalkey3
529 : * (was generated from convertkey2)
530 : */
531 :
532 2 : succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
533 2 : succeed_if (output_error (parentKey), "error in kdbSet");
534 2 : succeed_if (output_warnings (parentKey), "warnings in kdbSet");
535 :
536 2 : key = ksLookupByName (ks, "user/convertkey1", 0);
537 2 : succeed_if (key, "convertkey1 was not restored");
538 2 : succeed_if (!strcmp (keyString (key), "changedtestvalue"), "meta information was not written back to convertkey1");
539 :
540 2 : key = ksLookupByName (ks, "user/convertkey2", 0);
541 2 : succeed_if (key, "convertkey2 was not restored");
542 2 : succeed_if (!strcmp (keyString (key), "testvalue2"), " value of convertkey2 was modified");
543 :
544 2 : key = ksLookupByName (ks, "user/normalkey1/subkey", 0);
545 2 : succeed_if (key, "subkey was not restored");
546 2 : succeed_if (!strcmp (keyString (key), "testvalue3"), " value of subkey was modified");
547 :
548 :
549 2 : keyDel (parentKey);
550 2 : ksDel (ks);
551 2 : PLUGIN_CLOSE ();
552 2 : }
553 :
554 2 : int main (int argc, char ** argv)
555 : {
556 2 : printf ("KEYTOMETA TESTS\n");
557 2 : printf ("==================\n\n");
558 :
559 2 : init (argc, argv);
560 :
561 2 : test_simpleAppendModes ();
562 2 : test_parentAppendMode ();
563 2 : test_metaMerging ();
564 2 : test_metaSkipMerge ();
565 2 : test_differentMetaNames ();
566 2 : test_appendSameLevel ();
567 2 : test_restoreOnSet ();
568 :
569 2 : print_result ("test_keytometa");
570 :
571 2 : return nbError;
572 : }
|