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.h>
10 :
11 : #include <kdbproposal.h>
12 :
13 2 : static void test_lookupSingle (void)
14 : {
15 2 : printf ("Test lookup single\n");
16 :
17 2 : Key * specKey = keyNew ("user/abc", KEY_META, "override/#0", "user/something", KEY_END);
18 2 : Key * k = 0;
19 2 : KeySet * ks = ksNew (20, k = keyNew ("user/else", KEY_END), KS_END);
20 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
21 2 : keySetMeta (specKey, "fallback/#0", "user/else");
22 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find fallback key");
23 2 : keySetMeta (specKey, "fallback/#0", "");
24 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
25 2 : keySetMeta (specKey, "override/#0", "user/else");
26 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find override key");
27 2 : keySetMeta (specKey, "override/#0", "");
28 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
29 :
30 2 : keyDel (specKey);
31 2 : ksDel (ks);
32 2 : }
33 :
34 2 : static void test_lookupChain (void)
35 : {
36 2 : printf ("Test lookup chain\n");
37 :
38 2 : Key * specKey = keyNew ("user/4", KEY_META, "override/#0", "user/something", KEY_END);
39 2 : Key * k1 = 0;
40 2 : Key * k2 = 0;
41 2 : Key * k3 = 0;
42 2 : Key * k4 = 0;
43 2 : KeySet * ks = ksNew (20, k1 = keyNew ("user/1", KEY_END), k2 = keyNew ("user/2", KEY_END), k3 = keyNew ("user/3", KEY_END),
44 : k4 = keyNew ("user/4", KEY_END), KS_END);
45 :
46 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
47 2 : keySetMeta (specKey, "override/#0", "user/else");
48 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
49 2 : keySetMeta (specKey, "override/#1", "user/wrong");
50 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
51 2 : keySetMeta (specKey, "override/#2", "user/3");
52 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k3, "did not find override key");
53 2 : keySetMeta (specKey, "override/#1", "user/2");
54 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k2, "found wrong key");
55 2 : keySetMeta (specKey, "override/#0", "user/1");
56 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k1, "found wrong key");
57 :
58 2 : keyDel (specKey);
59 2 : ksDel (ks);
60 2 : }
61 :
62 2 : static void test_lookupChainLast (void)
63 : {
64 2 : printf ("Test lookup chain last\n");
65 :
66 2 : Key * k1 = 0;
67 2 : Key * k2 = 0;
68 2 : Key * k3 = 0;
69 2 : Key * k4 = 0;
70 : // clang-format off
71 2 : KeySet *ks= ksNew(20,
72 : k1 = keyNew("spec/key",
73 : KEY_VALUE, "spec value",
74 : KEY_META, "override/#0", "/something",
75 : KEY_META, "override/#1", "/something_else",
76 : KEY_META, "override/#2", "/override",
77 : KEY_END),
78 : k2 = keyNew("user/key", KEY_VALUE, "wrong user value", KEY_END),
79 : k3 = keyNew("dir/key", KEY_VALUE, "wrong dir value", KEY_END),
80 : k4 = keyNew("user/override", KEY_VALUE, "ok", KEY_END),
81 : KS_END);
82 : // clang-format on
83 :
84 2 : Key * found = ksLookupByName (ks, "/key", 0);
85 2 : succeed_if (found == k4, "found wrong key");
86 2 : succeed_if_same_string (keyName (found), "user/override");
87 2 : succeed_if_same_string (keyString (found), "ok");
88 :
89 2 : Key * searchKey = keyNew ("/key", KEY_END);
90 2 : found = ksLookup (ks, searchKey, 0);
91 2 : succeed_if (found == k4, "found wrong key");
92 2 : succeed_if_same_string (keyName (found), "user/override");
93 2 : succeed_if_same_string (keyString (found), "ok");
94 2 : keyDel (searchKey);
95 :
96 2 : ksDel (ks);
97 2 : }
98 :
99 :
100 2 : static void test_lookupChainRealWorld (void)
101 : {
102 2 : printf ("Test lookup chain real world\n");
103 :
104 2 : Key * k1 = 0;
105 2 : Key * k2 = 0;
106 2 : Key * k3 = 0;
107 2 : Key * k4 = 0;
108 : // clang-format off
109 2 : KeySet *ks= ksNew(20,
110 : k1 = keyNew("spec/sw/P/current/editor",
111 : KEY_META, "example", "vim",
112 : KEY_META, "override/#0", "/sw/P/override/editor",
113 : KEY_META, "override/#1", "/sw/override/editor",
114 : KEY_META, "override/#2", "/sw/defaults/editor",
115 : KEY_END),
116 : k2 = keyNew("user/sw/defaults/editor", KEY_VALUE, "ok", KEY_END),
117 : k3 = keyNew("dir/sw/P/current/editor", KEY_VALUE, "wrong dir value", KEY_END),
118 : k4 = keyNew("user/sw/P/current/editor", KEY_VALUE, "wrong user value", KEY_END),
119 : KS_END);
120 : // clang-format on
121 :
122 2 : Key * found = ksLookupByName (ks, "/sw/P/current/editor", 0);
123 2 : succeed_if (found == k2, "found wrong key");
124 2 : succeed_if_same_string (keyName (found), "user/sw/defaults/editor");
125 2 : succeed_if_same_string (keyString (found), "ok");
126 :
127 2 : Key * searchKey = keyNew ("/sw/P/current/editor", KEY_END);
128 2 : found = ksLookup (ks, searchKey, 0);
129 2 : succeed_if (found == k2, "found wrong key");
130 2 : succeed_if_same_string (keyName (found), "user/sw/defaults/editor");
131 2 : succeed_if_same_string (keyString (found), "ok");
132 2 : keyDel (searchKey);
133 :
134 2 : ksDel (ks);
135 2 : }
136 :
137 2 : static void test_lookupNoOverride (void)
138 : {
139 2 : printf ("Test lookup with override not found\n");
140 :
141 : // clang-format off
142 2 : Key *specKey = keyNew("/test/lift/limit",
143 : KEY_CASCADING_NAME,
144 : KEY_META, "default", "1",
145 : KEY_META, "override/#0", "/test/person_lift/limit",
146 : KEY_META, "override/#1", "/test/material_lift/limit",
147 : KEY_META, "override/#2", "/test/heavy_material_lift/limit",
148 : KEY_END);
149 : // clang-format on
150 2 : Key * dup = keyDup (specKey);
151 :
152 2 : Key * k1 = 0;
153 2 : Key * k2 = 0;
154 2 : KeySet * ks = ksNew (20, k1 = keyNew ("user/test/lift/limit", KEY_VALUE, "22", KEY_END),
155 : k2 = keyNew ("/test/person_lift/limit", KEY_CASCADING_NAME, KEY_VALUE, "10", KEY_END), KS_END);
156 :
157 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k1, "found wrong key");
158 2 : succeed_if (ksLookup (ks, dup, KDB_O_SPEC) == k1, "found wrong key");
159 2 : elektraKeySetName (dup, "/test/lift/limit", KEY_CASCADING_NAME);
160 2 : succeed_if (ksLookup (ks, dup, KDB_O_SPEC) == k1, "found wrong key");
161 2 : succeed_if (ksLookup (ks, dup, KDB_O_SPEC | KDB_O_CREATE) == k1, "found wrong key");
162 :
163 2 : keyDel (specKey);
164 2 : ksDel (ks);
165 2 : keyDel (dup);
166 2 : }
167 :
168 2 : static void test_lookupDefault (void)
169 : {
170 2 : printf ("Test lookup default\n");
171 :
172 2 : Key * specKey = keyNew ("user/abc", KEY_END);
173 2 : Key * k = 0;
174 2 : KeySet * ks = ksNew (20, KS_END);
175 :
176 2 : succeed_if (ksGetSize (ks) == 0, "wrong size");
177 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
178 :
179 2 : keySetMeta (specKey, "default", "xyz");
180 :
181 2 : k = ksLookup (ks, specKey, KDB_O_SPEC);
182 2 : succeed_if (k != 0, "found no default key");
183 2 : succeed_if (ksGetSize (ks) == 1, "wrong size");
184 2 : succeed_if_same_string (keyName (k), "/abc");
185 2 : succeed_if_same_string (keyString (k), "xyz");
186 :
187 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
188 2 : succeed_if (ksGetSize (ks) == 1, "wrong size");
189 2 : keySetMeta (specKey, "default", "");
190 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
191 2 : succeed_if (ksGetSize (ks) == 1, "wrong size");
192 :
193 2 : keyDel (specKey);
194 2 : ksDel (ks);
195 2 : }
196 :
197 2 : static void test_lookupNoascading (void)
198 : {
199 2 : printf ("Test lookup without cascading\n");
200 :
201 2 : Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_END);
202 :
203 2 : Key * d = keyDup (specKey);
204 2 : keySetString (d, "dup");
205 2 : succeed_if_same_string (keyName (specKey), "/abc");
206 2 : succeed_if_same_string (keyName (d), "/abc");
207 :
208 2 : succeed_if (!keyCmp (d, specKey), "comparision to duplicate failed");
209 2 : succeed_if_same_string (keyName (d), "/abc");
210 2 : succeed_if_same_string (keyName (specKey), "/abc");
211 :
212 2 : KeySet * ks = ksNew (20, d, KS_END);
213 :
214 2 : Key * k = ksLookup (ks, specKey, KDB_O_NOCASCADING);
215 2 : succeed_if_same_string (keyName (specKey), "/abc");
216 2 : succeed_if (k != 0, "did not find cascading key");
217 2 : succeed_if (k != specKey, "should not be specKey");
218 2 : succeed_if (k == d, "should be dup key");
219 :
220 2 : Key * a = keyNew (keyName (specKey), KEY_CASCADING_NAME, KEY_VALUE, "a", KEY_END);
221 2 : ksAppendKey (ks, a);
222 :
223 12 : for (int i = 0; i < 5; ++i)
224 : {
225 10 : k = ksLookup (ks, specKey, KDB_O_NOCASCADING);
226 10 : succeed_if (keyGetNameSize (specKey) == 5, "size of spec key wrong");
227 10 : succeed_if_same_string (keyName (specKey), "/abc");
228 10 : succeed_if (k != 0, "did not find cascading key");
229 10 : succeed_if (k != specKey, "should not be specKey");
230 10 : succeed_if (k == a, "should be dup key");
231 :
232 : // search without cascading
233 10 : k = ksLookup (ks, specKey, 0);
234 10 : succeed_if (keyGetNameSize (specKey) == 5, "size of spec key wrong");
235 10 : succeed_if_same_string (keyName (specKey), "/abc");
236 10 : succeed_if (k != 0, "did not find cascading key");
237 10 : succeed_if (k != specKey, "should not be specKey");
238 10 : succeed_if (k == a, "should be dup key");
239 : }
240 :
241 2 : ksDel (ks);
242 2 : keyDel (specKey);
243 2 : }
244 :
245 2 : static void test_lookupDefaultCascading (void)
246 : {
247 2 : printf ("Test lookup default with cascading\n");
248 :
249 2 : Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_END);
250 2 : Key * k = 0;
251 2 : KeySet * ks = ksNew (20, KS_END);
252 :
253 2 : succeed_if (ksGetSize (ks) == 0, "wrong size");
254 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
255 :
256 2 : keySetMeta (specKey, "default", "xyz");
257 2 : k = ksLookup (ks, specKey, KDB_O_SPEC);
258 2 : succeed_if (k != 0, "found no default key");
259 2 : succeed_if (ksGetSize (ks) == 1, "wrong size");
260 2 : succeed_if_same_string (keyName (k), "/abc");
261 2 : succeed_if_same_string (keyString (k), "xyz");
262 :
263 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
264 2 : succeed_if (ksGetSize (ks) == 1, "wrong size");
265 2 : keySetMeta (specKey, "default", "");
266 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find default key again");
267 2 : succeed_if (ksGetSize (ks) == 1, "wrong size");
268 :
269 2 : keyDel (specKey);
270 2 : ksDel (ks);
271 2 : }
272 :
273 2 : static void test_lookupLongChain (void)
274 : {
275 2 : printf ("Test lookup long chain\n");
276 :
277 : // clang-format off
278 2 : Key *specKey = keyNew("user/4",
279 : KEY_META, "override/#0", "user/something",
280 : KEY_META, "override/#1", "user/something",
281 : KEY_META, "override/#2", "user/something",
282 : KEY_META, "override/#3", "user/something",
283 : KEY_META, "override/#3", "user/something",
284 : KEY_META, "override/#4", "user/something",
285 : KEY_META, "override/#5", "user/something",
286 : KEY_META, "override/#6", "user/something",
287 : KEY_META, "override/#7", "user/something",
288 : KEY_META, "override/#8", "user/something",
289 : KEY_META, "override/#9", "user/something",
290 : KEY_META, "override/#_10", "user/something",
291 : KEY_META, "override/#_11", "user/something",
292 : KEY_META, "override/#_12", "user/something",
293 : KEY_META, "override/#_13", "user/something",
294 : KEY_META, "override/#_14", "user/something",
295 : KEY_META, "override/#_15", "user/something",
296 : KEY_END);
297 : // clang-format on
298 2 : Key * k1 = 0;
299 2 : Key * k2 = 0;
300 2 : Key * k3 = 0;
301 2 : Key * k4 = 0;
302 2 : KeySet * ks = ksNew (20, k1 = keyNew ("user/1", KEY_END), k2 = keyNew ("user/2", KEY_END), k3 = keyNew ("user/3", KEY_END),
303 : k4 = keyNew ("user/4", KEY_END), KS_END);
304 :
305 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
306 2 : keySetMeta (specKey, "override/#_16", "user/else");
307 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
308 2 : keySetMeta (specKey, "override/#_17", "user/wrong");
309 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k4, "found wrong key");
310 2 : keySetMeta (specKey, "override/#_18", "user/3");
311 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k3, "did not find override key");
312 2 : keySetMeta (specKey, "override/#_10", "user/2");
313 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k2, "found wrong key");
314 2 : keySetMeta (specKey, "override/#5", "user/1");
315 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k1, "found wrong key");
316 :
317 2 : keyDel (specKey);
318 2 : ksDel (ks);
319 2 : }
320 :
321 2 : static void test_lookupCascading (void)
322 : {
323 2 : printf ("Test lookup cascading\n");
324 :
325 2 : Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_META, "override/#0", "/something", KEY_END);
326 2 : Key * k = 0;
327 2 : KeySet * ks = ksNew (20, k = keyNew ("user/else", KEY_END), KS_END);
328 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
329 2 : keySetMeta (specKey, "fallback/#0", "/else");
330 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find fallback key");
331 2 : keySetMeta (specKey, "fallback/#0", "");
332 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
333 2 : keySetMeta (specKey, "override/#0", "/else");
334 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find override key");
335 2 : keySetMeta (specKey, "override/#0", "");
336 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key");
337 2 : elektraKeySetName (specKey, "/else", KEY_CASCADING_NAME);
338 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key itself");
339 :
340 2 : keyDel (specKey);
341 2 : ksDel (ks);
342 2 : }
343 :
344 2 : static void test_lookupNamespace (void)
345 : {
346 2 : printf ("Test lookup namespace\n");
347 :
348 2 : Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_META, "namespace/#0", "system", KEY_END);
349 2 : Key * k = 0;
350 :
351 2 : KeySet * ks = ksNew (20, k = keyNew ("user/abc", KEY_END), KS_END);
352 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key of other namespace");
353 2 : keySetMeta (specKey, "namespace/#0", "user");
354 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key in correct namespace");
355 2 : ksDel (ks);
356 :
357 2 : ks = ksNew (20, k = keyNew ("system/abc", KEY_END), KS_END);
358 2 : keySetMeta (specKey, "namespace/#0", "user");
359 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key of other namespace");
360 2 : keySetMeta (specKey, "namespace/#0", "system");
361 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key in correct namespace");
362 2 : ksDel (ks);
363 :
364 :
365 2 : ks = ksNew (20, keyNew ("system/abc", KEY_END), k = keyNew ("user/abc", KEY_END), KS_END);
366 2 : keySetMeta (specKey, "namespace/#0", "user");
367 2 : keySetMeta (specKey, "namespace/#1", "system");
368 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "found wrong key of other namespace");
369 2 : ksDel (ks);
370 :
371 :
372 2 : ks = ksNew (20, k = keyNew ("system/abc", KEY_END), keyNew ("user/abc", KEY_END), KS_END);
373 2 : keySetMeta (specKey, "namespace/#0", "system");
374 2 : keySetMeta (specKey, "namespace/#1", "user");
375 2 : succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "found wrong key of other namespace");
376 2 : ksDel (ks);
377 :
378 2 : keyDel (specKey);
379 2 : }
380 :
381 2 : static void test_lookupIndirect (void)
382 : {
383 2 : printf ("Test lookup by indirect spec\n");
384 :
385 : Key * s;
386 : Key * p;
387 : Key * d;
388 : Key * u;
389 : Key * y;
390 : Key * e;
391 2 : KeySet * ks =
392 : ksNew (20, s = keyNew ("spec/abc", KEY_END), p = keyNew ("proc/abc", KEY_END), d = keyNew ("dir/abc", KEY_END),
393 : u = keyNew ("user/abc", KEY_END), y = keyNew ("system/abc", KEY_END), e = keyNew ("system/else", KEY_END), KS_END);
394 2 : succeed_if (ksGetSize (ks) == 6, "wrong size");
395 :
396 2 : Key * k = ksLookupByName (ks, "/abc", 0);
397 2 : succeed_if (k == p, "did not find proc key");
398 :
399 2 : keySetMeta (s, "namespace/#0", "no");
400 2 : keySetMeta (s, "default", "80");
401 2 : k = ksLookupByName (ks, "/abc", 0);
402 2 : succeed_if (k != 0, "should find default");
403 2 : succeed_if (ksGetSize (ks) == 7, "default key not added");
404 2 : succeed_if_same_string (keyString (k), "80");
405 :
406 2 : Key * k2 = ksLookupByName (ks, "/abc", 0);
407 2 : succeed_if (k == k2, "did not get same default");
408 :
409 2 : keySetMeta (s, "fallback/#0", "/else");
410 2 : k = ksLookupByName (ks, "/abc", 0);
411 2 : succeed_if (k == e, "did not find else");
412 :
413 2 : keySetMeta (s, "namespace/#0", "system");
414 2 : k = ksLookupByName (ks, "/abc", 0);
415 2 : succeed_if (k == y, "did not find system key");
416 :
417 2 : keySetMeta (s, "namespace/#0", "system");
418 2 : keySetMeta (s, "namespace/#1", "user");
419 2 : k = ksLookupByName (ks, "/abc", 0);
420 2 : succeed_if (k == y, "did not find system key");
421 :
422 2 : keySetMeta (s, "namespace/#0", "proc");
423 2 : keySetMeta (s, "namespace/#1", "user");
424 2 : k = ksLookupByName (ks, "/abc", 0);
425 2 : succeed_if (k == p, "did not find proc key");
426 :
427 2 : keySetMeta (s, "override/#0", "/else");
428 2 : k = ksLookupByName (ks, "/abc", 0);
429 2 : succeed_if (k == e, "did not find override key");
430 :
431 2 : ksDel (ks);
432 2 : }
433 :
434 2 : static void test_lookupDoubleIndirect (void)
435 : {
436 2 : printf ("Test lookup by double indirect spec\n");
437 :
438 : Key * s;
439 : Key * p;
440 : Key * d;
441 : Key * u;
442 : Key * y;
443 : Key * se;
444 : Key * pe;
445 2 : KeySet * ks = ksNew (20, se = keyNew ("spec/first", KEY_END), pe = keyNew ("proc/first", KEY_END), s = keyNew ("spec/abc", KEY_END),
446 : p = keyNew ("proc/abc", KEY_END), d = keyNew ("dir/abc", KEY_END), u = keyNew ("user/abc", KEY_END),
447 : y = keyNew ("system/abc", KEY_END), KS_END);
448 2 : succeed_if (ksGetSize (ks) == 7, "wrong size");
449 :
450 2 : Key * k = ksLookupByName (ks, "/first", 0);
451 2 : succeed_if (k == pe, "did not find proc key");
452 :
453 2 : keySetMeta (se, "override/#0", "/abc");
454 2 : k = ksLookupByName (ks, "/first", 0);
455 2 : succeed_if (k == p, "did not find proc/abc");
456 :
457 2 : keySetMeta (s, "namespace/#0", "system");
458 2 : k = ksLookupByName (ks, "/first", 0);
459 2 : succeed_if (k == y, "did not find system key");
460 :
461 2 : keySetMeta (s, "namespace/#0", "system");
462 2 : keySetMeta (s, "namespace/#1", "user");
463 2 : k = ksLookupByName (ks, "/first", 0);
464 2 : succeed_if (k == y, "did not find system key");
465 :
466 2 : keySetMeta (s, "namespace/#0", "proc");
467 2 : keySetMeta (s, "namespace/#1", "user");
468 2 : k = ksLookupByName (ks, "/first", 0);
469 2 : succeed_if (k == p, "did not find proc key");
470 :
471 2 : keySetMeta (s, "override/#0", "proc/first");
472 2 : k = ksLookupByName (ks, "/first", 0);
473 2 : succeed_if (k == pe, "did not find override key (double indirect)");
474 :
475 2 : ksDel (ks);
476 2 : }
477 :
478 2 : static void test_lookupDoubleIndirectDefault (void)
479 : {
480 2 : printf ("Test lookup by double indirect spec with default\n");
481 :
482 : Key * s;
483 : Key * p;
484 : Key * u;
485 : Key * y;
486 : Key * se;
487 : Key * pe;
488 2 : KeySet * ks =
489 : ksNew (20, se = keyNew ("spec/first", KEY_END), pe = keyNew ("proc/first", KEY_END), s = keyNew ("spec/abc", KEY_END),
490 : p = keyNew ("proc/abc", KEY_END), u = keyNew ("user/abc", KEY_END), y = keyNew ("system/abc", KEY_END), KS_END);
491 2 : succeed_if (ksGetSize (ks) == 6, "wrong size");
492 2 : keySetMeta (se, "default", "default is ok");
493 2 : keySetMeta (s, "default", "default is NOT ok");
494 :
495 2 : Key * k = ksLookupByName (ks, "/first", 0);
496 2 : succeed_if (k == pe, "did not find proc key");
497 :
498 2 : keySetMeta (se, "namespace/#0", "system");
499 2 : k = ksLookupByName (ks, "/first", 0);
500 2 : succeed_if_same_string (keyString (k), "default is ok");
501 :
502 2 : keySetMeta (se, "override/#0", "/abc");
503 2 : k = ksLookupByName (ks, "/first", 0);
504 2 : succeed_if (k == p, "did not find proc/abc");
505 :
506 2 : keySetMeta (s, "namespace/#0", "system");
507 2 : k = ksLookupByName (ks, "/first", 0);
508 2 : succeed_if (k == y, "did not find system key");
509 :
510 2 : keySetMeta (s, "namespace/#0", "system");
511 2 : keySetMeta (s, "namespace/#1", "user");
512 2 : k = ksLookupByName (ks, "/first", 0);
513 2 : succeed_if (k == y, "did not find system key");
514 :
515 2 : keySetMeta (s, "namespace/#0", "proc");
516 2 : keySetMeta (s, "namespace/#1", "user");
517 2 : k = ksLookupByName (ks, "/first", 0);
518 2 : succeed_if (k == p, "did not find proc key");
519 :
520 2 : keySetMeta (s, "namespace/#0", "dir");
521 2 : keySetMeta (s, "namespace/#1", 0);
522 2 : k = ksLookupByName (ks, "/first", 0);
523 2 : succeed_if_same_string (keyString (k), "default is ok");
524 :
525 2 : keySetMeta (s, "override/#0", "proc/first");
526 2 : k = ksLookupByName (ks, "/first", 0);
527 2 : succeed_if (k == pe, "did not find override key (double indirect)");
528 :
529 2 : keySetMeta (s, "override/#0", "dir/first");
530 2 : k = ksLookupByName (ks, "/first", 0);
531 2 : succeed_if_same_string (keyString (k), "default is ok");
532 :
533 2 : ksDel (ks);
534 2 : }
535 :
536 :
537 2 : int main (int argc, char ** argv)
538 : {
539 2 : printf ("SPEC TESTS\n");
540 2 : printf ("==========================\n\n");
541 :
542 2 : init (argc, argv);
543 :
544 2 : test_lookupSingle ();
545 2 : test_lookupChain ();
546 2 : test_lookupChainLast ();
547 2 : test_lookupChainRealWorld ();
548 2 : test_lookupNoOverride ();
549 2 : test_lookupDefault ();
550 2 : test_lookupNoascading ();
551 2 : test_lookupDefaultCascading ();
552 2 : test_lookupLongChain ();
553 2 : test_lookupCascading ();
554 2 : test_lookupNamespace ();
555 2 : test_lookupIndirect ();
556 2 : test_lookupDoubleIndirect ();
557 2 : test_lookupDoubleIndirectDefault ();
558 :
559 2 : printf ("\n%s RESULTS: %d test(s) done. %d error(s).\n", argv[0], nbTest, nbError);
560 :
561 2 : return nbError;
562 : }
|