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 <kdbproposal.h>
10 : #include <tests_internal.h>
11 :
12 2 : static void test_ro (void)
13 : {
14 : Key * key;
15 :
16 2 : key = keyNew (0);
17 2 : key->flags |= KEY_FLAG_RO_VALUE;
18 :
19 2 : succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
20 2 : succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
21 :
22 2 : key->flags |= KEY_FLAG_RO_NAME;
23 2 : succeed_if (keySetName (key, "user") == -1, "read only name, not allowed to set");
24 :
25 2 : key->flags |= KEY_FLAG_RO_META;
26 2 : succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
27 :
28 2 : keyDel (key);
29 2 : }
30 :
31 2 : static void test_uid (void)
32 : {
33 : Key * key;
34 :
35 2 : key = keyNew ("user/uid", KEY_UID, 100, KEY_END);
36 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "100");
37 2 : succeed_if (keyGetUID (key) == 100, "uid was not set correctly");
38 :
39 2 : succeed_if (keySetUID (key, 101) == 0, "could not set uid");
40 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "101");
41 2 : succeed_if (keyGetUID (key) == 101, "uid was not set correctly");
42 :
43 2 : succeed_if (keySetUID (key, 0) == 0, "could not set uid");
44 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "0");
45 2 : succeed_if (keyGetUID (key) == 0, "uid was not set correctly");
46 :
47 2 : succeed_if (keySetUID (key, (uid_t) -1) == 0, "could not set uid");
48 2 : warn_if_fail (!strcmp (keyValue (keyGetMeta (key, "uid")), "-1"),
49 : "this is for 64bit, other platforms might have other results here");
50 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
51 :
52 2 : succeed_if (keySetMeta (key, "uid", "102") == sizeof ("102"), "could not set meta");
53 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "102");
54 2 : succeed_if (keyGetUID (key) == 102, "uid was not set correctly");
55 :
56 2 : succeed_if (keySetMeta (key, "uid", "x") == sizeof ("x"), "could not set meta");
57 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "x");
58 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
59 :
60 2 : succeed_if (keySetMeta (key, "uid", "x1") == sizeof ("x1"), "could not set meta");
61 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "x1");
62 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
63 :
64 2 : succeed_if (keySetMeta (key, "uid", "2000000") == sizeof ("2000000"), "could not set large uid");
65 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "2000000");
66 2 : succeed_if (keyGetUID (key) == 2000000, "large uid was not set correctly");
67 :
68 2 : succeed_if (keySetMeta (key, "uid", "1x") == sizeof ("1x"), "could not set meta");
69 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "1x");
70 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
71 :
72 2 : succeed_if (keySetMeta (key, "uid", "50x") == sizeof ("50x"), "could not set meta");
73 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "uid")), "50x");
74 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid was not set correctly");
75 :
76 2 : keyDel (key);
77 :
78 2 : key = keyNew ("user/uid", KEY_END);
79 2 : succeed_if (keyValue (keyGetMeta (key, "uid")) == 0, "got value, but uid was not set up to now");
80 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "got value, but uid was not set up to now");
81 :
82 2 : keyDel (key);
83 2 : }
84 :
85 :
86 2 : static void test_comment (void)
87 : {
88 : Key * key;
89 : char ret[10];
90 :
91 2 : succeed_if (key = keyNew (0), "could not create new key");
92 2 : succeed_if_same_string (keyComment (key), "");
93 2 : succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
94 2 : succeed_if (keyValue (keyGetMeta (key, "comment")) == 0, "No comment up to now");
95 :
96 2 : succeed_if (keySetComment (key, 0) == 1, "could not remove comment");
97 2 : succeed_if (keyValue (keyGetMeta (key, "comment")) == 0, "There should be an no comment");
98 2 : succeed_if_same_string (keyComment (key), "");
99 2 : succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
100 2 : succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get empty comment");
101 2 : succeed_if (keyGetComment (key, ret, 1) == 1, "Could not get empty comment");
102 2 : succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
103 :
104 2 : succeed_if (keySetComment (key, "") == 1, "could not remove comment");
105 2 : succeed_if (keyValue (keyGetMeta (key, "comment")) == 0, "There should be an no comment");
106 2 : succeed_if_same_string (keyComment (key), "");
107 2 : succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
108 2 : succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get empty comment");
109 2 : succeed_if (keyGetComment (key, ret, 1) == 1, "Could not get empty comment");
110 2 : succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
111 :
112 2 : succeed_if (keySetComment (key, "mycom") == sizeof ("mycom"), "could not set comment");
113 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "comment")), "mycom");
114 2 : succeed_if_same_string (keyComment (key), "mycom");
115 2 : succeed_if (keyGetCommentSize (key) == sizeof ("mycom"), "My comment size problem");
116 2 : succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get my comment");
117 2 : succeed_if (keyGetComment (key, ret, 1) == -1, "Could not get my comment");
118 2 : succeed_if (keyGetComment (key, ret, sizeof ("mycom")) == sizeof ("mycom"), "Could not get my comment");
119 2 : succeed_if_same_string (ret, "mycom");
120 2 : succeed_if (keyDel (key) == 0, "could not delete key");
121 2 : }
122 :
123 2 : static void test_owner (void)
124 : {
125 : Key * key;
126 :
127 2 : succeed_if (key = keyNew (0), "could not create new key");
128 2 : succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key");
129 2 : succeed_if_same_string (keyOwner (key), "");
130 2 : succeed_if (keyDel (key) == 0, "could not delete key");
131 :
132 2 : succeed_if (key = keyNew ("system/key", KEY_END), "could not create new key");
133 2 : succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key");
134 2 : succeed_if_same_string (keyOwner (key), "");
135 2 : succeed_if (keyDel (key) == 0, "could not delete key");
136 :
137 2 : succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key");
138 2 : succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key");
139 2 : succeed_if_same_string (keyOwner (key), "");
140 2 : succeed_if (keyDel (key) == 0, "could not delete key");
141 :
142 2 : succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key");
143 2 : succeed_if (keySetOwner (key, "markus") == sizeof ("markus"), "could not set owner markus");
144 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "markus");
145 2 : succeed_if_same_string (keyOwner (key), "markus");
146 2 : succeed_if (keyDel (key) == 0, "could not delete key");
147 :
148 :
149 2 : succeed_if (key = keyNew ("user:markus/key", KEY_END), "could not create new key");
150 2 : succeed_if (keySetOwner (key, "markus") == sizeof ("markus"), "could not set owner markus");
151 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "markus");
152 2 : succeed_if_same_string (keyOwner (key), "markus");
153 2 : succeed_if (keyDel (key) == 0, "could not delete key");
154 :
155 2 : setenv ("USER", "markus", 1);
156 2 : succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key with env");
157 2 : succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner set for empty key with env");
158 2 : succeed_if_same_string (keyOwner (key), "");
159 2 : succeed_if (keyDel (key) == 0, "could not delete key with env");
160 :
161 2 : succeed_if (key = keyNew ("user/key", KEY_END), "could not create new key with env");
162 2 : succeed_if (keySetMeta (key, "owner", "myowner") == 8, "owner set for empty key with env");
163 2 : succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "myowner");
164 2 : succeed_if (keyDel (key) == 0, "could not delete key with env");
165 2 : }
166 :
167 2 : static void test_mode (void)
168 : {
169 : Key * key;
170 :
171 2 : key = keyNew ("user/mode", KEY_MODE, 0100, KEY_END);
172 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "100");
173 2 : succeed_if (keyGetMode (key) == 0100, "mode was not set correctly");
174 :
175 2 : succeed_if (keySetMode (key, 0101) == 0, "could not set mode");
176 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "101");
177 2 : succeed_if (keyGetMode (key) == 0101, "mode was not set correctly");
178 :
179 2 : succeed_if (keySetMode (key, 0) == 0, "could not set mode");
180 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0");
181 2 : succeed_if (keyGetMode (key) == 0, "mode was not set correctly");
182 :
183 2 : succeed_if (keySetMeta (key, "mode", "102") == sizeof ("102"), "could not set meta");
184 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "102");
185 2 : succeed_if (keyGetMode (key) == 0102, "mode was not set correctly");
186 :
187 2 : succeed_if (keySetMeta (key, "mode", "0103") == sizeof ("0103"), "could not set meta");
188 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0103");
189 2 : succeed_if (keyGetMode (key) == 0103, "mode was not set correctly with leading octal 0");
190 :
191 2 : succeed_if (keySetMeta (key, "mode", "x") == sizeof ("x"), "could not set meta");
192 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "x");
193 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
194 :
195 2 : succeed_if (keySetMeta (key, "mode", "x1") == sizeof ("x1"), "could not set meta");
196 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "x1");
197 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
198 :
199 : #if SIZEOF_MODE_T > 2
200 2 : succeed_if (keySetMeta (key, "mode", "2000000") == sizeof ("2000000"), "could not set large mode");
201 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "2000000");
202 2 : succeed_if (keyGetMode (key) == 02000000, "large mode was not set correctly");
203 : #endif
204 :
205 2 : succeed_if (keySetMeta (key, "mode", "1x") == sizeof ("1x"), "could not set meta");
206 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "1x");
207 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
208 :
209 2 : succeed_if (keySetMeta (key, "mode", "50x") == sizeof ("50x"), "could not set meta");
210 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "50x");
211 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "mode was not set correctly");
212 :
213 2 : keyDel (key);
214 :
215 2 : key = keyNew ("user/mode", KEY_END);
216 2 : succeed_if (keyValue (keyGetMeta (key, "mode")) == 0, "got value, but mode was not set up to now");
217 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "KDB_FILE_MODE not default on new key");
218 :
219 2 : succeed_if (keySetMeta (key, "mode", "") == sizeof (""), "could not set large mode");
220 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "");
221 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "empty mode should also yield default");
222 :
223 2 : keyDel (key);
224 2 : }
225 :
226 2 : static void test_metaKeySet (void)
227 : {
228 2 : Key * key = keyNew ("user/test", KEY_END);
229 2 : keySetMeta (key, "meta/test1", "value1");
230 2 : keySetMeta (key, "meta/test2", "value2");
231 2 : keySetMeta (key, "meta/test3", "value3");
232 :
233 2 : KeySet * metaKeys = elektraKeyGetMetaKeySet (key);
234 :
235 : /* test whether the metakeyset contains all keys */
236 2 : Key * metaKey = ksLookupByName (metaKeys, "meta/test1", KDB_O_NONE);
237 2 : exit_if_fail (metaKey, "the first metakey was not found in the metakeyset");
238 2 : succeed_if (!strcmp (keyString (metaKey), "value1"), "the first metakey in the metakeyset has a wrong value");
239 :
240 2 : metaKey = ksLookupByName (metaKeys, "meta/test2", KDB_O_NONE);
241 2 : exit_if_fail (metaKey, "the second metakey was not found in the metakeyset");
242 2 : succeed_if (!strcmp (keyString (metaKey), "value2"), "the second metakey in the metakeyset has a wrong value");
243 :
244 2 : metaKey = ksLookupByName (metaKeys, "meta/test3", KDB_O_NONE);
245 2 : exit_if_fail (metaKey, "the third metakey was not found in the metakeyset");
246 2 : succeed_if (!strcmp (keyString (metaKey), "value3"), "the third metakey in the metakeyset has a wrong value");
247 :
248 : /* test whether the metakeyset is affected by deletions */
249 2 : ksPop (metaKeys);
250 :
251 2 : const Key * deletedKey = keyGetMeta (key, "meta/test3");
252 2 : exit_if_fail (deletedKey, "key deleted from the metakeyset is not present on the original key anymore");
253 2 : succeed_if (!strcmp (keyString (deletedKey), "value3"), "key deleted from the metakeyset has a wrong value afterwards");
254 :
255 2 : ksDel (metaKeys);
256 2 : metaKeys = elektraKeyGetMetaKeySet (key);
257 2 : ksRewind (metaKeys);
258 2 : metaKey = ksNext (metaKeys);
259 2 : keySetString (metaKey, "newvalue");
260 :
261 2 : const Key * modifiedKey = keyGetMeta (key, "meta/test1");
262 2 : succeed_if (!strcmp (keyString (modifiedKey), "value1"),
263 : "metakey has incorrect value after a key from the metakeyset was modified");
264 :
265 2 : ksDel (metaKeys);
266 2 : keyDel (key);
267 2 : }
268 :
269 2 : static void test_metaArrayToKS (void)
270 : {
271 2 : Key * test = keyNew ("/a", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END);
272 2 : KeySet * ks = elektraMetaArrayToKS (test, "dep");
273 : Key * cur;
274 2 : cur = ksNext (ks);
275 2 : succeed_if (!strcmp (keyName (cur), "dep"), "failed!");
276 2 : cur = ksNext (ks);
277 2 : succeed_if (!strcmp (keyName (cur), "dep/#0"), "failed!");
278 2 : cur = ksNext (ks);
279 2 : succeed_if (!strcmp (keyName (cur), "dep/#1"), "failed!");
280 2 : keyDel (test);
281 2 : ksDel (ks);
282 2 : }
283 8 : static void checkTopArray (Key ** array, unsigned int size)
284 : {
285 : unsigned int i;
286 8 : KeySet * done = ksNew (size, KS_END);
287 50 : for (i = 0; i < size; ++i)
288 : {
289 42 : Key * cur = array[i];
290 42 : KeySet * deps = elektraMetaArrayToKS (cur, "dep");
291 : Key * dep;
292 42 : ksRewind (deps);
293 42 : ksNext (deps);
294 42 : ksRewind (done);
295 128 : while ((dep = ksNext (deps)) != NULL)
296 : {
297 44 : if (!strcmp (keyName (cur), keyString (dep))) continue;
298 40 : Key * ret = ksLookupByName (done, keyString (dep), KDB_O_NONE);
299 40 : succeed_if (ret != NULL, "Failed, dependency not resolved correctly\n");
300 : }
301 42 : ksDel (deps);
302 42 : ksAppendKey (done, cur);
303 : }
304 8 : ksDel (done);
305 8 : }
306 :
307 : #define succeed_if_top(i, s) \
308 : { \
309 : if (strcmp (keyName (array[i]), s)) \
310 : { \
311 : fprintf (stderr, "Failed, %s should be on position %d\n", s, i); \
312 : succeed_if (0, ""); \
313 : } \
314 : else \
315 : succeed_if (1, ""); \
316 : }
317 :
318 :
319 2 : static void checkTopOrder1 (Key ** array)
320 : {
321 2 : succeed_if_top (0, "/d");
322 2 : succeed_if_top (1, "/c");
323 2 : succeed_if_top (2, "/b");
324 2 : succeed_if_top (3, "/a");
325 2 : }
326 :
327 2 : static void checkTopOrder2 (Key ** array)
328 : {
329 2 : succeed_if_top (0, "/d");
330 2 : succeed_if_top (1, "/c");
331 2 : succeed_if_top (2, "/b");
332 2 : succeed_if_top (3, "/a");
333 2 : }
334 :
335 2 : static void checkTopOrder3 (Key ** array)
336 : {
337 2 : succeed_if_top (0, "/b");
338 2 : succeed_if_top (1, "/d");
339 2 : succeed_if_top (2, "/c");
340 2 : succeed_if_top (3, "/a");
341 2 : }
342 2 : static void test_top (void)
343 : {
344 2 : KeySet * test0 = ksNew (10, keyNew ("/a", KEY_VALUE, "whatever", KEY_END), KS_END);
345 2 : KeySet * test1 = ksNew (
346 : 10, keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
347 : keyNew ("/b", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
348 : keyNew ("/c", KEY_VALUE, "-", KEY_END),
349 : keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_END), KS_END);
350 2 : KeySet * test2 = ksNew (
351 : 10, keyNew ("/a", KEY_VALUE, "b, d", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/d", KEY_END),
352 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
353 : keyNew ("/c", KEY_VALUE, "-", KEY_END),
354 : keyNew ("/d", KEY_VALUE, "c, e", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/c", KEY_META, "dep/#1", "/e", KEY_END),
355 : keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
356 : keyNew ("/f", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
357 : keyNew ("/g", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
358 : keyNew ("/h", KEY_VALUE, "-", KEY_END), KS_END);
359 2 : KeySet * test3 = ksNew (
360 : 10, keyNew ("/5", KEY_VALUE, "11", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/11", KEY_END),
361 : keyNew ("/7", KEY_VALUE, "8, 11", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/8", KEY_META, "dep/#1", "/11", KEY_END),
362 : keyNew ("/3", KEY_VALUE, "8, 10", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/8", KEY_META, "dep/#1", "/10", KEY_END),
363 : keyNew ("/11", KEY_VALUE, "2, 9, 10", KEY_META, "dep", "#2", KEY_META, "dep/#0", "/2", KEY_META, "dep/#1", "/9", KEY_META,
364 : "dep/#2", "/10", KEY_END),
365 : keyNew ("/8", KEY_VALUE, "9", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/9", KEY_END),
366 : keyNew ("/2", KEY_VALUE, "-", KEY_END), keyNew ("/9", KEY_VALUE, "-", KEY_END), keyNew ("/10", KEY_VALUE, "-", KEY_END),
367 : KS_END);
368 2 : Key ** array = elektraMalloc (ksGetSize (test1) * sizeof (Key *));
369 2 : memset (array, 0, ksGetSize (test1) * sizeof (Key *));
370 2 : elektraSortTopology (test1, array);
371 :
372 2 : checkTopArray (array, ksGetSize (test1));
373 :
374 2 : elektraRealloc ((void **) &array, ksGetSize (test2) * sizeof (Key *));
375 2 : memset (array, 0, ksGetSize (test2) * sizeof (Key *));
376 2 : elektraSortTopology (test2, array);
377 :
378 2 : checkTopArray (array, ksGetSize (test2));
379 :
380 2 : elektraRealloc ((void **) &array, ksGetSize (test3) * sizeof (Key *));
381 2 : memset (array, 0, ksGetSize (test3) * sizeof (Key *));
382 2 : elektraSortTopology (test3, array);
383 :
384 2 : checkTopArray (array, ksGetSize (test3));
385 :
386 2 : elektraRealloc ((void **) &array, ksGetSize (test0) * sizeof (Key *));
387 2 : memset (array, 0, ksGetSize (test0) * sizeof (Key *));
388 2 : elektraSortTopology (test0, array);
389 :
390 2 : checkTopArray (array, ksGetSize (test0));
391 :
392 2 : KeySet * testCycle = ksNew (10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_END),
393 : keyNew ("/b", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_END), KS_END);
394 2 : KeySet * testCycle2 = ksNew (
395 : 10, keyNew ("/a", KEY_VALUE, "b, d", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/d", KEY_END),
396 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
397 : keyNew ("/c", KEY_VALUE, "-", KEY_END),
398 : keyNew ("/d", KEY_VALUE, "c, e", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/c", KEY_META, "dep/#1", "/e", KEY_END),
399 : keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
400 : keyNew ("/f", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
401 : keyNew ("/g", KEY_VALUE, "h", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/h", KEY_END),
402 : keyNew ("/h", KEY_VALUE, "e", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/e", KEY_END), KS_END);
403 :
404 2 : KeySet * testCycle3 = ksNew (10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_END),
405 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
406 : keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_END),
407 : keyNew ("/d", KEY_VALUE, "e", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/e", KEY_END),
408 : keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
409 : keyNew ("/f", KEY_VALUE, "g", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/g", KEY_END),
410 : keyNew ("/g", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_END), KS_END);
411 2 : KeySet * testCycle4 =
412 2 : ksNew (10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_END),
413 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
414 : keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_END),
415 : keyNew ("/d", KEY_VALUE, "e", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/e", KEY_META, "dep/#1", "/g", KEY_END),
416 : keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_END),
417 : keyNew ("/f", KEY_VALUE, "g", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/g", KEY_END),
418 : keyNew ("/g", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_END), KS_END);
419 :
420 :
421 2 : elektraRealloc ((void **) &array, ksGetSize (testCycle) * sizeof (Key *));
422 2 : succeed_if (elektraSortTopology (testCycle, array) == 0, "Cycle detection failed\n");
423 :
424 2 : elektraRealloc ((void **) &array, ksGetSize (testCycle2) * sizeof (Key *));
425 2 : succeed_if (elektraSortTopology (testCycle2, array) == 0, "Cycle detection failed\n");
426 :
427 2 : elektraRealloc ((void **) &array, ksGetSize (testCycle3) * sizeof (Key *));
428 2 : succeed_if (elektraSortTopology (testCycle3, array) == 0, "Cycle detection failed\n");
429 :
430 2 : elektraRealloc ((void **) &array, ksGetSize (testCycle4) * sizeof (Key *));
431 2 : succeed_if (elektraSortTopology (testCycle4, array) == 0, "Cycle detection failed\n");
432 :
433 2 : KeySet * orderTest1 = ksNew (
434 : 10, keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
435 : keyNew ("/b", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
436 : keyNew ("/c", KEY_VALUE, "-", KEY_META, "order", "#1", KEY_END),
437 : keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#0", KEY_END), KS_END);
438 2 : elektraRealloc ((void **) &array, ksGetSize (orderTest1) * sizeof (Key *));
439 2 : memset (array, 0, ksGetSize (orderTest1) * sizeof (Key *));
440 2 : elektraSortTopology (orderTest1, array);
441 2 : checkTopOrder1 (array);
442 :
443 :
444 2 : KeySet * orderTest2 = ksNew (
445 : 10, keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END),
446 : keyNew ("/b", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_META,
447 : "order", "#0", KEY_END),
448 : keyNew ("/c", KEY_VALUE, "-", KEY_META, "order", "#3", KEY_END),
449 : keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#1", KEY_END), KS_END);
450 2 : memset (array, 0, ksGetSize (orderTest2) * sizeof (Key *));
451 2 : elektraSortTopology (orderTest2, array);
452 2 : checkTopOrder2 (array);
453 :
454 :
455 2 : KeySet * orderTest3 = ksNew (
456 : 10,
457 : keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/a", KEY_META, "dep/#1", "/b", KEY_META, "order",
458 : "#2", KEY_END),
459 : keyNew ("/b", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "#0", KEY_END),
460 : keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#1", KEY_END),
461 : keyNew ("/d", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#5", KEY_END), KS_END);
462 2 : memset (array, 0, ksGetSize (orderTest3) * sizeof (Key *));
463 2 : elektraSortTopology (orderTest3, array);
464 2 : checkTopOrder3 (array);
465 :
466 :
467 2 : KeySet * testCycleOrder1 = ksNew (
468 : 10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "1", KEY_END),
469 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_END),
470 : keyNew ("/c", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_META, "order", "#0", KEY_END), KS_END);
471 :
472 2 : KeySet * testCycleOrder2 = ksNew (
473 : 10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "#2", KEY_END),
474 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_META, "order", "#0", KEY_END),
475 : keyNew ("/c", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_META, "order", "#1", KEY_END), KS_END);
476 :
477 2 : KeySet * testCycleOrder3 = ksNew (
478 : 10, keyNew ("/a", KEY_VALUE, "b", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/b", KEY_META, "order", "#2", KEY_END),
479 : keyNew ("/b", KEY_VALUE, "c", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/c", KEY_META, "order", "#0", KEY_END),
480 : keyNew ("/c", KEY_VALUE, "d", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/d", KEY_META, "order", "#1", KEY_END),
481 : keyNew ("/d", KEY_VALUE, "e", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/e", KEY_META, "order", "#3", KEY_END),
482 : keyNew ("/e", KEY_VALUE, "f", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/f", KEY_META, "order", "#5", KEY_END),
483 : keyNew ("/f", KEY_VALUE, "g", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/g", KEY_META, "order", "#4", KEY_END),
484 : keyNew ("/g", KEY_VALUE, "a", KEY_META, "dep", "#0", KEY_META, "dep/#0", "/a", KEY_META, "order", "#6", KEY_END), KS_END);
485 :
486 2 : elektraRealloc ((void **) &array, ksGetSize (testCycleOrder1) * sizeof (Key *));
487 2 : succeed_if (elektraSortTopology (testCycleOrder1, array) == 0, "Cycle detection failed\n");
488 :
489 2 : elektraRealloc ((void **) &array, ksGetSize (testCycleOrder2) * sizeof (Key *));
490 2 : succeed_if (elektraSortTopology (testCycleOrder2, array) == 0, "Cycle detection failed\n");
491 :
492 2 : elektraRealloc ((void **) &array, ksGetSize (testCycleOrder3) * sizeof (Key *));
493 2 : succeed_if (elektraSortTopology (testCycleOrder3, array) == 0, "Cycle detection failed\n");
494 :
495 2 : ksDel (test0);
496 2 : ksDel (test1);
497 2 : ksDel (test2);
498 2 : ksDel (test3);
499 2 : ksDel (testCycle);
500 2 : ksDel (testCycle2);
501 2 : ksDel (testCycle3);
502 2 : ksDel (testCycle4);
503 2 : ksDel (orderTest1);
504 2 : ksDel (orderTest2);
505 2 : ksDel (orderTest3);
506 2 : ksDel (testCycleOrder1);
507 2 : ksDel (testCycleOrder2);
508 2 : ksDel (testCycleOrder3);
509 2 : elektraFree (array);
510 2 : }
511 2 : int main (int argc, char ** argv)
512 : {
513 2 : printf ("KEY META TESTS\n");
514 2 : printf ("==================\n\n");
515 :
516 2 : init (argc, argv);
517 2 : test_ro ();
518 :
519 2 : test_uid ();
520 2 : test_comment ();
521 2 : test_owner ();
522 2 : test_mode ();
523 2 : test_metaKeySet ();
524 :
525 2 : test_metaArrayToKS ();
526 2 : test_top ();
527 2 : printf ("\ntest_meta RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
528 :
529 2 : return nbError;
530 : }
|