Line data Source code
1 : /**
2 : * @file
3 : *
4 : * @brief
5 : *
6 : * @copyright BSD License (see doc/LICENSE.md or https://www.libelektra.org)
7 : */
8 :
9 : #include "spec.h"
10 :
11 : #include <tests_plugin.h>
12 :
13 : #define PARENT_KEY "/tests/spec"
14 :
15 : #define TEST_BEGIN \
16 : { \
17 : KeySet * conf = ksDup (_conf); \
18 : PLUGIN_OPEN ("spec"); \
19 : Key * parentKey = keyNew (PARENT_KEY, KEY_END); \
20 : bool success = 1;
21 :
22 : #define TEST_END \
23 : success = 1; \
24 : keyDel (parentKey); \
25 : PLUGIN_CLOSE (); \
26 : }
27 :
28 : #define TEST_CHECK(expression, message) \
29 : success = (expression); \
30 : succeed_if (success, message);
31 :
32 : #define TEST_ON_FAIL(block) \
33 : do \
34 : { \
35 : if (!success) \
36 : { \
37 : block; \
38 : } \
39 : } while (0)
40 :
41 2 : static void test_default (void)
42 : {
43 2 : printf ("test default\n");
44 :
45 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
46 2 : TEST_BEGIN
47 : {
48 2 : KeySet * ks =
49 2 : ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "default", "17", KEY_META, "othermeta", "", KEY_END), KS_END);
50 :
51 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
52 2 : TEST_ON_FAIL (output_error (parentKey));
53 :
54 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
55 :
56 2 : succeed_if (lookup != NULL, ".../a not found");
57 2 : succeed_if_same_string (keyString (lookup), "17");
58 2 : succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
59 :
60 2 : ksDel (ks);
61 : }
62 2 : TEST_END
63 :
64 2 : TEST_BEGIN
65 : {
66 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "default", "17", KEY_META, "othermeta", "", KEY_END),
67 : keyNew ("user" PARENT_KEY "/a", KEY_VALUE, "19", KEY_META, "default", "19", KEY_END), KS_END);
68 :
69 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet should fail");
70 :
71 2 : ksDel (ks);
72 : }
73 2 : TEST_END
74 2 : ksDel (_conf);
75 2 : }
76 :
77 2 : static void test_assign_condition (void)
78 : {
79 2 : printf ("test assign/condition\n");
80 :
81 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
82 :
83 2 : TEST_BEGIN
84 : {
85 2 : KeySet * ks =
86 2 : ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "assign/condition", "17", KEY_META, "othermeta", "", KEY_END),
87 : KS_END);
88 :
89 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
90 2 : TEST_ON_FAIL (output_error (parentKey));
91 :
92 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
93 :
94 2 : succeed_if (lookup != NULL, ".../a not found");
95 2 : succeed_if_same_string (keyString (lookup), "");
96 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "assign/condition")), "17");
97 2 : succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
98 :
99 2 : ksDel (ks);
100 : }
101 2 : TEST_END
102 2 : ksDel (_conf);
103 2 : }
104 :
105 2 : static void test_wildcard (void)
106 : {
107 2 : printf ("test wildcard (_)\n");
108 :
109 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
110 :
111 2 : TEST_BEGIN
112 : {
113 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/_", KEY_META, "default", "17", KEY_META, "othermeta", "", KEY_END),
114 : keyNew ("user" PARENT_KEY "/a/x", KEY_END), KS_END);
115 :
116 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
117 2 : TEST_ON_FAIL (output_error (parentKey));
118 :
119 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a/x", 0);
120 :
121 2 : succeed_if (lookup != NULL, ".../a/x not found");
122 : // succeed_if_same_string (keyString (lookup), "17"); // TODO: wildcard defaults, not possible right now
123 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "17");
124 2 : succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
125 :
126 2 : ksDel (ks);
127 : }
128 2 : TEST_END
129 :
130 2 : TEST_BEGIN
131 : {
132 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/_", KEY_META, "require/count", "2", KEY_END),
133 : keyNew ("user" PARENT_KEY "/a/x", KEY_END), keyNew ("user" PARENT_KEY "/a/y", KEY_END), KS_END);
134 :
135 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
136 2 : TEST_ON_FAIL (output_error (parentKey));
137 :
138 2 : ksDel (ks);
139 : }
140 2 : TEST_END
141 :
142 2 : ksDel (_conf);
143 2 : }
144 :
145 2 : static void test_require (void)
146 : {
147 2 : printf ("test require\n");
148 :
149 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
150 :
151 2 : TEST_BEGIN
152 : {
153 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "require", "", KEY_END), KS_END);
154 :
155 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
156 :
157 2 : ksDel (ks);
158 : }
159 2 : TEST_END
160 :
161 2 : TEST_BEGIN
162 : {
163 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "require", "", KEY_END),
164 : keyNew ("user" PARENT_KEY "/a", KEY_END), KS_END);
165 :
166 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
167 2 : TEST_ON_FAIL (output_error (parentKey));
168 :
169 2 : ksDel (ks);
170 : }
171 2 : TEST_END
172 2 : ksDel (_conf);
173 2 : }
174 :
175 2 : static void test_array (void)
176 : {
177 2 : printf ("test array\n");
178 :
179 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
180 :
181 2 : TEST_BEGIN
182 : {
183 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#", KEY_META, "default", "7", KEY_META, "type", "long", KEY_END),
184 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#5", KEY_END), KS_END);
185 :
186 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
187 2 : TEST_ON_FAIL (output_error (parentKey));
188 :
189 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
190 2 : succeed_if (lookup != NULL, ".../a not found");
191 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#5");
192 2 : succeed_if (keyGetMeta (lookup, "type") == NULL, "parent shouldn't have copied metadata");
193 :
194 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0", 0);
195 2 : succeed_if (lookup != NULL, ".../a/#0 not found");
196 2 : succeed_if_same_string (keyString (lookup), "7");
197 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
198 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
199 :
200 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#1", 0);
201 2 : succeed_if (lookup != NULL, ".../a/#1 not found");
202 2 : succeed_if_same_string (keyString (lookup), "7");
203 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
204 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
205 :
206 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#2", 0);
207 2 : succeed_if (lookup != NULL, ".../a/#2 not found");
208 2 : succeed_if_same_string (keyString (lookup), "7");
209 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
210 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
211 :
212 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#3", 0);
213 2 : succeed_if (lookup != NULL, ".../a/#3 not found");
214 2 : succeed_if_same_string (keyString (lookup), "7");
215 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
216 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
217 :
218 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#4", 0);
219 2 : succeed_if (lookup != NULL, ".../a/#4 not found");
220 2 : succeed_if_same_string (keyString (lookup), "7");
221 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
222 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
223 :
224 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#5", 0);
225 2 : succeed_if (lookup != NULL, ".../a/#5 not found");
226 2 : succeed_if_same_string (keyString (lookup), "7");
227 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
228 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "type")), "long");
229 :
230 2 : ksDel (ks);
231 : }
232 2 : TEST_END
233 :
234 2 : TEST_BEGIN
235 : {
236 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
237 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
238 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
239 :
240 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
241 2 : TEST_ON_FAIL (output_error (parentKey));
242 :
243 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
244 2 : succeed_if (lookup != NULL, ".../a not found");
245 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#0");
246 :
247 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
248 2 : succeed_if (lookup != NULL, ".../a/#0/b not found");
249 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#2");
250 :
251 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#0", 0);
252 2 : succeed_if (lookup != NULL, ".../a/#0/b/#0 not found");
253 2 : succeed_if_same_string (keyString (lookup), "7");
254 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
255 :
256 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#1", 0);
257 2 : succeed_if (lookup != NULL, ".../a/#0/b/#1 not found");
258 2 : succeed_if_same_string (keyString (lookup), "7");
259 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
260 :
261 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#2", 0);
262 2 : succeed_if (lookup != NULL, ".../a/#0/b/#2 not found");
263 2 : succeed_if_same_string (keyString (lookup), "7");
264 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
265 :
266 2 : ksDel (ks);
267 : }
268 2 : TEST_END
269 :
270 2 : TEST_BEGIN
271 : {
272 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
273 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
274 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
275 :
276 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
277 2 : TEST_ON_FAIL (output_error (parentKey));
278 :
279 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
280 2 : succeed_if (lookup != NULL, ".../a not found");
281 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#0");
282 :
283 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
284 2 : succeed_if (lookup != NULL, ".../a/#0/b not found");
285 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#2");
286 :
287 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#0", 0);
288 2 : succeed_if (lookup != NULL, ".../a/#0/b/#0 not found");
289 2 : succeed_if_same_string (keyString (lookup), "7");
290 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
291 :
292 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#1", 0);
293 2 : succeed_if (lookup != NULL, ".../a/#0/b/#1 not found");
294 2 : succeed_if_same_string (keyString (lookup), "7");
295 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
296 :
297 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#2", 0);
298 2 : succeed_if (lookup != NULL, ".../a/#0/b/#2 not found");
299 2 : succeed_if_same_string (keyString (lookup), "7");
300 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
301 :
302 2 : ksDel (ks);
303 : }
304 2 : TEST_END
305 :
306 2 : TEST_BEGIN
307 : {
308 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
309 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#3", KEY_END),
310 : keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
311 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
312 :
313 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
314 2 : TEST_ON_FAIL (output_error (parentKey));
315 :
316 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
317 2 : succeed_if (lookup != NULL, ".../a not found");
318 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#0");
319 :
320 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
321 2 : succeed_if (lookup != NULL, ".../a/#0/b not found");
322 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "array")), "#2");
323 :
324 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#0", 0);
325 2 : succeed_if (lookup != NULL, ".../a/#0/b/#0 not found");
326 2 : succeed_if_same_string (keyString (lookup), "7");
327 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
328 :
329 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#1", 0);
330 2 : succeed_if (lookup != NULL, ".../a/#0/b/#1 not found");
331 2 : succeed_if_same_string (keyString (lookup), "7");
332 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
333 :
334 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/#2", 0);
335 2 : succeed_if (lookup != NULL, ".../a/#0/b/#2 not found");
336 2 : succeed_if_same_string (keyString (lookup), "7");
337 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "7");
338 :
339 2 : ksDel (ks);
340 : }
341 2 : TEST_END
342 :
343 2 : TEST_BEGIN
344 : {
345 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
346 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array/min", "#3", KEY_END),
347 : keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
348 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END), KS_END);
349 :
350 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
351 :
352 2 : ksDel (ks);
353 : }
354 2 : TEST_END
355 :
356 2 : TEST_BEGIN
357 : {
358 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "default", "7", KEY_END),
359 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#3", KEY_END),
360 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#2", KEY_END),
361 : keyNew ("user" PARENT_KEY "/a/#0/b/c", KEY_END), KS_END);
362 :
363 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
364 :
365 2 : ksDel (ks);
366 : }
367 2 : TEST_END
368 2 : ksDel (_conf);
369 2 : }
370 :
371 2 : static void test_require_array (void)
372 : {
373 2 : printf ("test require array\n");
374 :
375 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
376 :
377 2 : TEST_BEGIN
378 : {
379 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "require", "", KEY_END),
380 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
381 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#0", KEY_END), KS_END);
382 :
383 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
384 :
385 2 : ksDel (ks);
386 : }
387 2 : TEST_END
388 :
389 2 : TEST_BEGIN
390 : {
391 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "require", "", KEY_END),
392 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
393 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#0", KEY_END),
394 : keyNew ("user" PARENT_KEY "/a/#0/b/#0", KEY_END), KS_END);
395 :
396 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
397 2 : TEST_ON_FAIL (output_error (parentKey));
398 :
399 2 : ksDel (ks);
400 : }
401 2 : TEST_END
402 :
403 2 : TEST_BEGIN
404 : {
405 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b/#", KEY_META, "require", "", KEY_END),
406 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
407 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "array", "#1", KEY_END),
408 : keyNew ("user" PARENT_KEY "/a/#0/b/#0", KEY_END), KS_END);
409 :
410 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
411 :
412 2 : ksDel (ks);
413 : }
414 2 : TEST_END
415 2 : ksDel (_conf);
416 2 : }
417 :
418 2 : static void test_array_member (void)
419 : {
420 2 : printf ("test array member\n");
421 :
422 2 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
423 :
424 2 : TEST_BEGIN
425 : {
426 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
427 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END), KS_END);
428 :
429 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
430 2 : TEST_ON_FAIL (output_error (parentKey));
431 :
432 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
433 2 : succeed_if (lookup != NULL, ".../a/#0/b not found");
434 2 : succeed_if_same_string (keyString (lookup), "x");
435 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "x");
436 :
437 2 : ksDel (ks);
438 : }
439 2 : TEST_END
440 :
441 2 : TEST_BEGIN
442 : {
443 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#", KEY_META, "default", "", KEY_END),
444 : keyNew ("user" PARENT_KEY "/a/x", KEY_END), KS_END);
445 :
446 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
447 :
448 2 : ksDel (ks);
449 : }
450 2 : TEST_END
451 :
452 2 : TEST_BEGIN
453 : {
454 2 : KeySet * ks = ksNew (10, keyNew ("user" PARENT_KEY "/a/x", KEY_VALUE, "y", KEY_END),
455 : keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
456 : keyNew ("spec" PARENT_KEY "/a/#", KEY_META, "default", "x", KEY_END), KS_END);
457 :
458 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
459 :
460 2 : ksDel (ks);
461 : }
462 2 : TEST_END
463 :
464 2 : TEST_BEGIN
465 : {
466 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
467 : keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END), KS_END);
468 :
469 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
470 2 : TEST_ON_FAIL (output_error (parentKey));
471 :
472 2 : ksDel (ks);
473 : }
474 2 : TEST_END
475 :
476 2 : TEST_BEGIN
477 : {
478 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
479 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
480 : keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END),
481 : keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
482 : keyNew ("user" PARENT_KEY "/a/#0/b/c", KEY_VALUE, "z", KEY_END), KS_END);
483 :
484 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
485 2 : TEST_ON_FAIL (output_error (parentKey));
486 :
487 2 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b", 0);
488 2 : succeed_if (lookup != NULL, ".../a/#0/b not found");
489 2 : succeed_if_same_string (keyString (lookup), "x");
490 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "x");
491 :
492 2 : lookup = ksLookupByName (ks, PARENT_KEY "/a/#0/b/c", 0);
493 2 : succeed_if (lookup != NULL, ".../a/#0/b/c not found");
494 2 : succeed_if_same_string (keyString (lookup), "z");
495 2 : succeed_if_same_string (keyString (keyGetMeta (lookup, "default")), "y");
496 :
497 2 : ksDel (ks);
498 : }
499 2 : TEST_END
500 :
501 2 : TEST_BEGIN
502 : {
503 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
504 : keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END),
505 : keyNew ("user" PARENT_KEY "/a/x/b/c", KEY_VALUE, "z", KEY_END), KS_END);
506 :
507 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
508 :
509 2 : ksDel (ks);
510 : }
511 2 : TEST_END
512 :
513 2 : TEST_BEGIN
514 : {
515 2 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
516 : keyNew ("spec" PARENT_KEY "/a/#/b", KEY_META, "default", "x", KEY_END),
517 : keyNew ("spec" PARENT_KEY "/a/#/b/c", KEY_META, "default", "y", KEY_END),
518 : keyNew ("user" PARENT_KEY "/a", KEY_META, "array", "#0", KEY_END),
519 : keyNew ("user" PARENT_KEY "/a/#0/b/c", KEY_VALUE, "z", KEY_END),
520 : keyNew ("user" PARENT_KEY "/a/x/b/c", KEY_VALUE, "z", KEY_END), KS_END);
521 :
522 2 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbGet shouldn't succeed");
523 :
524 2 : ksDel (ks);
525 : }
526 2 : TEST_END
527 2 : ksDel (_conf);
528 2 : }
529 :
530 : /* TODO: find way to remove metadata safely after other plugins ran
531 : static void test_remove_meta (void)
532 : {
533 : printf ("test remove meta\n");
534 :
535 : KeySet * _conf = ksNew (1, keyNew ("user/conflict/get", KEY_VALUE, "ERROR", KEY_END), KS_END);
536 :
537 : TEST_BEGIN
538 : {
539 : KeySet * ks = ksNew (10, keyNew ("spec" PARENT_KEY "/a", KEY_META, "othermeta", "", KEY_END),
540 : keyNew ("user" PARENT_KEY "/a", KEY_END), KS_END);
541 :
542 : TEST_CHECK (plugin->kdbGet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbGet failed");
543 : TEST_ON_FAIL (output_error (parentKey));
544 :
545 : Key * lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
546 :
547 : succeed_if (lookup != NULL, ".../a not found");
548 : succeed_if (keyGetMeta (lookup, "othermeta") != NULL, "metadata missing");
549 :
550 : TEST_CHECK (plugin->kdbSet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_SUCCESS, "kdbSet failed");
551 : TEST_ON_FAIL (output_error (parentKey));
552 :
553 : lookup = ksLookupByName (ks, PARENT_KEY "/a", 0);
554 :
555 : succeed_if (lookup != NULL, ".../a not found");
556 : succeed_if (keyGetMeta (lookup, "othermeta") == NULL, "metadata not removed");
557 :
558 : ksDel (ks);
559 : }
560 : TEST_END
561 : ksDel (_conf);
562 : }
563 : */
564 :
565 2 : int main (int argc, char ** argv)
566 : {
567 2 : printf ("SPEC TESTS\n");
568 2 : printf ("==================\n\n");
569 :
570 2 : init (argc, argv);
571 :
572 2 : test_default ();
573 2 : test_assign_condition ();
574 2 : test_wildcard ();
575 2 : test_require ();
576 2 : test_array ();
577 2 : test_require_array ();
578 2 : test_array_member ();
579 : // test_remove_meta ();
580 :
581 2 : print_result ("testmod_spec");
582 :
583 2 : return nbError;
584 : }
|