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_internal.h>
10 :
11 : #ifdef HAVE_TIME_H
12 : #include <time.h>
13 : #endif
14 :
15 2 : static void test_keyRefcounter (void)
16 : {
17 2 : Key * key = keyNew (0);
18 2 : key->ksReference = 5;
19 2 : succeed_if (key->ksReference == 5, "wrong ref");
20 2 : succeed_if (keyGetRef (key) == 5, "wrong ref");
21 12 : while (keyGetRef (key) > 0)
22 10 : keyDecRef (key);
23 2 : succeed_if (key->ksReference == 0, "wrong ref after dec");
24 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
25 2 : succeed_if (keyDecRef (key) == 0, "should stay at minimum");
26 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
27 2 : succeed_if (keyDecRef (key) == 0, "should stay at minimum");
28 2 : keyDel (key);
29 2 : }
30 :
31 2 : static void test_keyHelpers (void)
32 : {
33 2 : char * name = "user/abc/defghi/jkl";
34 : char * p;
35 2 : size_t size = 0;
36 2 : int level = 0;
37 : char buffer[20];
38 :
39 2 : Key * key = keyNew ("system/parent/base", KEY_END);
40 : Key *k1, *k2;
41 :
42 2 : printf ("Test key helpers\n");
43 :
44 : /* copied out of example from keyNameGetOneLevel
45 : Lets define a key name with a lot of repeating '/' and escaped '/'
46 : char *keyName="user////abc/def\\/ghi////jkl///";*/
47 :
48 2 : p = name;
49 12 : while (*(p = keyNameGetOneLevel (p + size, &size)))
50 : {
51 8 : level++;
52 :
53 8 : strncpy (buffer, p, size);
54 8 : buffer[size] = 0;
55 :
56 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
57 8 : switch (level)
58 : {
59 : case 1:
60 2 : succeed_if_same_string (buffer, "user");
61 : break;
62 : case 2:
63 2 : succeed_if_same_string (buffer, "abc");
64 : break;
65 : case 3:
66 2 : succeed_if_same_string (buffer, "defghi");
67 : break;
68 : case 4:
69 2 : succeed_if_same_string (buffer, "jkl");
70 : break;
71 : default:
72 0 : succeed_if (0, "should not reach case statement");
73 : }
74 : }
75 :
76 : /* with escaped sequence:*/
77 2 : name = "user////abc/def\\/ghi////jkl///";
78 2 : size = 0;
79 2 : level = 0;
80 :
81 2 : p = name;
82 12 : while (*(p = keyNameGetOneLevel (p + size, &size)))
83 : {
84 8 : level++;
85 :
86 8 : strncpy (buffer, p, size);
87 8 : buffer[size] = 0;
88 :
89 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
90 8 : switch (level)
91 : {
92 : case 1:
93 2 : succeed_if_same_string (buffer, "user");
94 2 : succeed_if (size == 4, "wrong size returned");
95 : break;
96 : case 2:
97 2 : succeed_if_same_string (buffer, "abc");
98 2 : succeed_if (size == 3, "wrong size returned");
99 : break;
100 : case 3:
101 2 : succeed_if_same_string (buffer, "def\\/ghi");
102 2 : succeed_if (size == 8, "wrong size returned");
103 : break;
104 : case 4:
105 2 : succeed_if_same_string (buffer, "jkl");
106 2 : succeed_if (size == 3, "wrong size returned");
107 : break;
108 : default:
109 0 : succeed_if (0, "should not reach case statement");
110 : }
111 : }
112 :
113 : /* with escaped sequence at the end:*/
114 2 : name = "user////abc/def\\/ghi////jkl\\/\\/";
115 2 : size = 0;
116 2 : level = 0;
117 :
118 2 : p = name;
119 12 : while (*(p = keyNameGetOneLevel (p + size, &size)))
120 : {
121 8 : level++;
122 :
123 8 : strncpy (buffer, p, size);
124 8 : buffer[size] = 0;
125 :
126 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
127 8 : switch (level)
128 : {
129 : case 1:
130 2 : succeed_if_same_string (buffer, "user");
131 2 : succeed_if (size == 4, "wrong size returned");
132 : break;
133 : case 2:
134 2 : succeed_if_same_string (buffer, "abc");
135 2 : succeed_if (size == 3, "wrong size returned");
136 : break;
137 : case 3:
138 2 : succeed_if_same_string (buffer, "def\\/ghi");
139 2 : succeed_if (size == 8, "wrong size returned");
140 : break;
141 : case 4:
142 2 : succeed_if_same_string (buffer, "jkl\\/\\/");
143 2 : succeed_if (size == 7, "wrong size returned");
144 : break;
145 : default:
146 0 : succeed_if (0, "should not reach case statement");
147 : }
148 : }
149 :
150 : /* with escaped sequence at the begin:*/
151 2 : name = "user////\\/abc/\\/def\\/ghi////jkl\\/\\/";
152 2 : size = 0;
153 2 : level = 0;
154 :
155 2 : p = name;
156 12 : while (*(p = keyNameGetOneLevel (p + size, &size)))
157 : {
158 8 : level++;
159 :
160 8 : strncpy (buffer, p, size);
161 8 : buffer[size] = 0;
162 :
163 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
164 8 : switch (level)
165 : {
166 : case 1:
167 2 : succeed_if_same_string (buffer, "user");
168 2 : succeed_if (size == 4, "wrong size returned");
169 : break;
170 : case 2:
171 2 : succeed_if_same_string (buffer, "\\/abc");
172 2 : succeed_if (size == 5, "wrong size returned");
173 : break;
174 : case 3:
175 2 : succeed_if_same_string (buffer, "\\/def\\/ghi");
176 2 : succeed_if (size == 10, "wrong size returned");
177 : break;
178 : case 4:
179 2 : succeed_if_same_string (buffer, "jkl\\/\\/");
180 2 : succeed_if (size == 7, "wrong size returned");
181 : break;
182 : default:
183 0 : succeed_if (0, "should not reach case statement");
184 : }
185 : }
186 :
187 : /* with double escaped slashes:*/
188 2 : name = "user////\\\\/abc/\\/def\\\\/ghi\\/jkl\\\\///";
189 2 : size = 0;
190 2 : level = 0;
191 :
192 2 : p = name;
193 14 : while (*(p = keyNameGetOneLevel (p + size, &size)))
194 : {
195 10 : level++;
196 :
197 10 : strncpy (buffer, p, size);
198 10 : buffer[size] = 0;
199 :
200 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
201 10 : switch (level)
202 : {
203 : case 1:
204 2 : succeed_if_same_string (buffer, "user");
205 2 : succeed_if (size == 4, "wrong size returned");
206 : break;
207 : case 2:
208 2 : succeed_if_same_string (buffer, "\\\\");
209 2 : succeed_if (size == 2, "wrong size returned");
210 : break;
211 : case 3:
212 2 : succeed_if_same_string (buffer, "abc");
213 2 : succeed_if (size == 3, "wrong size returned");
214 : break;
215 : case 4:
216 2 : succeed_if_same_string (buffer, "\\/def\\\\");
217 2 : succeed_if (size == 7, "wrong size returned");
218 : break;
219 : case 5:
220 2 : succeed_if_same_string (buffer, "ghi\\/jkl\\\\");
221 2 : succeed_if (size == 10, "wrong size returned");
222 : break;
223 : default:
224 0 : succeed_if (0, "should not reach case statement");
225 : }
226 : }
227 :
228 : /* with triple escaped slashes:*/
229 2 : name = "user////\\\\\\/ab/\\\\\\/def\\\\/ghi/jkl\\\\\\///";
230 2 : size = 0;
231 2 : level = 0;
232 :
233 2 : p = name;
234 14 : while (*(p = keyNameGetOneLevel (p + size, &size)))
235 : {
236 10 : level++;
237 :
238 10 : strncpy (buffer, p, size);
239 10 : buffer[size] = 0;
240 :
241 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
242 10 : switch (level)
243 : {
244 : case 1:
245 2 : succeed_if_same_string (buffer, "user");
246 2 : succeed_if (size == 4, "wrong size returned");
247 : break;
248 : case 2:
249 2 : succeed_if_same_string (buffer, "\\\\\\/ab");
250 2 : succeed_if (size == 6, "wrong size returned");
251 : break;
252 : case 3:
253 2 : succeed_if_same_string (buffer, "\\\\\\/def\\\\");
254 2 : succeed_if (size == 9, "wrong size returned");
255 : break;
256 : case 4:
257 2 : succeed_if_same_string (buffer, "ghi");
258 2 : succeed_if (size == 3, "wrong size returned");
259 : break;
260 : case 5:
261 2 : succeed_if_same_string (buffer, "jkl\\\\\\/");
262 2 : succeed_if (size == 7, "wrong size returned");
263 : break;
264 : default:
265 0 : succeed_if (0, "should not reach case statement");
266 : }
267 : }
268 :
269 : /* backslashes only:*/
270 2 : name = "/\\/\\\\/\\\\\\/\\\\\\\\/\\\\\\\\\\/\\\\\\\\\\\\/\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\";
271 2 : size = 0;
272 2 : level = 0;
273 :
274 2 : p = name;
275 12 : while (*(p = keyNameGetOneLevel (p + size, &size)))
276 : {
277 8 : level++;
278 :
279 8 : strncpy (buffer, p, size);
280 8 : buffer[size] = 0;
281 :
282 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
283 8 : switch (level)
284 : {
285 : case 1:
286 2 : succeed_if_same_string (buffer, "\\/\\\\");
287 2 : succeed_if (size == 1 + 1 + 2, "wrong size returned");
288 : break;
289 : case 2:
290 2 : succeed_if_same_string (buffer, "\\\\\\/\\\\\\\\");
291 2 : succeed_if (size == 3 + 1 + 4, "wrong size returned");
292 : break;
293 : case 3:
294 2 : succeed_if_same_string (buffer, "\\\\\\\\\\/\\\\\\\\\\\\");
295 2 : succeed_if (size == 5 + 1 + 6, "wrong size returned");
296 : break;
297 : case 4:
298 2 : succeed_if_same_string (buffer, "\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\");
299 2 : succeed_if (size == 7 + 1 + 8, "wrong size returned");
300 : break;
301 : default:
302 0 : succeed_if (0, "should not reach case statement");
303 : }
304 : }
305 :
306 : /* backslashes with slashes:*/
307 2 : name = "////////\\/\\\\//////\\\\\\/\\\\\\\\////\\\\\\\\\\/\\\\\\\\\\\\//\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\";
308 2 : size = 0;
309 2 : level = 0;
310 :
311 2 : p = name;
312 12 : while (*(p = keyNameGetOneLevel (p + size, &size)))
313 : {
314 8 : level++;
315 :
316 8 : strncpy (buffer, p, size);
317 8 : buffer[size] = 0;
318 :
319 : /* printf("Level %d name: \"%s\"\n",level,buffer);*/
320 8 : switch (level)
321 : {
322 : case 1:
323 2 : succeed_if_same_string (buffer, "\\/\\\\");
324 2 : succeed_if (size == 1 + 1 + 2, "wrong size returned");
325 : break;
326 : case 2:
327 2 : succeed_if_same_string (buffer, "\\\\\\/\\\\\\\\");
328 2 : succeed_if (size == 3 + 1 + 4, "wrong size returned");
329 : break;
330 : case 3:
331 2 : succeed_if_same_string (buffer, "\\\\\\\\\\/\\\\\\\\\\\\");
332 2 : succeed_if (size == 5 + 1 + 6, "wrong size returned");
333 : break;
334 : case 4:
335 2 : succeed_if_same_string (buffer, "\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\");
336 2 : succeed_if (size == 7 + 1 + 8, "wrong size returned");
337 : break;
338 : default:
339 0 : succeed_if (0, "should not reach case statement");
340 : }
341 : }
342 :
343 2 : keyDel (key);
344 :
345 2 : succeed_if (keyAddBaseName (0, "s") == -1, "null pointer saftey");
346 :
347 2 : k1 = keyNew ("user/dir1/dir2", KEY_END);
348 2 : succeed_if (keyAddBaseName (k1, 0) == 15, "Could not add nothing to basename");
349 2 : succeed_if_same_string (keyName (k1), "user/dir1/dir2");
350 2 : succeed_if (keyAddBaseName (k1, "") == 17, "Could not add nothing to basename");
351 2 : succeed_if_same_string (keyName (k1), "user/dir1/dir2/%");
352 2 : succeed_if (keyAddBaseName (k1, "mykey") == 23, "Could not add basename");
353 2 : succeed_if_same_string (keyName (k1), "user/dir1/dir2/%/mykey");
354 2 : succeed_if (keyGetNameSize (k1) == 23, "Name size not correct");
355 2 : succeed_if (keyAddBaseName (k1, "mykey") == sizeof ("user/dir1/dir2/%/mykey/mykey"), "Could not add basename");
356 2 : succeed_if_same_string (keyName (k1), "user/dir1/dir2/%/mykey/mykey");
357 2 : succeed_if (keyGetNameSize (k1) == 29, "Name size not correct");
358 2 : succeed_if (keyAddBaseName (k1, "a") == 31, "Could not add basename");
359 2 : succeed_if_same_string (keyName (k1), "user/dir1/dir2/%/mykey/mykey/a");
360 2 : succeed_if (keyGetNameSize (k1) == 31, "Name size not correct");
361 2 : keyDel (k1);
362 :
363 : {
364 2 : k2 = keyNew ("user/dir1/dir2", KEY_END);
365 2 : char c[] = "user/dir1/dir2/mykey\\/mykey\\/a";
366 2 : succeed_if (keyAddBaseName (k2, "mykey/mykey/a") == sizeof (c), "Could not add basename");
367 2 : succeed_if_same_string (keyName (k2), c);
368 2 : succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
369 2 : keyDel (k2);
370 : }
371 :
372 : {
373 2 : k2 = keyNew ("user/dir1/dir2", KEY_END);
374 2 : char c[] = "user/dir1/dir2/mykey\\/\\/\\/\\/a";
375 2 : succeed_if (keyAddBaseName (k2, "mykey////a") == sizeof (c), "Could not add basename");
376 2 : succeed_if_same_string (keyName (k2), c);
377 2 : succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
378 2 : keyDel (k2);
379 : }
380 :
381 : {
382 2 : k2 = keyNew ("user/dir1/dir2", KEY_END);
383 2 : char c[] = "user/dir1/dir2/mykey\\/\\/\\/\\/";
384 2 : succeed_if (keyAddBaseName (k2, "mykey////") == sizeof (c), "Could not add basename");
385 2 : succeed_if_same_string (keyName (k2), c);
386 2 : succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
387 2 : keyDel (k2);
388 : }
389 :
390 :
391 2 : k2 = keyNew (0);
392 2 : succeed_if (keyAddBaseName (k2, "no") == -1, "Could add basename on empty name");
393 2 : succeed_if_same_string (keyName (k2), "");
394 2 : succeed_if (keyGetNameSize (k2) == 1, "Name size not correct");
395 2 : keyDel (k2);
396 :
397 2 : k2 = keyNew (0);
398 2 : succeed_if (keyAddBaseName (k2, "user") == -1, "Could add basename on empty name");
399 2 : succeed_if_same_string (keyName (k2), "");
400 2 : succeed_if (keyGetNameSize (k2) == 1, "Name size not correct");
401 2 : keyDel (k2);
402 :
403 2 : k2 = keyNew ("user/dir1/dir2/mykey/mykey/a", KEY_END);
404 2 : succeed_if (keySetBaseName (k2, "mykey") == 33, "Could not add basename");
405 2 : succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/mykey");
406 2 : succeed_if (keyGetNameSize (k2) == 33, "Name size not correct");
407 2 : succeed_if (keySetBaseName (k2, "einva") == 33, "Could not add basename");
408 2 : succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/einva");
409 2 : succeed_if (keyGetNameSize (k2) == 33, "Name size not correct");
410 2 : succeed_if (keySetBaseName (k2, "chang") == 33, "Could not add basename");
411 2 : succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/chang");
412 2 : succeed_if (keySetBaseName (k2, "change") == 34, "Could not add basename");
413 2 : succeed_if (keyGetNameSize (k2) == 34, "Name size not correct");
414 2 : succeed_if_same_string (keyName (k2), "user/dir1/dir2/mykey/mykey/change");
415 2 : keyDel (k2);
416 :
417 2 : k2 = keyNew ("user/dir1/a", KEY_END);
418 2 : succeed_if (keySetBaseName (k2, 0) == 10, "Could not add basename");
419 2 : succeed_if_same_string (keyName (k2), "user/dir1");
420 2 : succeed_if (keyGetNameSize (k2) == 10, "Name size not correct");
421 2 : keyDel (k2);
422 :
423 2 : k2 = keyNew ("user/dir1/a", KEY_END);
424 2 : succeed_if (keySetBaseName (k2, "some/more") == sizeof ("user/dir1/some\\/more"), "Could not add basename");
425 2 : succeed_if_same_string (keyName (k2), "user/dir1/some\\/more");
426 2 : succeed_if (keyGetNameSize (k2) == sizeof ("user/dir1/some\\/more"), "Name size not correct");
427 2 : keyDel (k2);
428 :
429 : {
430 2 : k2 = keyNew ("user/dir1/a", KEY_END);
431 2 : char c[] = "user/dir1/some\\/\\/\\/\\/more";
432 2 : succeed_if (keySetBaseName (k2, "some////more") == sizeof (c), "Could not add basename");
433 2 : succeed_if_same_string (keyName (k2), c);
434 2 : succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
435 2 : keyDel (k2);
436 : }
437 :
438 : {
439 2 : k2 = keyNew ("user/dir1/a", KEY_END);
440 2 : char c[] = "user/dir1/\\/\\/\\/\\/more";
441 2 : succeed_if (keySetBaseName (k2, "////more") == sizeof (c), "Could not add basename");
442 2 : succeed_if_same_string (keyName (k2), c);
443 2 : succeed_if (keyGetNameSize (k2) == sizeof (c), "Name size not correct");
444 2 : keyDel (k2);
445 : }
446 :
447 2 : k2 = keyNew ("user", KEY_END);
448 2 : succeed_if (keySetBaseName (k2, "user") == -1, "Could add basename, but there is none");
449 2 : succeed_if_same_string (keyName (k2), "user");
450 2 : succeed_if (keyGetNameSize (k2) == 5, "Name size not correct");
451 2 : keyDel (k2);
452 :
453 2 : k2 = keyNew ("system", KEY_END);
454 2 : succeed_if (keySetBaseName (k2, "system") == -1, "Could add basename, but there is none");
455 2 : succeed_if_same_string (keyName (k2), "system");
456 2 : succeed_if (keyGetNameSize (k2) == 7, "Name size not correct");
457 2 : keyDel (k2);
458 2 : }
459 :
460 2 : static void test_keyPlugin (void)
461 : {
462 2 : Plugin * plug = (Plugin *) 1222243;
463 :
464 2 : Key * k = keyNew ("system/name", KEY_BINARY, KEY_SIZE, sizeof (plug), KEY_VALUE, &plug, KEY_END);
465 2 : Plugin * xlug = *(Plugin **) keyValue (k);
466 :
467 2 : succeed_if (xlug == plug, "should point to the same");
468 2 : succeed_if (plug == (Plugin *) 1222243, "should point to that");
469 2 : succeed_if (xlug == (Plugin *) 1222243, "should point to that too");
470 :
471 2 : keyDel (k);
472 2 : }
473 :
474 : #define TEST_ESCAPE_PART(A, S) \
475 : do \
476 : { \
477 : char a[] = A; \
478 : char s[] = S; \
479 : elektraEscapeKeyNamePart (a, buffer); \
480 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong"); \
481 : elektraUnescapeKeyName (buffer, buffer2); \
482 : succeed_if_same_string (a, buffer2); \
483 : } while (0)
484 :
485 :
486 2 : static void test_keyNameEscape (void)
487 : {
488 : char buffer[500];
489 : char buffer2[500];
490 :
491 2 : printf ("test escapeKeyNamePart\n");
492 :
493 : #include <data_escape.c>
494 :
495 :
496 : /*
497 : for (size_t i = 0; i<10; ++i)
498 : {
499 : int z = buffer[i];
500 : printf ("%c %d\n", (char)z, z);
501 : }
502 : */
503 :
504 2 : printf ("test roundtripping properties\n");
505 2 : Key * k = keyNew ("user/a", KEY_END);
506 : #ifdef LONG_TEST
507 : char a[] = "abcd";
508 : #else
509 2 : char a[] = "ab";
510 : #endif
511 514 : for (int c0 = 0; c0 < 256; ++c0)
512 131072 : for (int c1 = 0; c1 < 256; ++c1)
513 : #ifdef LONG_TEST
514 : for (int c2 = 0; c2 < 256; ++c2)
515 : for (int c3 = 0; c3 < 256; ++c3)
516 : #endif
517 : {
518 131072 : a[0] = c0;
519 131072 : a[1] = c1;
520 : #ifdef LONG_TEST
521 : a[2] = c2;
522 : a[3] = c3;
523 : #endif
524 131072 : elektraEscapeKeyNamePart (a, buffer);
525 131072 : elektraUnescapeKeyName (buffer, buffer2);
526 131072 : succeed_if_same_string (a, buffer2);
527 :
528 131072 : keySetBaseName (k, a);
529 131072 : succeed_if_same_string (a, keyBaseName (k));
530 : }
531 2 : keyDel (k);
532 2 : }
533 :
534 2 : static void test_keyNameUnescape (void)
535 : {
536 : char buffer[500];
537 :
538 2 : printf ("test unescapeKeyNamePart\n");
539 : {
540 2 : char a[] = "\\\\a";
541 2 : char s[] = "\\\\a";
542 2 : elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
543 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
544 : /*
545 : for (size_t i = 0; i<sizeof(s); ++i)
546 : {
547 : int z = buffer[i];
548 : printf ("%c %d\n", (char)z, z);
549 : }
550 : */
551 : }
552 :
553 : {
554 2 : char a[] = "a\\/test";
555 2 : char s[] = "a/test";
556 2 : elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
557 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
558 : }
559 :
560 : {
561 2 : char a[] = "a\\\\\\/test";
562 2 : char s[] = "a\\/test";
563 2 : elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
564 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
565 : }
566 :
567 : {
568 2 : char a[] = "a\\\\\\\\\\/test";
569 2 : char s[] = "a\\\\/test";
570 2 : elektraUnescapeKeyNamePart (a, sizeof (a) - 1, buffer);
571 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
572 : }
573 :
574 :
575 2 : printf ("test unescapeKeyName\n");
576 :
577 : {
578 2 : char a[] = "user/a/test";
579 2 : char s[] = "user\0a\0test";
580 2 : elektraUnescapeKeyName (a, buffer);
581 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
582 : }
583 :
584 : {
585 2 : char a[] = "user/a\\/test";
586 2 : char s[] = "user\0a/test";
587 2 : elektraUnescapeKeyName (a, buffer);
588 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
589 : }
590 :
591 : {
592 2 : char a[] = "user/a\\\\/test";
593 2 : char s[] = "user\0a\\\0test";
594 2 : elektraUnescapeKeyName (a, buffer);
595 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
596 : }
597 :
598 : {
599 2 : char a[] = "user/\\\\/test";
600 2 : char s[] = "user\0\\\0test";
601 2 : elektraUnescapeKeyName (a, buffer);
602 2 : succeed_if (!memcmp (buffer, s, sizeof (s) - 1), "unescaped name wrong");
603 : }
604 :
605 : /*
606 : for (size_t i = 0; i<sizeof(s); ++i)
607 : {
608 : int z = buffer[i];
609 : printf ("%c %d\n", (char)z, z);
610 : }
611 : */
612 2 : }
613 :
614 2 : static void test_keyCompare (void)
615 : {
616 2 : printf ("test keyCompare\n");
617 2 : Key * key1 = keyNew (0);
618 2 : Key * key2 = keyNew (0);
619 :
620 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys don't differ of course");
621 :
622 2 : keySetName (key1, "user/myname");
623 2 : succeed_if_same_string (keyName (key1), "user/myname");
624 2 : succeed_if (keyCompare (key1, key2) == KEY_NAME, "the keys should differ in name");
625 2 : keySetName (key2, "user/myname");
626 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in name");
627 :
628 2 : keySetOwner (key1, "myowner");
629 2 : succeed_if (keyCompare (key1, key2) == (KEY_OWNER | KEY_META), "the keys should differ in owner");
630 2 : keySetOwner (key2, "myowner");
631 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in owner");
632 :
633 2 : keySetString (key1, "myvalue");
634 2 : succeed_if (keyCompare (key1, key2) == KEY_VALUE, "the keys should differ in value");
635 2 : keySetString (key2, "myvalue");
636 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in value");
637 :
638 2 : keySetComment (key1, "mycomment");
639 2 : succeed_if (keyCompare (key1, key2) == (KEY_COMMENT | KEY_META), "the keys should differ in comment");
640 2 : keySetComment (key2, "mycomment");
641 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in comment");
642 :
643 2 : keySetUID (key1, 50);
644 2 : succeed_if (keyCompare (key1, key2) == (KEY_META), "the keys should differ in uid");
645 2 : keySetUID (key2, 50);
646 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in uid");
647 :
648 2 : keySetGID (key1, 50);
649 2 : succeed_if (keyCompare (key1, key2) == (KEY_META), "the keys should differ in gid");
650 2 : keySetGID (key2, 50);
651 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in gid");
652 :
653 2 : keySetMode (key1, 0222);
654 2 : succeed_if (keyCompare (key1, key2) == (KEY_META), "the keys should differ in mode");
655 2 : keySetMode (key2, 0222);
656 2 : succeed_if (keyCompare (key1, key2) == 0, "the keys should not differ in mode");
657 :
658 2 : keyDel (key1);
659 2 : keyDel (key2);
660 2 : }
661 :
662 2 : static void test_keyNewExtensions (void)
663 : {
664 2 : printf ("test keyNewExtensions\n");
665 :
666 2 : Key * key = 0;
667 2 : succeed_if (keyIsUser (key) == -1, "empty user key");
668 2 : succeed_if (keyIsSystem (key) == -1, "empty user key?");
669 :
670 2 : key = keyNew ("", KEY_END);
671 2 : succeed_if (keyIsUser (key) == 0, "empty user key");
672 2 : succeed_if (keyIsSystem (key) == 0, "empty user key?");
673 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + mode");
674 :
675 : // Key with name + UID/GID
676 2 : key = keyNew ("system/sw/test", KEY_UID, 123, KEY_GID, 456, KEY_END);
677 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name + UID + GID");
678 2 : succeed_if (keyGetUID (key) == 123, "keyNew: UID no set correctly");
679 2 : succeed_if (keyGetGID (key) == 456, "keyNew: GID not set correctly");
680 2 : succeed_if (keyIsUser (key) == 0, "not user");
681 2 : succeed_if (keyIsSystem (key) == 1, "is system");
682 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + UID + GID");
683 :
684 : // Key with name + MODE
685 2 : key = keyNew ("system/sw/test", KEY_MODE, 0644, KEY_END);
686 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name + mode");
687 2 : succeed_if (keyGetMode (key) == 0644, "keyNew: mode no set correctly");
688 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + mode");
689 2 : }
690 :
691 2 : static void test_owner (void)
692 : {
693 2 : printf ("test owner\n");
694 :
695 2 : Key * key = 0;
696 : char fullroot[KDB_MAX_PATH_LENGTH];
697 2 : char array[] = "here is some data stored";
698 2 : char testOwner[] = "max";
699 :
700 : char * getBack;
701 2 : key = keyNew ("user/test/test", KEY_END);
702 2 : succeed_if (keySetOwner (key, "hugo") == sizeof ("hugo"), "could not set owner");
703 2 : succeed_if_same_string (keyOwner (key), "hugo");
704 2 : succeed_if (keyGetOwnerSize (key) == 5, "owner length not correct");
705 2 : keyGetFullName (key, fullroot, KDB_MAX_PATH_LENGTH);
706 2 : succeed_if_same_string (keyOwner (key), "hugo");
707 : /* printf ("%s, %s, %s\n", keyName(key), keyBaseName(key), fullroot); */
708 2 : succeed_if_same_string (keyName (key), "user/test/test");
709 2 : succeed_if_same_string (keyBaseName (key), "test");
710 : // printf ("%s\n", fullroot);
711 2 : succeed_if_same_string (fullroot, "user:hugo/test/test");
712 2 : succeed_if (keyIsUser (key) == 1, "is user");
713 2 : succeed_if (keyIsSystem (key) == 0, "not system");
714 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
715 :
716 2 : key = keyNew ("user/test/test", KEY_END);
717 2 : succeed_if (keySetOwner (key, "tommy") == sizeof ("tommy"), "could not set owner");
718 2 : succeed_if_same_string (keyOwner (key), "tommy");
719 2 : succeed_if (keyGetOwnerSize (key) == 6, "owner length not correct");
720 2 : keyGetFullName (key, fullroot, KDB_MAX_PATH_LENGTH);
721 2 : succeed_if_same_string (keyOwner (key), "tommy");
722 : /* printf ("%s, %s, %s\n", keyName(key), keyBaseName(key), fullroot); */
723 2 : succeed_if_same_string (keyName (key), "user/test/test");
724 2 : succeed_if_same_string (keyBaseName (key), "test");
725 2 : succeed_if_same_string (fullroot, "user:tommy/test/test");
726 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
727 :
728 : // Key with name + owner
729 2 : key = keyNew ("user/test/test", KEY_OWNER, "yl", KEY_END);
730 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name + owner");
731 2 : succeed_if_same_string (keyOwner (key), "yl");
732 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
733 :
734 2 : key = keyNew ("user/valid/there", KEY_BINARY, KEY_SIZE, sizeof (array), KEY_VALUE, array, KEY_END);
735 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name + value of default type");
736 2 : succeed_if (keyIsBinary (key), "Could not set type to binary");
737 2 : succeed_if (keyGetValueSize (key) == sizeof (array), "Value size not correct");
738 2 : succeed_if (memcmp ((char *) keyValue (key), array, sizeof (array)) == 0, "could not get correct binary value");
739 2 : getBack = elektraMalloc (keyGetValueSize (key));
740 2 : keyGetBinary (key, getBack, keyGetValueSize (key));
741 2 : succeed_if (memcmp (getBack, array, sizeof (array)) == 0, "could not get correct value with keyGetBinary");
742 2 : elektraFree (getBack);
743 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
744 :
745 2 : key = keyNew ("user:y", KEY_END);
746 2 : succeed_if_same_string (keyName (key), "user");
747 2 : succeed_if (keyGetNameSize (key) == 5, "empty name size");
748 2 : succeed_if_same_string (keyOwner (key), "y");
749 2 : succeed_if (keyGetOwnerSize (key) == 2, "owner y size");
750 2 : keyDel (key);
751 :
752 2 : succeed_if (key = keyNew ("user:perfectowner", KEY_END), "could not create new key");
753 2 : succeed_if (keySetName (key, "user:perfectowner") == 5, "could not set to user with owner");
754 2 : succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
755 2 : succeed_if_same_string (keyOwner (key), "perfectowner");
756 2 : succeed_if (keyDel (key) == 0, "could not delete key");
757 :
758 : char ret[1000];
759 2 : size_t i = 0;
760 2 : key = keyNew ("user:max/name", KEY_END);
761 2 : succeed_if (keyGetOwner (0, ret, 100) == -1, "null pointer");
762 2 : succeed_if (keyGetOwner (key, 0, 100) == -1, "string null pointer");
763 2 : succeed_if (keyGetOwner (key, ret, 0) == -1, "length checking");
764 6 : for (i = 1; i < sizeof (testOwner); i++)
765 : {
766 6 : succeed_if (keyGetOwner (key, ret, i) == -1, "length checking too short");
767 : }
768 8 : for (i = sizeof (testOwner); i < sizeof (testOwner) * 2; i++)
769 : {
770 8 : succeed_if (keyGetOwner (key, ret, i) == sizeof (testOwner), "length checking longer");
771 : }
772 2 : succeed_if (keyGetOwner (key, ret, (size_t) -1) == -1, "maxSize exceeded");
773 :
774 2 : succeed_if (keySetOwner (key, 0) == 1, "delete owner");
775 2 : succeed_if (keyGetOwner (key, ret, i) == 1, "length checking deleting");
776 2 : succeed_if_same_string (ret, "");
777 :
778 2 : succeed_if (keySetOwner (key, testOwner) == sizeof (testOwner), "set owner");
779 2 : succeed_if (keyGetOwner (key, ret, i) == sizeof (testOwner), "length checking working");
780 2 : succeed_if_same_string (ret, testOwner);
781 :
782 2 : succeed_if (keySetOwner (key, "") == 1, "delete owner");
783 2 : succeed_if (keyGetOwner (key, ret, i) == 1, "length checking deleting");
784 2 : succeed_if_same_string (ret, "");
785 :
786 2 : succeed_if (keySetOwner (key, testOwner) == sizeof (testOwner), "set owner");
787 2 : succeed_if (keyGetOwner (key, ret, i) == sizeof (testOwner), "length checking working");
788 2 : succeed_if_same_string (ret, testOwner);
789 2 : keyDel (key);
790 :
791 2 : succeed_if (keyOwner (0) == 0, "null pointer");
792 :
793 2 : key = keyNew (0);
794 2 : succeed_if_same_string (keyOwner (key), "");
795 2 : succeed_if (keyGetOwner (key, ret, 1000) == 1, "get empty owner");
796 2 : succeed_if_same_string (ret, "");
797 2 : succeed_if (keyGetOwner (key, ret, 0) == -1, "get empty owner");
798 2 : keyDel (key);
799 :
800 2 : succeed_if (keySetOwner (0, "") == -1, "null pointer");
801 2 : }
802 :
803 4 : static void test_keyComment (void)
804 : {
805 : Key * key;
806 : char ret[1000];
807 : size_t i;
808 4 : char testComment[] = "testcomment";
809 :
810 4 : printf ("Test comment of key\n");
811 :
812 4 : succeed_if (key = keyNew (0), "could not create new key");
813 4 : succeed_if (keyGetCommentSize (key) == 1, "empty comment size");
814 4 : succeed_if (keySetComment (key, "perfectcomment") == 15, "could not set comment");
815 4 : succeed_if (keyGetCommentSize (key) == 15, "comment size not correct");
816 4 : succeed_if_same_string (keyComment (key), "perfectcomment");
817 4 : succeed_if (keySetComment (key, "perfectcomment") == 15, "could not re-set same comment");
818 4 : succeed_if_same_string (keyComment (key), "perfectcomment");
819 4 : succeed_if (keySetComment (key, "nearperfectcomment") == 19, "could not re-set other comment");
820 4 : succeed_if (keyGetCommentSize (key) == 19, "comment size not correct");
821 4 : succeed_if_same_string (keyComment (key), "nearperfectcomment");
822 4 : succeed_if (keyGetComment (key, ret, keyGetCommentSize (key) >= 999 ? 999 : keyGetCommentSize (key)) == 19,
823 : "could not get comment");
824 4 : succeed_if_same_string (ret, "nearperfectcomment");
825 4 : succeed_if (keyDel (key) == 0, "could not delete key");
826 :
827 4 : succeed_if (key = keyNew (0), "could not create new key");
828 4 : succeed_if_same_string (keyComment (key), "");
829 4 : succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
830 4 : succeed_if (keySetComment (key, "") == 1, "could not set comment");
831 4 : succeed_if_same_string (keyComment (key), "");
832 4 : succeed_if (keyGetCommentSize (key) == 1, "Empty comment size problem");
833 4 : succeed_if (keyGetComment (key, ret, 0) == -1, "Could not get empty comment");
834 4 : succeed_if (keyGetComment (key, ret, 1) == 1, "Could not get empty comment");
835 4 : succeed_if (ret[0] == 0, "keyGetComment did not return empty comment");
836 4 : succeed_if (keyDel (key) == 0, "could not delete key");
837 :
838 4 : succeed_if (key = keyNew (0), "could not create new key");
839 1020 : for (i = 1; i < 256; i++)
840 : {
841 1020 : ret[0] = i;
842 1020 : ret[1] = i;
843 1020 : ret[2] = 0;
844 1020 : succeed_if (keySetComment (key, ret) == 3, "could not set comment");
845 : // output_key (key);
846 1020 : succeed_if_same_string (keyComment (key), ret);
847 : }
848 4 : succeed_if (keyDel (key) == 0, "could not delete key");
849 :
850 :
851 4 : printf ("Test comment of key 2\n");
852 :
853 4 : succeed_if (keyComment (0) == 0, "null pointer");
854 4 : succeed_if (keyGetCommentSize (0) == -1, "null pointer");
855 4 : succeed_if (keySetComment (0, "") == -1, "null pointer");
856 :
857 4 : key = keyNew (0);
858 4 : succeed_if (keyGetCommentSize (key) == 1, "empty comment size");
859 :
860 4 : keySetComment (key, testComment);
861 4 : succeed_if (keyGetComment (0, ret, 100) == -1, "null pointer");
862 4 : succeed_if (keyGetComment (key, 0, 100) == -1, "comment null pointer");
863 4 : succeed_if (keyGetComment (key, ret, 0) == -1, "length checking");
864 :
865 44 : for (i = 1; i < sizeof (testComment); i++)
866 : {
867 44 : succeed_if (keyGetComment (key, ret, i) == -1, "length checking too short");
868 : }
869 48 : for (i = sizeof (testComment); i < sizeof (testComment) * 2; i++)
870 : {
871 48 : succeed_if (keyGetComment (key, ret, i) == sizeof (testComment), "length checking longer");
872 : }
873 4 : succeed_if (keyGetComment (key, ret, (size_t) -1) == -1, "maxSize exceeded");
874 :
875 4 : succeed_if (keySetComment (key, 0) == 1, "delete comment");
876 4 : succeed_if (keyGetComment (key, ret, i) == 1, "length checking deleting");
877 4 : succeed_if_same_string (ret, "");
878 :
879 4 : succeed_if (keySetComment (key, testComment) == sizeof (testComment), "set comment");
880 4 : succeed_if (keyGetComment (key, ret, i) == sizeof (testComment), "length checking working");
881 4 : succeed_if_same_string (ret, testComment);
882 :
883 4 : succeed_if (keySetComment (key, "") == 1, "delete comment");
884 4 : succeed_if (keyGetComment (key, ret, i) == 1, "length checking deleting");
885 4 : succeed_if_same_string (ret, "");
886 :
887 4 : succeed_if (keySetComment (key, testComment) == sizeof (testComment), "set comment");
888 4 : succeed_if (keyGetComment (key, ret, i) == sizeof (testComment), "length checking working");
889 4 : succeed_if_same_string (ret, testComment);
890 :
891 4 : succeed_if (keyGetCommentSize (key) == sizeof (testComment), "testComment comment size");
892 4 : succeed_if (strncmp (keyComment (key), testComment, sizeof (testComment)) == 0, "testComment not same");
893 4 : keyDel (key);
894 4 : }
895 :
896 2 : static void test_keyOwner (void)
897 : {
898 : Key * key;
899 : char ret[1000];
900 : int i;
901 2 : printf ("Test owner of keys\n");
902 2 : succeed_if (key = keyNew (0), "could not create new key");
903 2 : succeed_if (keyGetOwnerSize (key) == 1, "empty owner size");
904 2 : succeed_if (keySetOwner (key, "perfectowner") == 13, "could not set owner");
905 2 : succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
906 2 : succeed_if_same_string (keyOwner (key), "perfectowner");
907 2 : succeed_if (keySetOwner (key, "perfectowner") == 13, "could not re-set same owner");
908 2 : succeed_if_same_string (keyOwner (key), "perfectowner");
909 2 : succeed_if (keySetOwner (key, "nearperfectowner") == 17, "could not re-set other owner");
910 2 : succeed_if (keyGetOwnerSize (key) == 17, "owner size not correct");
911 2 : succeed_if_same_string (keyOwner (key), "nearperfectowner");
912 2 : succeed_if (keyGetOwner (key, ret, keyGetOwnerSize (key) >= 999 ? 999 : keyGetOwnerSize (key)) == 17, "could not get owner");
913 2 : succeed_if_same_string (ret, "nearperfectowner");
914 2 : succeed_if (keyDel (key) == 0, "could not delete key");
915 :
916 2 : succeed_if (key = keyNew (0), "could not create new key");
917 2 : succeed_if (keySetName (key, "user:perfectowner") == 5, "could not set to user with owner");
918 2 : succeed_if (keyGetOwnerSize (key) == 13, "owner size not correct");
919 2 : succeed_if_same_string (keyOwner (key), "perfectowner");
920 2 : succeed_if (keyDel (key) == 0, "could not delete key");
921 :
922 2 : succeed_if (key = keyNew (0), "could not create new key");
923 2 : succeed_if_same_string (keyOwner (key), "");
924 2 : succeed_if (keyGetOwnerSize (key) == 1, "Empty owner size problem");
925 2 : succeed_if (keySetOwner (key, "") == 1, "could not set owner");
926 2 : succeed_if_same_string (keyOwner (key), "");
927 2 : succeed_if (keyGetOwnerSize (key) == 1, "Empty owner size problem");
928 2 : succeed_if (keyGetOwner (key, ret, 0) == -1, "Could not get empty owner");
929 2 : succeed_if (keyGetOwner (key, ret, 1) == 1, "Could not get empty owner");
930 2 : succeed_if (ret[0] == 0, "keyGetOwner did not return empty owner");
931 2 : succeed_if (keyDel (key) == 0, "could not delete key");
932 :
933 2 : succeed_if (key = keyNew (0), "could not create new key");
934 510 : for (i = 1; i < 256; i++)
935 : {
936 510 : ret[0] = i;
937 510 : ret[1] = i;
938 510 : ret[2] = 0;
939 510 : succeed_if (keySetOwner (key, ret) == 3, "could not set owner");
940 : // output_key (key);
941 510 : succeed_if_same_string (keyOwner (key), ret);
942 : }
943 2 : succeed_if (keyDel (key) == 0, "could not delete key");
944 2 : }
945 :
946 2 : static void test_keyDir (void)
947 : {
948 : mode_t i;
949 2 : Key * key = keyNew ("user", KEY_END);
950 :
951 2 : printf ("Test directory keys\n");
952 :
953 2 : succeed_if (keyGetMode (key) == 0600, "new key not 0600 by default");
954 :
955 2 : succeed_if (keySetMode (key, 0644) == 0, "could not set to 0644");
956 2 : succeed_if (keyGetMode (key) == 0644, "key is not 0644, but was set");
957 :
958 2 : succeed_if (keySetDir (key) == 0, "could not set directory key");
959 : // succeed_if (keyGetMode(key) == 0755, "key is not 0644, but was set");
960 :
961 1024 : for (i = 0; i <= 0777; i++)
962 : {
963 1024 : succeed_if (keySetMode (key, i) == 0, "could not set to 0000 <= i <= 0777");
964 1024 : succeed_if (keyGetMode (key) == i, "key is not correct 0000 <= i <= 0777");
965 :
966 1024 : succeed_if (keySetDir (key) == 0, "could not set directory key");
967 : }
968 2 : keyDel (key);
969 :
970 2 : key = keyNew ("user", KEY_DIR, KEY_END);
971 2 : succeed_if (keyGetMode (key) == 0700, "new key with KEY_DIR not 0700 by default");
972 :
973 2 : succeed_if (keySetMode (key, 0644) == 0, "could not set to 0644");
974 2 : succeed_if (keyGetMode (key) == 0644, "key is not 0644, but was set");
975 :
976 2 : succeed_if (keySetDir (key) == 0, "could not set directory key");
977 2 : succeed_if (keyGetMode (key) == 0744, "key is not 0644, but was set");
978 2 : keyDel (key);
979 :
980 2 : key = keyNew ("user/s", KEY_DIR, KEY_MODE, 0444, KEY_END);
981 2 : succeed_if (keyGetMode (key) == 0544, "0444 set by keyNew");
982 2 : keyDel (key);
983 :
984 2 : key = keyNew ("user/s", KEY_MODE, 0444, KEY_DIR, KEY_END);
985 2 : succeed_if (keyGetMode (key) == 0544, "0555 set by keyNew");
986 2 : keyDel (key);
987 2 : }
988 :
989 2 : static void test_keyTime (void)
990 : {
991 2 : Key * key = keyNew (0);
992 2 : time_t now = time (0);
993 2 : time_t past = now - 60 * 60 * 24 * 356 * 10;
994 2 : time_t future = now + 60 * 60 * 24 * 356 * 10;
995 : /*
996 : time_t far_future = now + 60L*60L*24L*356L * 100L;
997 : */
998 :
999 2 : printf ("Test key time\n");
1000 :
1001 2 : succeed_if (keyGetATime (0) == (time_t) -1, "null pointer check");
1002 2 : succeed_if (keyGetMTime (0) == (time_t) -1, "null pointer check");
1003 2 : succeed_if (keyGetCTime (0) == (time_t) -1, "null pointer check");
1004 :
1005 2 : succeed_if (keySetATime (0, 0) == -1, "null pointer check");
1006 2 : succeed_if (keySetMTime (0, 0) == -1, "null pointer check");
1007 2 : succeed_if (keySetCTime (0, 0) == -1, "null pointer check");
1008 :
1009 2 : succeed_if (keyGetATime (key) == 0, "new initialized atime not 0");
1010 2 : succeed_if (keyGetMTime (key) == 0, "new initialized mtime not 0");
1011 2 : succeed_if (keyGetCTime (key) == 0, "new initialized ctime not 0");
1012 :
1013 2 : succeed_if (keySetATime (key, now) == 0, "could not set atime");
1014 2 : succeed_if (keySetMTime (key, now) == 0, "could not set mtime");
1015 2 : succeed_if (keySetCTime (key, now) == 0, "could not set ctime");
1016 :
1017 2 : succeed_if (keyGetATime (key) == now, "new initialized atime not 0");
1018 2 : succeed_if (keyGetMTime (key) == now, "new initialized mtime not 0");
1019 2 : succeed_if (keyGetCTime (key) == now, "new initialized ctime not 0");
1020 :
1021 :
1022 2 : succeed_if (keySetATime (key, past) == 0, "could not set atime");
1023 2 : succeed_if (keySetMTime (key, past) == 0, "could not set mtime");
1024 2 : succeed_if (keySetCTime (key, past) == 0, "could not set ctime");
1025 :
1026 2 : succeed_if (keyGetATime (key) == past, "new initialized atime not 0");
1027 2 : succeed_if (keyGetMTime (key) == past, "new initialized mtime not 0");
1028 2 : succeed_if (keyGetCTime (key) == past, "new initialized ctime not 0");
1029 :
1030 :
1031 2 : succeed_if (keySetATime (key, future) == 0, "could not set atime");
1032 2 : succeed_if (keySetMTime (key, future) == 0, "could not set mtime");
1033 2 : succeed_if (keySetCTime (key, future) == 0, "could not set ctime");
1034 :
1035 2 : succeed_if (keyGetATime (key) == future, "new initialized atime not 0");
1036 2 : succeed_if (keyGetMTime (key) == future, "new initialized mtime not 0");
1037 2 : succeed_if (keyGetCTime (key) == future, "new initialized ctime not 0");
1038 :
1039 : /*
1040 : succeed_if (keySetATime (key, far_future) == 0, "could not set atime");
1041 : succeed_if (keySetMTime (key, far_future) == 0, "could not set mtime");
1042 : succeed_if (keySetCTime (key, far_future) == 0, "could not set ctime");
1043 :
1044 : succeed_if (keyGetATime(key) == far_future, "new initialized atime not 0");
1045 : succeed_if (keyGetMTime(key) == far_future, "new initialized mtime not 0");
1046 : succeed_if (keyGetCTime(key) == far_future, "new initialized ctime not 0");
1047 :
1048 : warn_if_fail (keyGetATime(key) > 0, "time_t not 64 bit, 2038 problem");
1049 : warn_if_fail (keyGetMTime(key) > 0, "time_t not 64 bit, 2038 problem");
1050 : warn_if_fail (keyGetCTime(key) > 0, "time_t not 64 bit, 2038 problem");
1051 : */
1052 :
1053 2 : keyDel (key);
1054 2 : }
1055 :
1056 2 : static void test_keyMeta (void)
1057 : {
1058 2 : Key * key = 0;
1059 :
1060 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid null pointer");
1061 2 : succeed_if (keyGetGID (key) == (gid_t) -1, "gid null pointer");
1062 2 : succeed_if (keyGetMode (key) == (mode_t) -1, "mode null pointer");
1063 :
1064 2 : key = 0;
1065 2 : succeed_if (keyNeedSync (key) == -1, "key needs sync");
1066 2 : key = keyNew (0);
1067 2 : succeed_if (keyNeedSync (key) == 0, "fresh key needs sync");
1068 2 : keyDel (key);
1069 :
1070 2 : key = keyNew ("user/remove", KEY_END);
1071 2 : succeed_if (keyNeedSync (key) == 1, "need sync");
1072 2 : keyDel (key);
1073 :
1074 2 : succeed_if (keyNeedSync (0) == -1, "keyNeedSync(0)");
1075 :
1076 2 : key = keyNew (0);
1077 2 : succeed_if (keyNeedSync (key) == 0, "keyNew(0) should not need sync");
1078 2 : succeed_if (keySetName (key, "invalid") == -1, "invalid name should fail");
1079 2 : succeed_if (keyNeedSync (key) == 0, "keyNew(0) should not need sync");
1080 2 : keyDel (key);
1081 :
1082 2 : key = keyNew (0);
1083 2 : succeed_if (keyNeedSync (key) == 0, "should not need sync");
1084 2 : keySetUID (key, 20);
1085 2 : succeed_if (keyNeedSync (key) == 1, "should need sync");
1086 2 : keyDel (key);
1087 :
1088 2 : key = keyNew (0);
1089 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid not set to nobody");
1090 2 : succeed_if (keyGetGID (key) == (gid_t) -1, "gid not set to nobody");
1091 :
1092 2 : succeed_if (keySetUID (key, 20) == 0, "could not set uid");
1093 2 : succeed_if (keySetGID (key, 21) == 0, "could not set uid");
1094 :
1095 2 : succeed_if (keyGetUID (key) == 20, "uid not set to 20");
1096 2 : succeed_if (keyGetGID (key) == 21, "gid not set to 21");
1097 :
1098 2 : succeed_if (keySetUID (key, (uid_t) -1) == 0, "could not set uid");
1099 2 : succeed_if (keySetGID (key, (gid_t) -1) == 0, "could not set uid");
1100 :
1101 2 : succeed_if (keyGetUID (key) == (uid_t) -1, "uid not set to nobody");
1102 2 : succeed_if (keyGetGID (key) == (gid_t) -1, "gid not set to nobody");
1103 :
1104 2 : succeed_if (keySetUID (key, 0) == 0, "could not set uid");
1105 2 : succeed_if (keySetGID (key, 0) == 0, "could not set uid");
1106 :
1107 2 : succeed_if (keyGetUID (key) == 0, "uid not set to 20");
1108 2 : succeed_if (keyGetGID (key) == 0, "gid not set to 21");
1109 2 : keyDel (key);
1110 :
1111 2 : key = keyNew (0);
1112 2 : succeed_if (keyGetMode (key) == KDB_FILE_MODE, "new key does not have default mode");
1113 2 : succeed_if (keySetDir (key) == 0, "could not set dir");
1114 2 : succeed_if (keyGetMode (key) == (KDB_FILE_MODE | KDB_DIR_MODE), "directory key");
1115 2 : keyDel (key);
1116 :
1117 2 : key = keyNew ("user/dir", KEY_DIR, KEY_END);
1118 2 : succeed_if (keyGetMode (key) == (KDB_FILE_MODE | KDB_DIR_MODE), "directory key");
1119 2 : succeed_if (keySetDir (key) == 0, "could not set dir");
1120 2 : succeed_if (keyGetMode (key) == (KDB_FILE_MODE | KDB_DIR_MODE), "directory key");
1121 2 : keyDel (key);
1122 2 : }
1123 :
1124 2 : static void test_elektraKeySetName (void)
1125 : {
1126 2 : printf ("test elektraKeySetName\n");
1127 :
1128 2 : Key * key = keyNew ("", KEY_END);
1129 2 : Key * dup = 0;
1130 :
1131 2 : succeed_if (elektraKeySetName (key, "/", KEY_CASCADING_NAME) != -1, "could not set cascading name");
1132 2 : succeed_if_same_string (keyName (key), "/");
1133 2 : dup = keyDup (key);
1134 2 : succeed_if_same_string (keyName (dup), "/");
1135 2 : keyDel (dup);
1136 :
1137 2 : elektraKeySetName (key, "/c", KEY_CASCADING_NAME);
1138 2 : succeed_if_same_string (keyName (key), "/c");
1139 2 : dup = keyDup (key);
1140 2 : succeed_if_same_string (keyName (dup), "/c");
1141 2 : keyDel (dup);
1142 :
1143 2 : succeed_if (elektraKeySetName (key, "/", KEY_CASCADING_NAME) != -1, "could not set cascading name");
1144 2 : succeed_if_same_string (keyName (key), "/");
1145 2 : elektraKeySetName (key, "/cascading", KEY_CASCADING_NAME);
1146 2 : succeed_if_same_string (keyName (key), "/cascading");
1147 2 : dup = keyDup (key);
1148 2 : succeed_if_same_string (keyName (dup), "/cascading");
1149 2 : keyDel (dup);
1150 :
1151 2 : elektraKeySetName (key, "/cascading/s/deep/below", KEY_CASCADING_NAME);
1152 2 : succeed_if_same_string (keyName (key), "/cascading/s/deep/below");
1153 2 : dup = keyDup (key);
1154 2 : succeed_if_same_string (keyName (dup), "/cascading/s/deep/below");
1155 2 : keyDel (dup);
1156 :
1157 2 : elektraKeySetName (key, "user/cascading/s/deep/below", KEY_CASCADING_NAME);
1158 2 : succeed_if_same_string (keyName (key), "user/cascading/s/deep/below");
1159 2 : dup = keyDup (key);
1160 2 : succeed_if_same_string (keyName (dup), "user/cascading/s/deep/below");
1161 2 : keyDel (dup);
1162 :
1163 2 : elektraKeySetName (key, "system/cascading/s/deep/below", KEY_CASCADING_NAME);
1164 2 : succeed_if_same_string (keyName (key), "system/cascading/s/deep/below");
1165 2 : dup = keyDup (key);
1166 2 : succeed_if_same_string (keyName (dup), "system/cascading/s/deep/below");
1167 2 : keyDel (dup);
1168 :
1169 2 : elektraKeySetName (key, "order", KEY_META_NAME);
1170 2 : succeed_if_same_string (keyName (key), "order");
1171 2 : dup = keyDup (key);
1172 2 : succeed_if_same_string (keyName (dup), "order");
1173 2 : keyDel (dup);
1174 :
1175 2 : elektraKeySetName (key, "check/type", KEY_META_NAME);
1176 2 : succeed_if_same_string (keyName (key), "check/type");
1177 2 : dup = keyDup (key);
1178 2 : succeed_if_same_string (keyName (dup), "check/type");
1179 2 : keyDel (dup);
1180 :
1181 2 : elektraKeySetName (key, "a", KEY_META_NAME);
1182 2 : succeed_if_same_string (keyName (key), "a");
1183 2 : dup = keyDup (key);
1184 2 : succeed_if_same_string (keyName (dup), "a");
1185 2 : keyDel (dup);
1186 :
1187 2 : elektraKeySetName (key, "", KEY_EMPTY_NAME);
1188 2 : succeed_if_same_string (keyName (key), "");
1189 2 : succeed_if (key->key != 0, "null pointer?");
1190 2 : dup = keyDup (key);
1191 2 : succeed_if_same_string (keyName (dup), "");
1192 2 : keyDel (dup);
1193 :
1194 2 : elektraKeySetName (key, "", KEY_META_NAME | KEY_EMPTY_NAME);
1195 2 : succeed_if_same_string (keyName (key), "");
1196 2 : succeed_if (key->key != 0, "null pointer?");
1197 2 : dup = keyDup (key);
1198 2 : succeed_if_same_string (keyName (dup), "");
1199 2 : keyDel (dup);
1200 :
1201 2 : keySetName (key, 0);
1202 2 : succeed_if_same_string (keyName (key), "");
1203 2 : succeed_if (key->key != 0, "null pointer?");
1204 2 : dup = keyDup (key);
1205 2 : succeed_if_same_string (keyName (dup), "");
1206 2 : keyDel (dup);
1207 :
1208 2 : elektraKeySetName (key, "", KEY_META_NAME | KEY_CASCADING_NAME);
1209 2 : succeed_if_same_string (keyName (key), "");
1210 2 : succeed_if (key->key != 0, "null pointer?");
1211 2 : dup = keyDup (key);
1212 2 : succeed_if_same_string (keyName (dup), "");
1213 2 : keyDel (dup);
1214 :
1215 2 : elektraKeySetName (key, "/cascading", KEY_META_NAME | KEY_CASCADING_NAME);
1216 2 : succeed_if_same_string (keyName (key), "/cascading");
1217 2 : succeed_if (key->key != 0, "null pointer?");
1218 2 : dup = keyDup (key);
1219 2 : succeed_if_same_string (keyName (dup), "/cascading");
1220 2 : keyDel (dup);
1221 :
1222 2 : elektraKeySetName (key, "meta", KEY_META_NAME | KEY_CASCADING_NAME);
1223 2 : succeed_if_same_string (keyName (key), "meta");
1224 2 : succeed_if (key->key != 0, "null pointer?");
1225 2 : dup = keyDup (key);
1226 2 : succeed_if_same_string (keyName (dup), "meta");
1227 2 : keyDel (dup);
1228 :
1229 2 : elektraKeySetName (key, "other", KEY_META_NAME | KEY_CASCADING_NAME);
1230 2 : succeed_if_same_string (keyName (key), "other");
1231 2 : succeed_if (key->key != 0, "null pointer?");
1232 2 : dup = keyDup (key);
1233 2 : succeed_if_same_string (keyName (dup), "other");
1234 2 : keyDel (dup);
1235 :
1236 2 : elektraKeySetName (key, "other///meta", KEY_META_NAME | KEY_CASCADING_NAME);
1237 2 : succeed_if_same_string (keyName (key), "other/meta");
1238 2 : succeed_if (key->key != 0, "null pointer?");
1239 2 : dup = keyDup (key);
1240 2 : succeed_if_same_string (keyName (dup), "other/meta");
1241 2 : keyDel (dup);
1242 :
1243 2 : elektraKeySetName (key, "user:hello/test", KEY_META_NAME | KEY_CASCADING_NAME);
1244 2 : succeed_if_same_string (keyName (key), "user/test");
1245 2 : succeed_if (key->key != 0, "null pointer?");
1246 2 : dup = keyDup (key);
1247 2 : succeed_if_same_string (keyName (dup), "user/test");
1248 2 : keyDel (dup);
1249 :
1250 18 : for (int i = 0; i < 8; ++i)
1251 : {
1252 16 : int flags = 0;
1253 16 : if (i & 1) flags |= KEY_CASCADING_NAME;
1254 16 : if (i & 2) flags |= KEY_META_NAME;
1255 16 : if (i & 4) flags |= KEY_EMPTY_NAME;
1256 :
1257 16 : elektraKeySetName (key, "spec/test", flags);
1258 16 : succeed_if_same_string (keyName (key), "spec/test");
1259 16 : succeed_if (key->key != 0, "null pointer?");
1260 16 : dup = keyDup (key);
1261 16 : succeed_if_same_string (keyName (dup), "spec/test");
1262 16 : keyDel (dup);
1263 :
1264 16 : elektraKeySetName (key, "proc/test", flags);
1265 16 : succeed_if_same_string (keyName (key), "proc/test");
1266 16 : succeed_if (key->key != 0, "null pointer?");
1267 16 : dup = keyDup (key);
1268 16 : succeed_if_same_string (keyName (dup), "proc/test");
1269 16 : keyDel (dup);
1270 :
1271 16 : elektraKeySetName (key, "dir/test", flags);
1272 16 : succeed_if_same_string (keyName (key), "dir/test");
1273 16 : succeed_if (key->key != 0, "null pointer?");
1274 16 : dup = keyDup (key);
1275 16 : succeed_if_same_string (keyName (dup), "dir/test");
1276 16 : keyDel (dup);
1277 :
1278 16 : elektraKeySetName (key, "user:hello/test", flags);
1279 16 : succeed_if_same_string (keyName (key), "user/test");
1280 16 : succeed_if (key->key != 0, "null pointer?");
1281 16 : dup = keyDup (key);
1282 16 : succeed_if_same_string (keyName (dup), "user/test");
1283 16 : keyDel (dup);
1284 :
1285 16 : elektraKeySetName (key, "system/test", flags);
1286 16 : succeed_if_same_string (keyName (key), "system/test");
1287 16 : succeed_if (key->key != 0, "null pointer?");
1288 16 : dup = keyDup (key);
1289 16 : succeed_if_same_string (keyName (dup), "system/test");
1290 16 : keyDel (dup);
1291 : }
1292 :
1293 2 : keyDel (key);
1294 2 : }
1295 :
1296 2 : static void test_keyLock (void)
1297 : {
1298 2 : printf ("Test locking\n");
1299 :
1300 2 : Key * key = keyNew ("", KEY_LOCK_NAME, KEY_END);
1301 2 : Key * key2 = keyNew ("", KEY_LOCK_NAME, KEY_END);
1302 :
1303 2 : succeed_if (keySetName (key, "user") == -1, "read only name, not allowed to set");
1304 :
1305 2 : keyDel (key);
1306 2 : key = keyNew ("", KEY_LOCK_VALUE, KEY_END);
1307 :
1308 2 : succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
1309 2 : succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
1310 :
1311 2 : keyDel (key);
1312 2 : key = keyNew ("", KEY_LOCK_META, KEY_END);
1313 :
1314 2 : succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
1315 2 : succeed_if (keyCopyMeta (key, key2, "meta") == -1, "read only meta, not allowed to set");
1316 2 : succeed_if (keyCopyAllMeta (key, key2) == -1, "read only meta, not allowed to set");
1317 :
1318 2 : keyDel (key);
1319 2 : key = keyNew (0);
1320 :
1321 2 : keyLock (key, KEY_LOCK_NAME);
1322 2 : succeed_if (keySetName (key, "user") == -1, "read only name, not allowed to set");
1323 2 : succeed_if (keyAddName (key, "a") == -1, "read only name, not allowed to set");
1324 2 : succeed_if (keySetBaseName (key, "a") == -1, "read only name, not allowed to set");
1325 2 : succeed_if (keyAddBaseName (key, "a") == -1, "read only name, not allowed to set");
1326 :
1327 2 : keyDel (key);
1328 2 : key = keyNew (0);
1329 :
1330 2 : keyLock (key, KEY_LOCK_VALUE);
1331 :
1332 2 : succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
1333 2 : succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
1334 :
1335 2 : keyDel (key);
1336 2 : key = keyNew (0);
1337 :
1338 2 : keyLock (key, KEY_LOCK_META);
1339 :
1340 2 : succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
1341 2 : succeed_if (keyCopyMeta (key, key2, "meta") == -1, "read only meta, not allowed to set");
1342 2 : succeed_if (keyCopyAllMeta (key, key2) == -1, "read only meta, not allowed to set");
1343 :
1344 2 : keyDel (key);
1345 2 : keyDel (key2);
1346 2 : }
1347 :
1348 :
1349 2 : static void test_keyAddName (void)
1350 : {
1351 2 : Key * k = keyNew ("user", KEY_END);
1352 2 : keyAddName (k, "something");
1353 2 : succeed_if_same_string (keyName (k), "user/something");
1354 :
1355 2 : keyAddName (k, "with/slash");
1356 2 : succeed_if_same_string (keyName (k), "user/something/with/slash");
1357 2 : keyDel (k);
1358 :
1359 : #define TEST_ADD_NAME(base, toadd, result) \
1360 : do \
1361 : { \
1362 : k = keyNew (base, KEY_META_NAME, KEY_CASCADING_NAME, KEY_END); \
1363 : succeed_if (keyAddName (k, toadd) == sizeof (result), "could not add name"); \
1364 : succeed_if_same_string (keyName (k), result); \
1365 : keyDel (k); \
1366 : } while (0)
1367 :
1368 2 : TEST_ADD_NAME ("spec", "something", "spec/something");
1369 2 : TEST_ADD_NAME ("proc", "something", "proc/something");
1370 2 : TEST_ADD_NAME ("dir", "something", "dir/something");
1371 2 : TEST_ADD_NAME ("user", "something", "user/something");
1372 2 : TEST_ADD_NAME ("system", "something", "system/something");
1373 :
1374 2 : TEST_ADD_NAME ("meta", "something", "meta/something");
1375 2 : TEST_ADD_NAME ("meta/", "something", "meta/something");
1376 2 : TEST_ADD_NAME ("meta//", "something", "meta/something");
1377 :
1378 2 : TEST_ADD_NAME ("meta", "something/", "meta/something");
1379 2 : TEST_ADD_NAME ("meta", "something//", "meta/something");
1380 :
1381 2 : TEST_ADD_NAME ("meta", "/something", "meta/something");
1382 2 : TEST_ADD_NAME ("meta", "//something", "meta/something");
1383 :
1384 2 : TEST_ADD_NAME ("user", "./user", "user/user");
1385 2 : TEST_ADD_NAME ("user/", "./user", "user/user");
1386 2 : TEST_ADD_NAME ("user/", "/./user", "user/user");
1387 2 : TEST_ADD_NAME ("user/", "/////./user", "user/user");
1388 2 : TEST_ADD_NAME ("user", "../user", "user/user");
1389 :
1390 2 : TEST_ADD_NAME ("user/verylongstringtoremove", "../x", "user/x");
1391 2 : TEST_ADD_NAME ("user/huhu", "../x", "user/x");
1392 2 : TEST_ADD_NAME ("user/rem", "../x", "user/x");
1393 2 : TEST_ADD_NAME ("user/more/level", "../../x", "user/x");
1394 :
1395 2 : TEST_ADD_NAME ("user/something", "../user", "user/user");
1396 :
1397 2 : TEST_ADD_NAME ("/something", "user", "/something/user");
1398 2 : TEST_ADD_NAME ("/", "user", "/user");
1399 2 : TEST_ADD_NAME ("/s", "user", "/s/user");
1400 2 : TEST_ADD_NAME ("/s", "/user", "/s/user");
1401 2 : TEST_ADD_NAME ("/s", "../user", "/user");
1402 2 : TEST_ADD_NAME ("/s", "..//user", "/user");
1403 2 : TEST_ADD_NAME ("/more/level", "../..//user", "/user");
1404 2 : TEST_ADD_NAME ("/much/more/level/1/2/3", "../../../../../..//user", "/user");
1405 2 : TEST_ADD_NAME ("/much/more/level/1/2/3", "../../../../../../..//user", "/user");
1406 2 : TEST_ADD_NAME ("/much/more/level/1/2/3", "..///../../../../../../..//user", "/user");
1407 2 : TEST_ADD_NAME ("/much/more/level/1/2/3", "..///../../..////../../../..//user", "/user");
1408 2 : TEST_ADD_NAME ("/much/more/level/1/2/3", "../../....///../../..////../../../..//user", "/user");
1409 2 : TEST_ADD_NAME ("/s", ".../user", "/s/.../user");
1410 2 : TEST_ADD_NAME ("/s", "..a/user", "/s/..a/user");
1411 2 : TEST_ADD_NAME ("/s", "..../user", "/s/..../user");
1412 :
1413 : // TEST_ADD_NAME("user", "///sw/../sw//././MyApp", "user/sw/MyApp");
1414 2 : TEST_ADD_NAME ("user", "sw/../sw", "user/sw");
1415 :
1416 : #undef TEST_ADD_NAME
1417 : #define TEST_ADD_NAME(base, toadd, result) \
1418 : do \
1419 : { \
1420 : k = keyNew (base, KEY_META_NAME, KEY_CASCADING_NAME, KEY_END); \
1421 : succeed_if (keyAddName (k, toadd) == 0, "adding irrelevant wrong return"); \
1422 : succeed_if_same_string (keyName (k), result); \
1423 : keyDel (k); \
1424 : } while (0)
1425 :
1426 2 : TEST_ADD_NAME ("/", 0, "/");
1427 2 : TEST_ADD_NAME ("/", "", "/");
1428 2 : TEST_ADD_NAME ("/", "/", "/");
1429 2 : TEST_ADD_NAME ("/", "//", "/");
1430 2 : TEST_ADD_NAME ("//", "/", "/");
1431 2 : TEST_ADD_NAME ("//", "//", "/");
1432 2 : TEST_ADD_NAME ("///", "//", "/");
1433 2 : TEST_ADD_NAME ("//", "///", "/");
1434 2 : TEST_ADD_NAME ("///", "///", "/");
1435 2 : TEST_ADD_NAME ("///.", "///", "/");
1436 2 : TEST_ADD_NAME ("///.", "///.", "/");
1437 2 : TEST_ADD_NAME ("///.", "///./", "/");
1438 2 : TEST_ADD_NAME ("///./", "///.", "/");
1439 2 : TEST_ADD_NAME ("///./", "///./", "/");
1440 2 : TEST_ADD_NAME ("///./..", "///./", "/");
1441 2 : TEST_ADD_NAME ("///./..", "///./..", "/");
1442 2 : TEST_ADD_NAME ("///./..", "///./../", "/");
1443 2 : TEST_ADD_NAME ("///./../", "///./..", "/");
1444 2 : TEST_ADD_NAME ("///./../", "///./../", "/");
1445 :
1446 2 : k = keyNew ("system/elektra/mountpoints/_t_error/config", KEY_END);
1447 2 : keyAddName (k, "on_open/error");
1448 2 : succeed_if_same_string (keyName (k), "system/elektra/mountpoints/_t_error/config/on_open/error");
1449 2 : keyDel (k);
1450 :
1451 2 : k = keyNew ("user", KEY_END);
1452 2 : succeed_if (keyAddName (k, "bar\\/foo_bar\\/") == sizeof ("user/bar\\/foo_bar\\/"), "could not add name");
1453 2 : succeed_if_same_string (keyName (k), "user/bar\\/foo_bar\\/");
1454 2 : keyDel (k);
1455 :
1456 2 : k = keyNew ("user", KEY_END);
1457 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\/") == sizeof ("user/ba\\\\/foo_bar\\/"), "could not add name");
1458 2 : succeed_if_same_string (keyName (k), "user/ba\\\\/foo_bar\\/");
1459 2 : keyDel (k);
1460 :
1461 2 : k = keyNew ("user", KEY_END);
1462 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("user/ba\\\\/foo_bar\\//%"), "could not add name");
1463 2 : succeed_if_same_string (keyName (k), "user/ba\\\\/foo_bar\\//%");
1464 2 : keyDel (k);
1465 :
1466 2 : k = keyNew ("user:yl", KEY_END);
1467 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("user/ba\\\\/foo_bar\\//%"), "could not add name");
1468 2 : succeed_if_same_string (keyName (k), "user/ba\\\\/foo_bar\\//%");
1469 2 : keyDel (k);
1470 :
1471 2 : k = keyNew ("user:yl", KEY_END);
1472 2 : succeed_if (keyAddName (k, "ba\\\\foo_bar\\//%") == sizeof ("user/ba\\\\foo_bar\\//%"), "could not add name");
1473 2 : succeed_if_same_string (keyName (k), "user/ba\\\\foo_bar\\//%");
1474 2 : keyDel (k);
1475 :
1476 2 : k = keyNew ("system", KEY_END);
1477 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("system/ba\\\\/foo_bar\\//%"), "could not add name");
1478 2 : succeed_if_same_string (keyName (k), "system/ba\\\\/foo_bar\\//%");
1479 2 : keyDel (k);
1480 :
1481 2 : k = keyNew ("meta", KEY_META_NAME, KEY_END);
1482 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("meta/ba\\\\/foo_bar\\//%"), "could not add name");
1483 2 : succeed_if_same_string (keyName (k), "meta/ba\\\\/foo_bar\\//%");
1484 2 : keyDel (k);
1485 :
1486 2 : k = keyNew ("/", KEY_CASCADING_NAME, KEY_END);
1487 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("/ba\\\\/foo_bar\\//%"), "could not add name");
1488 2 : succeed_if_same_string (keyName (k), "/ba\\\\/foo_bar\\//%");
1489 2 : keyDel (k);
1490 :
1491 2 : k = keyNew ("/", KEY_CASCADING_NAME, KEY_END);
1492 2 : succeed_if (keyAddName (k, "ba\\\\/foo_bar\\//%") == sizeof ("/ba\\\\/foo_bar\\//%"), "could not add name");
1493 2 : succeed_if_same_string (keyName (k), "/ba\\\\/foo_bar\\//%");
1494 2 : keyDel (k);
1495 :
1496 2 : k = keyNew ("/", KEY_CASCADING_NAME, KEY_END);
1497 2 : succeed_if (keyAddName (k, "/\\\\/foo_bar\\//%") == sizeof ("/\\\\/foo_bar\\//%"), "could not add name");
1498 2 : succeed_if_same_string (keyName (k), "/\\\\/foo_bar\\//%");
1499 2 : keyDel (k);
1500 2 : }
1501 :
1502 2 : static void test_keyNeedSync (void)
1503 : {
1504 2 : printf ("Test key need sync\n");
1505 :
1506 2 : Key * k = keyNew (0);
1507 2 : succeed_if (!keyNeedSync (k), "no sync, because written like that in docu prior to 0.8.9");
1508 2 : keyDel (k);
1509 :
1510 2 : k = keyNew ("", KEY_END);
1511 2 : succeed_if (keyNeedSync (k), "fresh key should need sync");
1512 :
1513 2 : set_bit (k->flags, KEY_FLAG_SYNC);
1514 2 : succeed_if (keyNeedSync (k), "sync bit was set");
1515 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1516 2 : succeed_if (!keyNeedSync (k), "sync bit was cleared");
1517 :
1518 2 : keySetName (k, "");
1519 2 : succeed_if (keyNeedSync (k), "nothing done, but synced (impl-dep, could be optimized)");
1520 :
1521 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1522 2 : keySetName (k, "user/abc");
1523 2 : succeed_if (keyNeedSync (k), "new name, should definitely need sync");
1524 :
1525 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1526 2 : keySetString (k, "a str");
1527 2 : succeed_if (keyNeedSync (k), "new string, should definitely need sync");
1528 :
1529 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1530 2 : keySetBinary (k, "a str", 4);
1531 2 : succeed_if (keyNeedSync (k), "new binary, should definitely need sync");
1532 :
1533 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1534 2 : keySetMeta (k, "metakey", "metaval");
1535 2 : succeed_if (keyNeedSync (k), "new meta, should definitely need sync");
1536 :
1537 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1538 2 : Key * d = keyDup (k);
1539 2 : succeed_if (keyNeedSync (d), "dup key, should definitely need sync");
1540 :
1541 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1542 2 : clear_bit (d->flags, KEY_FLAG_SYNC);
1543 2 : succeed_if (keyCopy (d, k) != -1, "copy not successful");
1544 2 : succeed_if (keyNeedSync (d), "copy key, should definitely need sync");
1545 2 : succeed_if (!keyNeedSync (k), "sources sync flag should not be affected");
1546 2 : keyDel (d);
1547 :
1548 2 : keyIncRef (k);
1549 2 : succeed_if (!keyNeedSync (k), "ref counter should not affect sync");
1550 2 : keyDecRef (k);
1551 2 : succeed_if (!keyNeedSync (k), "ref counter should not affect sync");
1552 :
1553 :
1554 2 : keySetName (k, "");
1555 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1556 :
1557 2 : succeed_if (keySetBaseName (k, "") == -1, "could not set base name");
1558 2 : succeed_if (!keyNeedSync (k), "nothing done, so still no sync (impl-dep, could be deoptimized)");
1559 :
1560 2 : keySetName (k, "user/abc");
1561 2 : succeed_if (keyNeedSync (k), "name set, sync should be there");
1562 :
1563 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1564 2 : succeed_if (keySetBaseName (k, "xynz") != -1, "could not set base name");
1565 2 : succeed_if (keyNeedSync (k), "base name changed, sync should be there");
1566 :
1567 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1568 2 : succeed_if (keyAddBaseName (k, "foo") != -1, "could not add base name");
1569 2 : succeed_if (keyNeedSync (k), "base name changed, sync should be there");
1570 :
1571 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1572 2 : succeed_if (keyAddName (k, "bar") != -1, "could not add name");
1573 2 : succeed_if (keyNeedSync (k), "base name changed, sync should be there");
1574 :
1575 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1576 2 : succeed_if (keySetOwner (k, "someowner") != -1, "could not set owner");
1577 2 : succeed_if (keyNeedSync (k), "owner changed, sync should be there");
1578 :
1579 2 : keyDel (k);
1580 2 : }
1581 :
1582 2 : static void test_keyCopy (void)
1583 : {
1584 2 : printf ("test copy key\n");
1585 2 : Key * k = keyNew ("", KEY_END);
1586 2 : Key * c = keyNew ("user/name", KEY_END);
1587 :
1588 2 : succeed_if (keyCopy (c, k) != -1, "could not copy");
1589 2 : succeed_if_same_string (keyName (k), "");
1590 2 : succeed_if_same_string (keyName (c), "");
1591 :
1592 2 : succeed_if (elektraKeySetName (k, "/abc", KEY_CASCADING_NAME) != -1, "could not set cascading name");
1593 2 : succeed_if (keyCopy (c, k) != -1, "could not copy");
1594 2 : succeed_if_same_string (keyName (k), "/abc");
1595 2 : succeed_if_same_string (keyName (c), "/abc");
1596 :
1597 2 : keyDel (k);
1598 2 : keyDel (c);
1599 2 : }
1600 :
1601 2 : static void test_keyFixedNew (void)
1602 : {
1603 2 : printf ("test fixed new\n");
1604 2 : Key * k1 = keyNew (0);
1605 2 : Key * k2 = keyNew ("", KEY_SIZE, 0, KEY_VALUE, 0, KEY_END);
1606 2 : compare_key (k1, k2);
1607 2 : keyDel (k1);
1608 2 : keyDel (k2);
1609 :
1610 2 : k1 = keyNew ("user/hello", KEY_END);
1611 2 : k2 = keyNew ("user/hello", KEY_SIZE, 0, KEY_VALUE, 0, KEY_END);
1612 2 : compare_key (k1, k2);
1613 2 : keyDel (k1);
1614 2 : keyDel (k2);
1615 :
1616 2 : k1 = keyNew ("user/hello", KEY_VALUE, "hello", KEY_END);
1617 2 : k2 = keyNew ("user/hello", KEY_SIZE, 6, KEY_VALUE, "hello", KEY_END);
1618 2 : compare_key (k1, k2);
1619 2 : keyDel (k1);
1620 2 : keyDel (k2);
1621 2 : }
1622 :
1623 2 : static void test_keyFlags (void)
1624 : {
1625 2 : printf ("Test KEY_FLAGS\n");
1626 :
1627 2 : Key * key = keyNew ("user/foo", KEY_FLAGS, KEY_BINARY | KEY_LOCK_NAME | KEY_LOCK_VALUE | KEY_LOCK_META, KEY_END);
1628 2 : Key * key2 = NULL;
1629 :
1630 2 : succeed_if (keyIsBinary (key), "Could not set type to binary");
1631 :
1632 2 : succeed_if (keySetName (key, "system") == -1, "read only name, not allowed to set");
1633 2 : succeed_if (keyAddName (key, "bar") == -1, "read only name, not allowed to set");
1634 2 : succeed_if (keyAddBaseName (key, "bar") == -1, "read only name, not allowed to set");
1635 :
1636 2 : succeed_if (keySetString (key, "a") == -1, "read only string, not allowed to set");
1637 2 : succeed_if (keySetBinary (key, "a", 2) == -1, "read only string, not allowed to set");
1638 :
1639 2 : succeed_if (keySetMeta (key, "meta", "value") == -1, "read only meta, not allowed to set");
1640 2 : succeed_if (keyCopyMeta (key, key2, "meta") == -1, "read only meta, not allowed to set");
1641 2 : succeed_if (keyCopyAllMeta (key, key2) == -1, "read only meta, not allowed to set");
1642 :
1643 2 : keyDel (key);
1644 2 : keyDel (key2);
1645 2 : }
1646 :
1647 2 : int main (int argc, char ** argv)
1648 : {
1649 2 : printf ("KEY TESTS\n");
1650 2 : printf ("==================\n\n");
1651 :
1652 2 : init (argc, argv);
1653 :
1654 2 : test_keyRefcounter ();
1655 2 : test_keyHelpers ();
1656 2 : test_keyPlugin ();
1657 2 : test_keyNameEscape ();
1658 2 : test_keyNameUnescape ();
1659 2 : test_keyCompare ();
1660 2 : test_keyNewExtensions ();
1661 2 : test_keyComment ();
1662 2 : test_keyOwner ();
1663 2 : test_keyComment ();
1664 2 : test_keyDir ();
1665 2 : test_keyTime ();
1666 2 : test_keyMeta ();
1667 2 : test_owner ();
1668 2 : test_elektraKeySetName ();
1669 2 : test_keyLock ();
1670 2 : test_keyAddName ();
1671 2 : test_keyNeedSync ();
1672 2 : test_keyCopy ();
1673 2 : test_keyFixedNew ();
1674 2 : test_keyFlags ();
1675 :
1676 2 : printf ("\ntest_key RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
1677 :
1678 2 : return nbError;
1679 : }
|