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 : #define NUMBER_OF_NAMESPACES 6
12 :
13 : char * namespaces[] = { "/", "spec", "proc", "dir", "user", "system", 0 };
14 :
15 : struct test
16 : {
17 : char * testName;
18 : char * keyName;
19 :
20 : char * expectedKeyName;
21 : char * expectedBaseName;
22 : char * expectedFRootName;
23 : };
24 :
25 : struct test tstKeyName[] = {
26 : { "Normal key", "system/foo/bar", "system/foo/bar", "bar", "system" },
27 :
28 : {
29 : "Key containing redundant & trailing separator", "system//foo//bar//", "system/foo/bar", /* keyName */
30 : "bar", /* keyBaseName */
31 : "system", /* keyGetFullRootName */
32 : },
33 :
34 : {
35 : "Normal user key", "user/key", "user/key", /* keyName */
36 : "key", /* keyBaseName */
37 : "user", /* keyGetFullRootName */
38 : },
39 :
40 : {
41 : "Normal user key with owner", "user:owner/key", "user/key", /* keyName */
42 : "key", /* keyBaseName */
43 : "user:owner", /* keyGetFullRootName */
44 : },
45 :
46 : {
47 : "Depth user key with owner", "user:owner/folder/long/base/dir/key", "user/folder/long/base/dir/key", /* keyName */
48 : "key", /* keyBaseName */
49 : "user:owner", /* keyGetFullRootName */
50 : },
51 :
52 : #ifdef COMPAT
53 : {
54 : "Key containing escaped separator", "user:yl///foo\\///bar\\/foo_bar\\", "user/foo\\//bar\\/foo_bar\\", /* keyName */
55 : "bar/foo_bar\\", /* keyBaseName */
56 : "user:yl", /* keyGetFullRootName */
57 : },
58 : #endif
59 :
60 : {
61 : "Key containing escaped separator at the end", "user:yl///foo\\///bar\\/foo_bar\\/",
62 : "user/foo\\//bar\\/foo_bar\\/", /* keyName */
63 : "bar/foo_bar/", /* keyBaseName */
64 : "user:yl", /* keyGetFullRootName */
65 : },
66 :
67 : {
68 : "Key with empty part", "user///%", "user/%", /* keyName */
69 : "", /* keyBaseName */
70 : "", /* keyGetFullRootName */
71 :
72 : },
73 :
74 : {
75 : "Key with escaped %", "user///\\%", "user/\\%", /* keyName */
76 : "%", /* keyBaseName */
77 : "", /* keyGetFullRootName */
78 :
79 : },
80 :
81 : {
82 : "Key with multi escaped %", "user///\\\\%", "user/\\\\%", /* keyName */
83 : "\\%", /* keyBaseName */
84 : "", /* keyGetFullRootName */
85 :
86 : },
87 :
88 : {
89 : NULL, NULL, NULL, /* keyName */
90 : NULL, /* keyBaseName */
91 : NULL, /* keyGetFullRootName */
92 : }
93 : };
94 :
95 2 : static void test_keyNewSpecial (void)
96 : {
97 2 : printf ("Test special key creation\n");
98 :
99 2 : Key * k = keyNew (0);
100 2 : succeed_if_same_string (keyName (k), "");
101 2 : keyDel (k);
102 :
103 2 : k = keyNew (0, KEY_END); // might break, useless arguments?
104 2 : succeed_if_same_string (keyName (k), "");
105 2 : keyDel (k);
106 :
107 2 : k = keyNew ("", KEY_END);
108 2 : succeed_if_same_string (keyName (k), "");
109 2 : keyDel (k);
110 :
111 2 : k = keyNew ("invalid", KEY_END);
112 2 : succeed_if_same_string (keyName (k), "");
113 2 : keyDel (k);
114 :
115 :
116 2 : k = keyNew ("other invalid", KEY_END);
117 2 : succeed_if_same_string (keyName (k), "");
118 2 : keyDel (k);
119 :
120 2 : k = keyNew ("system spaces", KEY_END);
121 2 : succeed_if_same_string (keyName (k), "");
122 2 : keyDel (k);
123 :
124 2 : k = keyNew ("system/bin", KEY_BINARY, KEY_VALUE, "a 2d\0b", KEY_END);
125 2 : succeed_if_same_string (keyValue (k), "a 2d");
126 2 : succeed_if (keyGetValueSize (k) == sizeof ("a 2d"), "no KEY_SIZE given, so bin is truncated");
127 2 : succeed_if (keyIsBinary (k), "not a binary key");
128 2 : keyDel (k);
129 2 : }
130 :
131 2 : static void test_keyNewSystem (void)
132 : {
133 : Key * key;
134 2 : char array[] = "here is some data stored";
135 : Key * k1;
136 : Key * k2;
137 : Key * k3;
138 : char * getBack;
139 :
140 2 : printf ("Test system key creation\n");
141 :
142 : // Empty key
143 2 : key = keyNew (0);
144 2 : succeed_if (key != NULL, "keyNew: Unable to create a new empty key");
145 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete empty key");
146 :
147 : // Key with name
148 2 : key = keyNew ("system/sw/test", KEY_END);
149 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name");
150 2 : succeed_if_same_string (keyName (key), "system/sw/test");
151 2 : keyCopy (key, 0);
152 2 : succeed_if_same_string (keyName (key), "");
153 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
154 :
155 : // Key with name
156 2 : key = keyNew ("system/sw/test", KEY_END);
157 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name");
158 2 : succeed_if_same_string (keyName (key), "system/sw/test");
159 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
160 :
161 : // Key with name + value
162 2 : key = keyNew ("system/sw/test", KEY_VALUE, "test", KEY_END);
163 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name + value of default type");
164 2 : succeed_if_same_string (keyValue (key), "test");
165 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + value");
166 2 : key = keyNew ("system/valid/there", KEY_BINARY, KEY_SIZE, sizeof (array), KEY_VALUE, array, KEY_END);
167 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name + value of default type");
168 2 : succeed_if (keyIsBinary (key), "Could not set type to binary");
169 2 : succeed_if (keyGetValueSize (key) == sizeof (array), "Value size not correct");
170 2 : succeed_if (memcmp ((char *) keyValue (key), array, sizeof (array)) == 0, "could not get correct binary value");
171 2 : getBack = elektraMalloc (keyGetValueSize (key));
172 2 : keyGetBinary (key, getBack, keyGetValueSize (key));
173 2 : succeed_if (memcmp (getBack, array, sizeof (array)) == 0, "could not get correct value with keyGetBinary");
174 2 : elektraFree (getBack);
175 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name + owner");
176 :
177 2 : key = keyNew ("system", KEY_END);
178 2 : succeed_if_same_string (keyName (key), "system");
179 2 : succeed_if (keyGetNameSize (key) == 7, "empty name size");
180 2 : succeed_if (keyValue (keyGetMeta (key, "owner")) == 0, "owner not null");
181 2 : keyDel (key);
182 :
183 2 : key = keyNew ("user/abc", KEY_OWNER, "huhu", KEY_END);
184 2 : succeed_if_same_string (keyName (key), "user/abc");
185 2 : succeed_if (keyGetNameSize (key) == 9, "empty name size");
186 2 : succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "huhu");
187 2 : keyDel (key);
188 :
189 2 : key = keyNew ("user:lost/abc", KEY_OWNER, "huhu", KEY_END);
190 2 : succeed_if_same_string (keyName (key), "user/abc");
191 2 : succeed_if (keyGetNameSize (key) == 9, "empty name size");
192 2 : succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "huhu");
193 2 : keyDel (key);
194 :
195 2 : key = keyNew ("user:huhu/abc", KEY_END);
196 2 : succeed_if_same_string (keyName (key), "user/abc");
197 2 : succeed_if (keyGetNameSize (key) == 9, "empty name size");
198 2 : succeed_if_same_string (keyString (keyGetMeta (key, "owner")), "huhu");
199 2 : keyDel (key);
200 :
201 : // testing multiple values at once
202 2 : k1 = keyNew ("system/1", KEY_VALUE, "singlevalue", KEY_END);
203 2 : k2 = keyNew ("system/2", KEY_VALUE, "myvalue", KEY_END);
204 2 : k3 = keyNew ("system/3", KEY_VALUE, "syskey", KEY_END);
205 2 : succeed_if (k1 != NULL, "keyNew: Unable to create a key with name + value of default type");
206 2 : succeed_if (keyIsString (k1), "keyNew: Default key value isn't set to string");
207 2 : succeed_if_same_string (keyValue (k1), "singlevalue");
208 :
209 2 : succeed_if (k2 != NULL, "keyNew: Unable to create a key with name + value of default type");
210 2 : succeed_if (keyIsString (k2), "keyNew: Default key value isn't set to string");
211 2 : succeed_if_same_string (keyValue (k2), "myvalue");
212 :
213 2 : succeed_if (k3 != NULL, "keyNew: Unable to create a key with name + value of default type");
214 2 : succeed_if (keyIsString (k3), "keyNew: Default key value isn't set to string");
215 2 : succeed_if_same_string (keyValue (k3), "syskey");
216 :
217 2 : succeed_if (keyDel (k1) == 0, "keyDel: Unable to delete key with name + value");
218 2 : succeed_if (keyDel (k2) == 0, "keyDel: Unable to delete key with name + value");
219 2 : succeed_if (keyDel (k3) == 0, "keyDel: Unable to delete key with name + value");
220 2 : }
221 :
222 2 : static void test_keyNewUser (void)
223 : {
224 : Key * k1;
225 : Key * k2;
226 : Key * k3;
227 :
228 2 : printf ("Test user key creation\n");
229 : // testing multiple values at once
230 2 : k1 = keyNew ("user/1", KEY_VALUE, "singlevalue", KEY_END);
231 2 : k2 = keyNew ("user/2", KEY_VALUE, "myvalue", KEY_END);
232 2 : k3 = keyNew ("user/3", KEY_VALUE, "syskey", KEY_END);
233 2 : succeed_if (k1 != NULL, "keyNew: Unable to create a key with name + value of default type");
234 2 : succeed_if (keyIsString (k1), "keyNew: Default key value isn't set to string");
235 2 : succeed_if_same_string (keyValue (k1), "singlevalue");
236 :
237 2 : succeed_if (k2 != NULL, "keyNew: Unable to create a key with name + value of default type");
238 2 : succeed_if (keyIsString (k2), "keyNew: Default key value isn't set to string");
239 2 : succeed_if_same_string (keyValue (k2), "myvalue");
240 :
241 2 : succeed_if (k3 != NULL, "keyNew: Unable to create a key with name + value of default type");
242 2 : succeed_if (keyIsString (k3), "keyNew: Default key value isn't set to string");
243 2 : succeed_if_same_string (keyValue (k3), "syskey");
244 :
245 2 : succeed_if (keyDel (k1) == 0, "keyDel: Unable to delete key with name + value");
246 2 : succeed_if (keyDel (k2) == 0, "keyDel: Unable to delete key with name + value");
247 2 : succeed_if (keyDel (k3) == 0, "keyDel: Unable to delete key with name + value");
248 :
249 2 : k1 = keyNew ("invalid", KEY_END);
250 2 : succeed_if (k1 != 0, "should construct key even on invalid names");
251 2 : succeed_if_same_string (keyName (k1), "");
252 2 : succeed_if (keyGetNameSize (k1) == 1, "namesize");
253 2 : keyDel (k1);
254 2 : }
255 :
256 2 : static void test_keyReference (void)
257 : {
258 2 : printf ("Test key reference\n");
259 :
260 2 : Key * key = keyNew ("user/key", KEY_END);
261 2 : Key * c = keyNew ("user/c", KEY_END);
262 : Key * d;
263 : KeySet *ks1, *ks2;
264 2 : succeed_if (keyGetRef (key) == 0, "New created key reference");
265 :
266 2 : succeed_if (keyIncRef (key) == 1, "keyIncRef return value");
267 2 : succeed_if (keyGetRef (key) == 1, "After keyIncRef key reference");
268 2 : succeed_if (keyIncRef (key) == 2, "keyIncRef return value");
269 2 : succeed_if (keyGetRef (key) == 2, "After keyIncRef key reference");
270 2 : succeed_if (keyIncRef (key) == 3, "keyIncRef return value");
271 2 : succeed_if (keyGetRef (key) == 3, "After keyIncRef key reference");
272 2 : succeed_if (keyIncRef (key) == 4, "keyIncRef return value");
273 2 : succeed_if (keyGetRef (key) == 4, "After keyIncRef key reference");
274 :
275 2 : d = keyDup (key);
276 2 : succeed_if (keyGetRef (d) == 0, "After keyDup key reference");
277 2 : succeed_if (keyIncRef (d) == 1, "keyIncRef return value");
278 2 : succeed_if (keyGetRef (key) == 4, "Reference should not change");
279 2 : succeed_if (keyDecRef (d) == 0, "decrement key");
280 2 : succeed_if (keyDel (d) == 0, "last keyDel d, key exist");
281 :
282 2 : keyCopy (c, key);
283 2 : succeed_if (keyGetRef (c) == 0, "After keyCopy key reference");
284 2 : succeed_if (keyIncRef (c) == 1, "keyIncRef return value");
285 2 : succeed_if (keyGetRef (key) == 4, "Reference should not change");
286 :
287 2 : keyCopy (c, key);
288 2 : succeed_if (keyGetRef (c) == 1, "After keyCopy key reference");
289 2 : succeed_if (keyDecRef (c) == 0, "keyDecRef return value");
290 2 : succeed_if (keyGetRef (key) == 4, "Reference should not change");
291 :
292 2 : succeed_if (keyIncRef (c) == 1, "keyIncRef return value");
293 2 : succeed_if (keyIncRef (c) == 2, "keyIncRef return value");
294 2 : keyCopy (c, key);
295 2 : succeed_if (keyGetRef (c) == 2, "After keyCopy key reference");
296 2 : succeed_if (keyDecRef (c) == 1, "keyDecRef return value");
297 2 : succeed_if (keyDecRef (c) == 0, "keyDecRef return value");
298 2 : succeed_if (keyDel (c) == 0, "could not delete copy");
299 :
300 2 : succeed_if (keyGetRef (key) == 4, "After keyIncRef key reference");
301 2 : succeed_if (keyDecRef (key) == 3, "keyDel return value");
302 2 : succeed_if (keyDel (key) == 3, "should not do anything");
303 2 : succeed_if (keyGetRef (key) == 3, "After keyIncRef key reference");
304 2 : succeed_if (keyDecRef (key) == 2, "keyDel return value");
305 2 : succeed_if (keyDel (key) == 2, "should not do anything");
306 2 : succeed_if (keyGetRef (key) == 2, "After keyIncRef key reference");
307 2 : succeed_if (keyDecRef (key) == 1, "keyDel return value");
308 2 : succeed_if (keyDel (key) == 1, "should not do anything");
309 2 : succeed_if (keyGetRef (key) == 1, "Should have no more reference");
310 2 : succeed_if (keyDecRef (key) == 0, "last keyDel key, key exist");
311 2 : succeed_if (keyDel (key) == 0, "last keyDel key, key exist");
312 :
313 : /* From examples in ksNew () */
314 2 : key = keyNew (0); // ref counter 0
315 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
316 2 : keyIncRef (key); // ref counter of key 1
317 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
318 2 : keyDel (key); // has no effect
319 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
320 2 : keyDecRef (key); // ref counter back to 0
321 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
322 2 : keyDel (key); // key is now deleted
323 :
324 2 : ks1 = ksNew (0, KS_END);
325 2 : ks2 = ksNew (0, KS_END);
326 2 : key = keyNew ("user/key", KEY_END); // ref counter 0
327 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
328 2 : ksAppendKey (ks1, key); // ref counter of key 1
329 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
330 2 : ksAppendKey (ks2, key); // ref counter of key 2
331 2 : succeed_if (keyGetRef (key) == 2, "reference counter");
332 2 : ksDel (ks1); // ref counter of key 1
333 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
334 2 : ksDel (ks2); // key is now deleted
335 :
336 2 : key = keyNew (0); // ref counter 0
337 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
338 2 : keyIncRef (key); // ref counter of key 1
339 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
340 2 : keyDel (key); // has no effect
341 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
342 2 : keyIncRef (key); // ref counter of key 2
343 2 : succeed_if (keyGetRef (key) == 2, "reference counter");
344 2 : keyDel (key); // has no effect
345 2 : succeed_if (keyGetRef (key) == 2, "reference counter");
346 2 : keyDecRef (key); // ref counter of key 1
347 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
348 2 : keyDel (key); // has no effect
349 2 : succeed_if (keyGetRef (key) == 1, "reference counter");
350 2 : keyDecRef (key); // ref counter is now 0
351 2 : succeed_if (keyGetRef (key) == 0, "reference counter");
352 2 : keyDel (key); // key is now deleted
353 :
354 2 : Key * k = keyNew ("system/proper_name", KEY_END); // ref counter = 0
355 2 : succeed_if (keyGetRef (k) == 0, "ref should be zero");
356 2 : KeySet * ks = ksNew (1, k, KS_END);
357 2 : succeed_if (keyGetRef (k) == 1, "ref should be one");
358 2 : succeed_if (keyDel (k) == 1, "key will not be deleted, because its in the keyset");
359 2 : succeed_if (keyGetRef (k) == 1, "ref should be one");
360 2 : succeed_if (ksDel (ks) == 0, "could not del"); // now the key will be deleted
361 :
362 : return;
363 :
364 : /* This code needs very long to execute, especially on 64bit
365 : * systems. */
366 :
367 : key = keyNew (0); // ref counter 0
368 : while (keyGetRef (key) < SSIZE_MAX)
369 : keyIncRef (key);
370 : succeed_if (keyGetRef (key) == SSIZE_MAX, "reference counter");
371 : succeed_if (keyIncRef (key) == SSIZE_MAX, "should stay at maximum");
372 : succeed_if (keyGetRef (key) == SSIZE_MAX, "reference counter");
373 : succeed_if (keyIncRef (key) == SSIZE_MAX, "should stay at maximum");
374 : keyDel (key);
375 : }
376 :
377 2 : static void test_keyName (void)
378 : {
379 : Key * key;
380 : char ret[1000];
381 : size_t i;
382 2 : char testName[] = "user/name";
383 2 : char testFullName[] = "user:max/name";
384 : char testBaseName[] = "name";
385 :
386 : #ifdef HAVE_CLEARENV
387 2 : clearenv ();
388 : #else
389 : unsetenv ("USER");
390 : #endif
391 :
392 2 : printf ("Test Key Name\n");
393 :
394 2 : key = keyNew (testName, KEY_END);
395 2 : succeed_if (keyGetName (0, ret, 100) == -1, "null pointer");
396 2 : succeed_if (keyGetName (key, 0, 100) == -1, "string null pointer");
397 2 : succeed_if (keyGetName (key, ret, 0) == -1, "length checking");
398 18 : for (i = 1; i < sizeof (testName); i++)
399 : {
400 18 : succeed_if (keyGetName (key, ret, i) == -1, "length checking too short");
401 : }
402 20 : for (i = sizeof (testName); i < sizeof (testName) * 2; i++)
403 : {
404 20 : succeed_if (keyGetName (key, ret, i) == sizeof (testName), "length checking longer");
405 : }
406 2 : succeed_if (keyGetName (key, ret, (size_t) -1) == -1, "maxSize exceeded");
407 2 : keyDel (key);
408 :
409 2 : succeed_if (keyName (0) == 0, "null pointer");
410 :
411 2 : key = keyNew (0);
412 2 : succeed_if_same_string (keyName (key), "");
413 2 : succeed_if (keyGetName (key, ret, 1000) == 1, "get empty name");
414 2 : succeed_if_same_string (ret, "");
415 2 : succeed_if (keyGetName (key, ret, 0) == -1, "get empty name");
416 2 : keyDel (key);
417 :
418 2 : succeed_if (keySetName (0, ret) == -1, "Null pointer");
419 :
420 :
421 2 : printf ("Test Key Full Name\n");
422 :
423 2 : key = keyNew (testFullName, KEY_END);
424 2 : succeed_if (keyGetFullName (0, ret, 100) == -1, "null pointer");
425 2 : succeed_if (keyGetFullName (key, 0, 100) == -1, "string null pointer");
426 2 : succeed_if (keyGetFullName (key, ret, 0) == -1, "length checking");
427 26 : for (i = 1; i < sizeof (testFullName); i++)
428 : {
429 26 : succeed_if (keyGetFullName (key, ret, i) == -1, "length checking too short");
430 : }
431 28 : for (i = sizeof (testFullName); i < sizeof (testFullName) * 2; i++)
432 : {
433 28 : succeed_if (keyGetFullName (key, ret, i) == sizeof (testFullName), "length checking longer");
434 : }
435 2 : succeed_if (keyGetFullName (key, ret, (size_t) -1) == -1, "maxSize exceeded");
436 2 : keyDel (key);
437 :
438 2 : key = keyNew (0);
439 2 : succeed_if (keyGetFullName (key, ret, 1000) == 1, "get empty name");
440 2 : succeed_if_same_string (ret, "");
441 2 : succeed_if (keyGetFullName (key, ret, 0) == -1, "get empty name");
442 2 : keyDel (key);
443 :
444 2 : succeed_if (keySetName (0, ret) == -1, "Null pointer");
445 :
446 :
447 2 : printf ("Test Key Base Name\n");
448 :
449 2 : key = keyNew (testFullName, KEY_END);
450 2 : succeed_if (keyGetBaseName (0, ret, 100) == -1, "null pointer");
451 2 : succeed_if (keyGetBaseName (key, 0, 100) == -1, "string null pointer");
452 2 : succeed_if (keyGetBaseName (key, ret, 0) == -1, "length checking");
453 8 : for (i = 1; i < sizeof (testBaseName); i++)
454 : {
455 8 : succeed_if (keyGetBaseName (key, ret, i) == -1, "length checking too short");
456 : }
457 10 : for (i = sizeof (testBaseName); i < sizeof (testBaseName) * 2; i++)
458 : {
459 10 : succeed_if (keyGetBaseName (key, ret, i) == sizeof (testBaseName), "length checking longer");
460 : }
461 2 : succeed_if (keyGetBaseName (key, ret, (size_t) -1) == -1, "maxSize exceeded");
462 2 : keyDel (key);
463 :
464 2 : succeed_if (keyBaseName (0) == 0, "null pointer");
465 :
466 2 : key = keyNew (0);
467 2 : succeed_if_same_string (keyBaseName (key), "");
468 2 : succeed_if (keyGetBaseName (key, ret, 1000) == 1, "get empty name");
469 2 : succeed_if_same_string (ret, "");
470 2 : succeed_if (keyGetBaseName (key, ret, 0) == -1, "get empty name");
471 2 : keyDel (key);
472 :
473 2 : succeed_if (keySetName (0, ret) == -1, "Null pointer");
474 :
475 2 : key = keyNew ("user", KEY_END);
476 2 : succeed_if_same_string (keyName (key), "user");
477 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
478 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
479 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
480 2 : succeed_if_same_string (ret, "");
481 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
482 2 : succeed_if_same_string (ret, "");
483 2 : keyDel (key);
484 :
485 2 : key = keyNew ("user/", KEY_END);
486 2 : succeed_if_same_string (keyName (key), "user");
487 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
488 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
489 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
490 2 : succeed_if_same_string (ret, "");
491 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
492 2 : succeed_if_same_string (ret, "");
493 2 : keyDel (key);
494 :
495 2 : key = keyNew ("user//", KEY_END);
496 2 : succeed_if_same_string (keyName (key), "user");
497 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
498 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
499 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
500 2 : succeed_if_same_string (ret, "");
501 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
502 2 : succeed_if_same_string (ret, "");
503 2 : keyDel (key);
504 :
505 2 : key = keyNew ("system", KEY_END);
506 2 : succeed_if_same_string (keyName (key), "system");
507 2 : succeed_if (keyGetNameSize (key) == 7, "name length checking");
508 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
509 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
510 2 : succeed_if_same_string (ret, "");
511 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
512 2 : succeed_if_same_string (ret, "");
513 2 : keyDel (key);
514 :
515 2 : key = keyNew ("system/", KEY_END);
516 2 : succeed_if_same_string (keyName (key), "system");
517 2 : succeed_if (keyGetNameSize (key) == 7, "name length checking");
518 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
519 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
520 2 : succeed_if_same_string (ret, "");
521 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
522 2 : succeed_if_same_string (ret, "");
523 2 : keyDel (key);
524 :
525 2 : key = keyNew ("dir", KEY_END);
526 2 : succeed_if_same_string (keyName (key), "dir");
527 2 : succeed_if (keyGetNameSize (key) == 4, "name length checking");
528 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
529 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
530 2 : succeed_if_same_string (ret, "");
531 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
532 2 : succeed_if_same_string (ret, "");
533 2 : keyDel (key);
534 :
535 2 : key = keyNew ("dir/", KEY_END);
536 2 : succeed_if_same_string (keyName (key), "dir");
537 2 : succeed_if (keyGetNameSize (key) == 4, "name length checking");
538 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
539 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
540 2 : succeed_if_same_string (ret, "");
541 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
542 2 : succeed_if_same_string (ret, "");
543 2 : keyDel (key);
544 :
545 2 : key = keyNew ("proc", KEY_END);
546 2 : succeed_if_same_string (keyName (key), "proc");
547 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
548 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
549 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
550 2 : succeed_if_same_string (ret, "");
551 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
552 2 : succeed_if_same_string (ret, "");
553 2 : keyDel (key);
554 :
555 2 : key = keyNew ("proc/", KEY_END);
556 2 : succeed_if_same_string (keyName (key), "proc");
557 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
558 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
559 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
560 2 : succeed_if_same_string (ret, "");
561 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
562 2 : succeed_if_same_string (ret, "");
563 2 : keyDel (key);
564 :
565 2 : key = keyNew ("spec", KEY_END);
566 2 : succeed_if_same_string (keyName (key), "spec");
567 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
568 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
569 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
570 2 : succeed_if_same_string (ret, "");
571 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
572 2 : succeed_if_same_string (ret, "");
573 2 : keyDel (key);
574 :
575 2 : key = keyNew ("spec/", KEY_END);
576 2 : succeed_if_same_string (keyName (key), "spec");
577 2 : succeed_if (keyGetNameSize (key) == 5, "name length checking");
578 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
579 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
580 2 : succeed_if_same_string (ret, "");
581 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
582 2 : succeed_if_same_string (ret, "");
583 2 : keyDel (key);
584 :
585 2 : key = keyNew ("/", KEY_END);
586 2 : succeed_if_same_string (keyName (key), "/");
587 2 : succeed_if (keyGetNameSize (key) == 2, "name length checking");
588 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
589 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
590 2 : succeed_if_same_string (ret, "");
591 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
592 2 : succeed_if_same_string (ret, "");
593 2 : keyDel (key);
594 :
595 2 : key = keyNew ("//", KEY_END);
596 2 : succeed_if_same_string (keyName (key), "/");
597 2 : succeed_if (keyGetNameSize (key) == 2, "name length checking");
598 2 : succeed_if (keyGetBaseNameSize (key) == 1, "length checking");
599 2 : succeed_if (keyGetBaseName (key, ret, 1) == 1, "GetBaseName for root key");
600 2 : succeed_if_same_string (ret, "");
601 2 : succeed_if (keyGetBaseName (key, ret, 2) == 1, "GetBaseName for root key");
602 2 : succeed_if_same_string (ret, "");
603 2 : keyDel (key);
604 2 : }
605 :
606 :
607 2 : static void test_keyNameSlashes (void)
608 : {
609 2 : printf ("Test Slashes in Key Name\n");
610 : char * buf;
611 : char * getBack;
612 : char ret[1000];
613 2 : Key * key = 0;
614 : int i;
615 :
616 :
617 2 : key = keyNew (0);
618 2 : succeed_if (keyGetNameSize (key) == 1, "empty name size");
619 2 : keyDel (key);
620 :
621 2 : key = keyNew ("", KEY_END);
622 2 : succeed_if (key != 0, "key should not be null!");
623 2 : succeed_if_same_string (keyName (key), "");
624 2 : succeed_if (keyGetName (key, ret, 999) == 1, "keyGetName should return 1");
625 2 : succeed_if_same_string (ret, "");
626 2 : succeed_if (keyGetNameSize (key) == 1, "empty name size");
627 2 : keyDel (key);
628 :
629 2 : key = keyNew (0);
630 2 : keySetName (key, "user");
631 2 : succeed_if_same_string (keyName (key), "user");
632 2 : succeed_if (keyGetNameSize (key) == 5, "empty name size");
633 :
634 2 : keySetName (key, "system");
635 2 : succeed_if_same_string (keyName (key), "system");
636 2 : succeed_if (keyGetNameSize (key) == 7, "empty name size");
637 2 : keyDel (key);
638 :
639 2 : key = keyNew (0);
640 2 : keySetName (key, "system");
641 2 : succeed_if_same_string (keyName (key), "system");
642 2 : succeed_if (keyGetNameSize (key) == 7, "empty name size");
643 :
644 2 : keySetName (key, "user");
645 2 : succeed_if_same_string (keyName (key), "user");
646 2 : succeed_if (keyGetNameSize (key) == 5, "empty name size");
647 2 : keyDel (key);
648 :
649 2 : key = keyNew (0);
650 2 : succeed_if (keySetName (key, "user:") == 5, "setting user: generates error");
651 2 : succeed_if_same_string (keyName (key), "user");
652 2 : succeed_if (keyGetNameSize (key) == 5, "empty name size");
653 2 : keyDel (key);
654 :
655 2 : key = keyNew (0);
656 2 : succeed_if (keySetName (key, "user:y") == 5, "setting user: generates error");
657 2 : succeed_if_same_string (keyName (key), "user");
658 2 : succeed_if (keyGetNameSize (key) == 5, "empty name size");
659 2 : keyDel (key);
660 :
661 2 : key = keyNew (0);
662 2 : succeed_if (keySetName (key, "no") == -1, "no error code setting invalid name");
663 2 : succeed_if_same_string (keyName (key), "");
664 2 : succeed_if (keyGetNameSize (key) == 1, "empty name size");
665 2 : keyDel (key);
666 :
667 2 : key = keyNew ("user/noname", KEY_END);
668 2 : succeed_if (keyGetNameSize (key) == 12, "size not correct after keyNew");
669 2 : getBack = elektraMalloc (12);
670 2 : succeed_if (keyGetName (key, getBack, 12), "could not get name");
671 2 : succeed_if_same_string (getBack, "user/noname");
672 2 : elektraFree (getBack);
673 :
674 2 : keySetName (key, "user/noname");
675 2 : succeed_if (keyGetNameSize (key) == 12, "size not correct after keySetName");
676 2 : getBack = elektraMalloc (12);
677 2 : succeed_if (keyGetName (key, getBack, 12), "could not get name");
678 2 : succeed_if_same_string (getBack, "user/noname");
679 2 : elektraFree (getBack);
680 :
681 2 : keySetName (key, "no");
682 2 : succeed_if (keyGetNameSize (key) == 1, "size not correct after keySetName");
683 2 : getBack = elektraMalloc (1);
684 2 : succeed_if (keyGetName (key, getBack, 1), "could not get name");
685 2 : succeed_if_same_string (getBack, "");
686 2 : elektraFree (getBack);
687 2 : keyDel (key);
688 :
689 2 : key = keyNew ("user/noname", KEY_END);
690 2 : keySetName (key, "");
691 2 : succeed_if_same_string (keyName (key), "");
692 2 : succeed_if (keyGetName (key, ret, 999) == 1, "keyGetName should return 1");
693 2 : succeed_if_same_string (ret, "");
694 2 : succeed_if (keyGetNameSize (key) == 1, "empty name size");
695 :
696 2 : keySetName (key, "user//hidden");
697 2 : succeed_if_same_string (keyName (key), "user/hidden");
698 2 : succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
699 :
700 2 : keySetName (key, "user///hidden");
701 2 : succeed_if_same_string (keyName (key), "user/hidden");
702 2 : succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
703 :
704 2 : keySetName (key, "user////////////////////////////////////hidden");
705 2 : succeed_if_same_string (keyName (key), "user/hidden");
706 2 : succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
707 :
708 2 : printf ("Test trailing Slashes in Key Name\n");
709 2 : keySetName (key, "user//hidden/");
710 2 : succeed_if_same_string (keyName (key), "user/hidden");
711 2 : succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
712 :
713 2 : keySetName (key, "user//hidden//");
714 2 : succeed_if_same_string (keyName (key), "user/hidden");
715 2 : succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
716 :
717 2 : keySetName (key, "user//hidden///////");
718 2 : succeed_if_same_string (keyName (key), "user/hidden");
719 2 : succeed_if (keyGetNameSize (key) == 12, "name size minus slashes");
720 :
721 2 : keySetName (key, "user");
722 2 : succeed_if_same_string (keyName (key), "user");
723 :
724 2 : keySetName (key, "user/");
725 2 : succeed_if_same_string (keyName (key), "user");
726 :
727 2 : keySetName (key, "user/a");
728 2 : succeed_if_same_string (keyName (key), "user/a");
729 :
730 2 : keySetName (key, "user//");
731 2 : succeed_if_same_string (keyName (key), "user");
732 :
733 2 : keySetName (key, "user/////////");
734 2 : succeed_if_same_string (keyName (key), "user");
735 :
736 2 : printf ("Test Dots in Key Name\n");
737 2 : keySetName (key, "user/hidden/.");
738 2 : succeed_if_same_string (keyName (key), "user/hidden");
739 :
740 2 : keySetName (key, "user/.");
741 2 : succeed_if_same_string (keyName (key), "user");
742 :
743 2 : keySetName (key, "user/./hidden");
744 2 : succeed_if_same_string (keyName (key), "user/hidden");
745 :
746 2 : keySetName (key, "user/.valid/.");
747 2 : succeed_if_same_string (keyName (key), "user/.valid");
748 :
749 2 : keySetName (key, "user/./.valid");
750 2 : succeed_if_same_string (keyName (key), "user/.valid");
751 :
752 2 : keySetName (key, "user/./.valid/.");
753 2 : succeed_if_same_string (keyName (key), "user/.valid");
754 :
755 2 : keySetName (key, "user/././././.valid/././././.");
756 2 : succeed_if_same_string (keyName (key), "user/.valid");
757 :
758 2 : printf ("Test Double Dots in Key Name\n");
759 2 : keySetName (key, "user/hidden/parent/..");
760 2 : succeed_if_same_string (keyName (key), "user/hidden");
761 :
762 2 : keySetName (key, "user/hidden/..");
763 2 : succeed_if_same_string (keyName (key), "user");
764 :
765 2 : keySetName (key, "user/..");
766 2 : succeed_if_same_string (keyName (key), "user");
767 :
768 2 : keySetName (key, "user/hidden/../..");
769 : // printf ("Name: %s\n", keyName(key));
770 2 : succeed_if_same_string (keyName (key), "user");
771 :
772 2 : succeed_if (keySetName (key, "user///sw/../sw//././MyApp") == sizeof ("user/sw/MyApp"), "could not set keySet example");
773 : // printf("%s %d\n", keyName(key), keyGetNameSize(key));
774 2 : succeed_if_same_string (keyName (key), "user/sw/MyApp");
775 2 : succeed_if (keyGetNameSize (key) == sizeof ("user/sw/MyApp"), "incorrect length for keySet example");
776 :
777 2 : printf ("Test Mixed Dots and Slashes in Key Name\n");
778 2 : keySetName (key, "user/hidden/../.");
779 :
780 2 : keyDel (key);
781 :
782 :
783 2 : printf ("Test failure key creation\n");
784 :
785 2 : key = keyNew ("invalid", KEY_END);
786 2 : succeed_if (key != 0, "null pointer for invalid name");
787 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
788 :
789 2 : key = keyNew ("nonhere/valid/there", KEY_END);
790 2 : succeed_if (key != NULL, "keyNew did not accept wrong name");
791 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
792 :
793 2 : key = keyNew ("nonhere:y/valid/there", KEY_END);
794 2 : succeed_if (key != NULL, "keyNew did not accept wrong name");
795 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
796 :
797 2 : key = keyNew ("user/validname", KEY_END);
798 2 : succeed_if (key != NULL, "keyNew: Unable to create a key with name");
799 2 : succeed_if_same_string (keyName (key), "user/validname");
800 :
801 2 : keySetName (key, "invalid");
802 2 : succeed_if (keyGetNameSize (key) == 1, "name size for invalid name");
803 2 : succeed_if_same_string (keyName (key), "");
804 :
805 2 : keySetName (key, "user/validname");
806 2 : succeed_if_same_string (keyName (key), "user/validname");
807 :
808 2 : keySetName (key, "");
809 2 : succeed_if (keyGetNameSize (key) == 1, "name size for invalid name");
810 2 : succeed_if_same_string (keyName (key), "");
811 :
812 2 : keySetName (key, "user/validname\\/t");
813 2 : succeed_if_same_string (keyName (key), "user/validname\\/t");
814 :
815 2 : keySetName (key, 0);
816 2 : succeed_if (keyGetNameSize (key) == 1, "name size for invalid name");
817 2 : succeed_if_same_string (keyName (key), "");
818 :
819 : #ifdef COMPAT
820 : keySetName (key, "user/validname\\");
821 : succeed_if_same_string (keyName (key), "user/validname\\");
822 : #endif
823 :
824 2 : keySetName (key, "user/validname\\/");
825 2 : succeed_if_same_string (keyName (key), "user/validname\\/");
826 2 : succeed_if (keyDel (key) == 0, "keyDel: Unable to delete key with name");
827 :
828 2 : printf ("Test key's name manipulation\n");
829 :
830 2 : Key * copy = keyNew (0);
831 :
832 20 : for (i = 0; tstKeyName[i].testName != NULL; i++)
833 : {
834 18 : key = keyNew (tstKeyName[i].keyName, KEY_END);
835 :
836 18 : succeed_if (keyGetRef (copy) == 0, "reference of copy not correct");
837 18 : keyCopy (copy, key);
838 18 : succeed_if (keyGetRef (copy) == 0, "reference of copy not correct");
839 :
840 18 : Key * dup = keyDup (key);
841 18 : succeed_if (keyGetRef (dup) == 0, "reference of dup not correct");
842 :
843 18 : compare_key (copy, key);
844 18 : compare_key (copy, dup);
845 18 : compare_key (dup, key);
846 :
847 : /* keyName */
848 18 : succeed_if_same_string (keyName (key), tstKeyName[i].expectedKeyName);
849 18 : succeed_if_same_string (keyName (copy), tstKeyName[i].expectedKeyName);
850 18 : succeed_if_same_string (keyName (dup), tstKeyName[i].expectedKeyName);
851 :
852 : /* keyBaseName */
853 18 : succeed_if_same_string (keyBaseName (key), tstKeyName[i].expectedBaseName);
854 18 : succeed_if_same_string (keyBaseName (copy), tstKeyName[i].expectedBaseName);
855 18 : succeed_if_same_string (keyBaseName (dup), tstKeyName[i].expectedBaseName);
856 :
857 : /* keyGetBaseNameSize */
858 18 : size_t size = keyGetBaseNameSize (key);
859 18 : succeed_if ((size == strlen (tstKeyName[i].expectedBaseName) + 1), "keyGetBaseNameSize");
860 :
861 : /* keyGetBaseName */
862 18 : size = keyGetBaseNameSize (key) + 1;
863 18 : buf = elektraMalloc (size * sizeof (char));
864 18 : keyGetBaseName (key, buf, size);
865 18 : succeed_if_same_string (buf, tstKeyName[i].expectedBaseName);
866 18 : elektraFree (buf);
867 :
868 : /* keyGetNameSize */
869 18 : size = keyGetNameSize (key);
870 18 : succeed_if ((size == strlen (tstKeyName[i].expectedKeyName) + 1), "keyGetKeyNameSize");
871 :
872 : /* keyGetName */
873 18 : size = keyGetNameSize (key);
874 18 : buf = elektraMalloc (size * sizeof (char));
875 18 : keyGetName (key, buf, size);
876 18 : succeed_if_same_string (buf, tstKeyName[i].expectedKeyName);
877 18 : elektraFree (buf);
878 :
879 18 : keyDel (key);
880 18 : keyDel (dup);
881 : }
882 2 : keyDel (copy);
883 2 : }
884 :
885 :
886 2 : static void test_keyValue (void)
887 : {
888 : Key * key;
889 : char ret[1000];
890 : size_t i;
891 2 : char testString[] = "teststring";
892 2 : char testBinary[] = "\0tes\1tbinary";
893 2 : testBinary[sizeof (testBinary) - 1] = 'T';
894 :
895 2 : printf ("Test value of keys\n");
896 :
897 2 : succeed_if (key = keyNew (0), "could not create new key");
898 2 : succeed_if (keyGetValueSize (key) == 1, "empty value size");
899 2 : succeed_if (keySetString (key, "perfectvalue") == 13, "could not set string");
900 2 : succeed_if (keyGetValueSize (key) == 13, "value size not correct");
901 2 : succeed_if_same_string (keyValue (key), "perfectvalue");
902 2 : succeed_if (keySetString (key, "perfectvalue") == 13, "could not re-set same string");
903 2 : succeed_if_same_string (keyValue (key), "perfectvalue");
904 2 : succeed_if (keySetString (key, "nearperfectvalue") == 17, "could not re-set other string");
905 2 : succeed_if (keyGetValueSize (key) == 17, "value size not correct");
906 2 : succeed_if_same_string (keyValue (key), "nearperfectvalue");
907 2 : succeed_if (keyGetString (key, ret, keyGetValueSize (key) >= 999 ? 999 : keyGetValueSize (key)) == 17, "could not get string");
908 2 : succeed_if_same_string (ret, "nearperfectvalue");
909 2 : succeed_if (keyDel (key) == 0, "could not delete key");
910 :
911 2 : succeed_if (key = keyNew (0), "could not create new key");
912 2 : succeed_if_same_string (keyValue (key), "");
913 2 : succeed_if (keyGetValueSize (key) == 1, "Empty value size problem");
914 2 : succeed_if (keySetString (key, "") == 1, "could not set empty string");
915 2 : succeed_if_same_string (keyValue (key), "");
916 2 : succeed_if (keyGetValueSize (key) == 1, "Empty value size problem");
917 2 : succeed_if (keyGetString (key, ret, 0) == -1, "Could not get empty value");
918 2 : succeed_if (keyGetString (key, ret, 1) == 1, "Could not get empty value");
919 2 : succeed_if (ret[0] == 0, "keyGetValue did not return empty value");
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 (keySetString (key, "a long long string") == 19, "could not set string");
924 2 : succeed_if (keyGetString (key, ret, 6) == -1, "string not truncated");
925 2 : succeed_if (keyGetBinary (key, ret, 999) == -1, "binary not mismatch");
926 2 : succeed_if (keyDel (key) == 0, "could not delete key");
927 :
928 2 : succeed_if (key = keyNew (0), "could not create new key");
929 2 : succeed_if (keySetBinary (key, "a", 1) == 1, "could not set binary");
930 2 : succeed_if (keyIsString (key) == 0, "is not a string");
931 2 : succeed_if (keyIsBinary (key) == 1, "is not a string");
932 2 : succeed_if (keyGetBinary (key, ret, 1) == 1, "binary not truncated");
933 2 : succeed_if (!strncmp (ret, "a", 1), "binary value wrong");
934 2 : succeed_if (keyGetString (key, ret, 999) == -1, "string not mismatch");
935 2 : succeed_if (keySetString (key, 0) == 1, "wrong error code for SetString");
936 2 : succeed_if (keyDel (key) == 0, "could not delete key");
937 :
938 2 : succeed_if (key = keyNew (0), "could not create new key");
939 2 : succeed_if (keySetBinary (key, NULL, 0) == 0, "could not set null binary");
940 2 : succeed_if (keyIsString (key) == 0, "is not a string");
941 2 : succeed_if (keyIsBinary (key) == 1, "is not a string");
942 2 : succeed_if (keyGetValueSize (key) == 0, "Empty value size problem");
943 2 : succeed_if (keyDel (key) == 0, "could not delete key");
944 :
945 2 : succeed_if (key = keyNew (0), "could not create new key");
946 2 : succeed_if (keySetString (key, "") == 1, "could not set empty string");
947 2 : succeed_if (keyIsString (key) == 1, "is not a string");
948 2 : succeed_if (keyIsBinary (key) == 0, "is a binary");
949 2 : succeed_if (keyGetValueSize (key) == 1, "Empty value size problem");
950 2 : succeed_if (keyDel (key) == 0, "could not delete key");
951 :
952 2 : succeed_if (key = keyNew (0), "could not create new key");
953 2 : succeed_if (keySetBinary (key, "a long long binary", 19) == 19, "could not set string");
954 2 : succeed_if (keyIsString (key) == 0, "is not a string");
955 2 : succeed_if (keyIsBinary (key) == 1, "is not a string");
956 2 : succeed_if (keyGetBinary (key, ret, 6) == -1, "binary not truncated");
957 2 : succeed_if (keyGetBinary (key, ret, 19) == 19, "could not get binary");
958 2 : succeed_if (!strncmp (ret, "a long long binary", 19), "binary value wrong");
959 2 : succeed_if (keyGetString (key, ret, 999) == -1, "string not mismatch");
960 2 : succeed_if (keyDel (key) == 0, "could not delete key");
961 :
962 2 : succeed_if (key = keyNew (0), "could not create new key");
963 508 : for (i = 1; i < 255; i++)
964 : {
965 508 : ret[0] = i;
966 508 : ret[1] = i;
967 508 : ret[2] = 0;
968 : // output_key (key);
969 508 : succeed_if (keySetString (key, ret) == 3, "could not set string");
970 508 : succeed_if_same_string (keyValue (key), ret);
971 : }
972 2 : succeed_if (keyDel (key) == 0, "could not delete key");
973 :
974 :
975 2 : succeed_if (key = keyNew (0), "could not create new key");
976 510 : for (i = 0; i < 255; i++)
977 : {
978 510 : ret[0] = i;
979 510 : ret[1] = 255 - i;
980 510 : ret[2] = i;
981 : // output_key (key);
982 510 : succeed_if (keySetBinary (key, ret, 3) == 3, "could not set string");
983 510 : succeed_if (memcmp (keyValue (key), ret, 3) == 0, "String not same as set");
984 : }
985 2 : succeed_if (keyDel (key) == 0, "could not delete key");
986 :
987 :
988 2 : printf ("Test string of key\n");
989 :
990 2 : succeed_if (keyValue (0) == 0, "null pointer");
991 2 : succeed_if (keyGetValueSize (0) == -1, "null pointer");
992 2 : succeed_if (keySetString (0, "") == -1, "null pointer");
993 :
994 2 : key = keyNew (0);
995 2 : succeed_if (keyGetValueSize (key) == 1, "empty value size");
996 :
997 2 : keySetString (key, testString);
998 2 : succeed_if (keyGetString (0, ret, 100) == -1, "null pointer");
999 2 : succeed_if (keyGetString (key, 0, 100) == -1, "string null pointer");
1000 2 : succeed_if (keyGetString (key, ret, 0) == -1, "length checking");
1001 :
1002 20 : for (i = 1; i < sizeof (testString); i++)
1003 : {
1004 20 : succeed_if (keyGetString (key, ret, i) == -1, "length checking too short");
1005 : }
1006 22 : for (i = sizeof (testString); i < sizeof (testString) * 2; i++)
1007 : {
1008 22 : succeed_if (keyGetString (key, ret, i) == sizeof (testString), "length checking longer");
1009 : }
1010 2 : succeed_if (keyGetString (key, ret, (size_t) -1) == -1, "maxSize exceeded");
1011 :
1012 2 : succeed_if (keySetString (key, 0) == 1, "delete string");
1013 2 : succeed_if (keyGetString (key, ret, i) == 1, "length checking deleting");
1014 2 : succeed_if_same_string (ret, "");
1015 :
1016 2 : succeed_if (keySetString (key, testString) == sizeof (testString), "set string");
1017 2 : succeed_if (keyGetString (key, ret, i) == sizeof (testString), "length checking working");
1018 2 : succeed_if_same_string (ret, testString);
1019 :
1020 2 : succeed_if (keySetString (key, "") == 1, "delete string");
1021 2 : succeed_if (keyGetString (key, ret, i) == 1, "length checking deleting");
1022 2 : succeed_if_same_string (ret, "");
1023 :
1024 2 : succeed_if (keySetString (key, testString) == sizeof (testString), "set string");
1025 2 : succeed_if (keyGetString (key, ret, i) == sizeof (testString), "length checking working");
1026 2 : succeed_if_same_string (ret, testString);
1027 :
1028 2 : succeed_if (keyGetValueSize (key) == sizeof (testString), "testString value size");
1029 2 : succeed_if (strncmp (keyValue (key), testString, sizeof (testString)) == 0, "testString not same");
1030 2 : keyDel (key);
1031 :
1032 :
1033 2 : printf ("Test binary of key\n");
1034 :
1035 2 : succeed_if (keyValue (0) == 0, "null pointer");
1036 2 : succeed_if (keyGetValueSize (0) == -1, "null pointer");
1037 2 : succeed_if (keySetBinary (0, "", 1) == -1, "null pointer");
1038 :
1039 2 : key = keyNew (0);
1040 2 : succeed_if (keySetBinary (key, "", 0) == -1, "null size");
1041 2 : succeed_if (keySetBinary (key, "b", 0) == -1, "null size");
1042 2 : succeed_if (keySetBinary (key, "", SIZE_MAX) == -1, "max size");
1043 2 : succeed_if (keySetBinary (key, "b", SIZE_MAX) == -1, "max size");
1044 2 : succeed_if (keyGetValueSize (key) == 1, "empty value size");
1045 :
1046 2 : keySetBinary (key, testBinary, sizeof (testBinary));
1047 2 : succeed_if (keyGetBinary (0, ret, 100) == -1, "null pointer");
1048 2 : succeed_if (keyGetBinary (key, 0, 100) == -1, "binary null pointer");
1049 2 : succeed_if (keyGetBinary (key, ret, 0) == -1, "length checking");
1050 :
1051 24 : for (i = 1; i < sizeof (testBinary); i++)
1052 : {
1053 24 : succeed_if (keyGetBinary (key, ret, i) == -1, "length checking too short");
1054 : }
1055 26 : for (i = sizeof (testBinary); i < sizeof (testBinary) * 2; i++)
1056 : {
1057 26 : succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking longer");
1058 : }
1059 2 : succeed_if (keyGetBinary (key, ret, (size_t) -1) == -1, "maxSize exceeded");
1060 :
1061 2 : succeed_if (keySetBinary (key, 0, 0) == 0, "delete binary");
1062 2 : succeed_if (keyGetBinary (key, ret, i) == 0, "length checking deleting");
1063 :
1064 2 : succeed_if (keySetBinary (key, testBinary, sizeof (testBinary)) == sizeof (testBinary), "set binary");
1065 2 : succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking working");
1066 2 : succeed_if_same_string (ret, testBinary);
1067 :
1068 2 : succeed_if (keySetBinary (key, 0, 1) == 0, "delete binary");
1069 2 : succeed_if (keyGetBinary (key, ret, i) == 0, "length checking deleting");
1070 :
1071 2 : succeed_if (keySetBinary (key, testBinary, sizeof (testBinary)) == sizeof (testBinary), "set binary");
1072 2 : succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking working");
1073 2 : succeed_if_same_string (ret, testBinary);
1074 :
1075 2 : succeed_if (keySetBinary (key, "", 1) == 1, "delete binary the string way");
1076 2 : succeed_if (keyGetBinary (key, ret, i) == 1, "length checking deleting string way");
1077 2 : succeed_if_same_string (ret, "");
1078 :
1079 2 : succeed_if (keySetBinary (key, testBinary, sizeof (testBinary)) == sizeof (testBinary), "set binary");
1080 2 : succeed_if (keyGetBinary (key, ret, i) == sizeof (testBinary), "length checking working");
1081 2 : succeed_if_same_string (ret, testBinary);
1082 :
1083 2 : succeed_if (keyGetValueSize (key) == sizeof (testBinary), "testBinary value size");
1084 2 : succeed_if (strncmp (keyValue (key), testBinary, sizeof (testBinary)) == 0, "testBinary not same");
1085 2 : keyDel (key);
1086 2 : }
1087 :
1088 2 : static void test_keyBinary (void)
1089 : {
1090 2 : Key * key = 0;
1091 : char ret[1000];
1092 : int i;
1093 2 : char binaryData[] = "\0binary \1\34data";
1094 2 : binaryData[sizeof (binaryData) - 1] = 'T';
1095 :
1096 2 : printf ("Test binary special cases\n");
1097 :
1098 2 : key = keyNew ("user/binary", KEY_BINARY, KEY_END);
1099 :
1100 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1101 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1102 2 : succeed_if (keyGetValueSize (key) == 0, "size not correct");
1103 2 : succeed_if (keyValue (key) == 0, "should be null key");
1104 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1105 :
1106 2 : keyDel (key);
1107 :
1108 2 : key = keyNew ("user/binary", KEY_BINARY, KEY_SIZE, sizeof (binaryData), KEY_VALUE, binaryData, KEY_END);
1109 :
1110 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1111 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1112 2 : succeed_if (keyGetValueSize (key) == sizeof (binaryData), "size not correct");
1113 2 : succeed_if (memcmp (binaryData, keyValue (key), sizeof (binaryData)) == 0, "memcmp");
1114 2 : succeed_if (keyGetBinary (key, ret, 1000) == sizeof (binaryData), "could not get binary data");
1115 2 : succeed_if (memcmp (binaryData, ret, sizeof (binaryData)) == 0, "memcmp");
1116 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1117 :
1118 2 : keyDel (key);
1119 :
1120 2 : key = keyNew (0);
1121 2 : keySetBinary (key, binaryData, sizeof (binaryData));
1122 :
1123 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1124 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1125 2 : succeed_if (keyGetValueSize (key) == sizeof (binaryData), "size not correct");
1126 2 : succeed_if (memcmp (binaryData, keyValue (key), sizeof (binaryData)) == 0, "memcmp");
1127 2 : succeed_if (keyGetBinary (key, ret, 1000) == sizeof (binaryData), "could not get binary data");
1128 2 : succeed_if (memcmp (binaryData, ret, sizeof (binaryData)) == 0, "memcmp");
1129 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1130 :
1131 2 : keyDel (key);
1132 :
1133 2 : key = keyNew (0);
1134 2 : keySetBinary (key, 0, 0);
1135 :
1136 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1137 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1138 2 : succeed_if (keyGetValueSize (key) == 0, "size not correct");
1139 2 : succeed_if (keyValue (key) == 0, "should be null pointer");
1140 2 : succeed_if (keyGetBinary (key, ret, 1000) == 0, "should write nothing because of no data");
1141 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1142 :
1143 2 : keyDel (key);
1144 :
1145 2 : key = keyNew (0);
1146 2 : keySetBinary (key, 0, 1);
1147 :
1148 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1149 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1150 2 : succeed_if (keyGetValueSize (key) == 0, "size not correct");
1151 2 : succeed_if (keyValue (key) == 0, "should be null pointer");
1152 2 : succeed_if (keyGetBinary (key, ret, 1000) == 0, "should write nothing because of no data");
1153 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1154 :
1155 2 : keyDel (key);
1156 :
1157 2 : key = keyNew (0);
1158 2 : keySetBinary (key, "", 1);
1159 2 : succeed_if (keySetBinary (key, 0, SIZE_MAX) == -1, "should do nothing and fail");
1160 2 : succeed_if (keySetBinary (key, 0, SSIZE_MAX) == 0, "should free data");
1161 :
1162 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1163 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1164 2 : succeed_if (keyGetValueSize (key) == 0, "size not correct");
1165 2 : succeed_if (keyValue (key) == 0, "should be null pointer");
1166 2 : succeed_if (keyGetBinary (key, ret, 1000) == 0, "should write nothing because of no data");
1167 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1168 :
1169 2 : keyDel (key);
1170 :
1171 2 : key = keyNew (0);
1172 2 : keySetBinary (key, "", 1);
1173 :
1174 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1175 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1176 2 : succeed_if (keyGetValueSize (key) == 1, "size not correct");
1177 2 : succeed_if (memcmp (binaryData, keyValue (key), 1) == 0, "memcmp");
1178 2 : succeed_if (keyGetBinary (key, ret, 1000) == 1, "could not get binary data");
1179 2 : succeed_if (memcmp (binaryData, ret, 1) == 0, "memcmp");
1180 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1181 :
1182 2 : keyDel (key);
1183 :
1184 2 : key = keyNew (0);
1185 2 : i = 23;
1186 2 : keySetBinary (key, (void *) &i, sizeof (i));
1187 :
1188 2 : succeed_if (keyIsBinary (key) == 1, "should be binary");
1189 2 : succeed_if (keyIsString (key) == 0, "should not be string");
1190 2 : succeed_if (keyGetValueSize (key) == sizeof (i), "size not correct");
1191 2 : succeed_if (memcmp ((void *) &i, keyValue (key), sizeof (i)) == 0, "memcmp");
1192 2 : succeed_if (keyGetBinary (key, ret, 1000) == sizeof (i), "could not get binary data");
1193 2 : succeed_if (memcmp ((void *) &i, ret, sizeof (i)) == 0, "memcmp");
1194 2 : succeed_if (keyGetString (key, ret, 1000) == -1, "should be type mismatch");
1195 :
1196 2 : i = *(int *) keyValue (key);
1197 2 : succeed_if (i == 23, "incorrect int");
1198 :
1199 2 : keyDel (key);
1200 2 : }
1201 :
1202 2 : static void test_keyInactive (void)
1203 : {
1204 2 : Key * key = keyNew (0);
1205 :
1206 2 : succeed_if (keyIsInactive (0) == -1, "NULL pointer");
1207 2 : succeed_if (keyIsInactive (key) == -1, "Key has no name");
1208 :
1209 2 : printf ("Test of active and inactive keys\n");
1210 2 : keySetName (key, "user/valid");
1211 2 : succeed_if (!keyIsInactive (key), "Key should not be inactive");
1212 :
1213 2 : keySetName (key, "user/.hidden/valid");
1214 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1215 :
1216 2 : keySetName (key, "user/.hidden/€valid");
1217 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1218 :
1219 2 : keySetName (key, "user/..hidden/valid");
1220 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1221 :
1222 2 : keySetName (key, "user/hidden");
1223 2 : succeed_if (!keyIsInactive (key), "Key should not be inactive");
1224 :
1225 2 : keySetName (key, "user/.hidden");
1226 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1227 :
1228 2 : keySetName (key, "user/.valid/.hidden");
1229 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1230 :
1231 2 : keySetName (key, "user/.valid/.:hidden");
1232 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1233 :
1234 2 : keySetName (key, "user/.valid/.€hidden");
1235 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1236 :
1237 2 : keySetName (key, "user/.HiddenStringKey");
1238 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1239 :
1240 2 : keySetName (key, "user/.HiddenDirectoryKey");
1241 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1242 :
1243 2 : keySetName (key, "user/.HiddenDirectoryKey/StringKey");
1244 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1245 :
1246 2 : keySetName (key, "user/tests/file8xdLVS/filesys/.HiddenStringKey");
1247 2 : succeed_if (keyIsInactive (key), "Key should be inactive");
1248 :
1249 2 : keySetName (key, "user/.hidden/nothidden/hierarchy");
1250 2 : succeed_if (keyIsInactive (key) == 1, "Key should be inactive");
1251 :
1252 2 : keySetName (key, "user/.hidden/nothidden/hierarchy");
1253 2 : succeed_if (keyIsInactive (key) == 1, "Key should be inactive");
1254 2 : keyDel (key);
1255 2 : }
1256 :
1257 2 : static void test_keyBelow (void)
1258 : {
1259 2 : Key * key1 = keyNew (0);
1260 2 : Key * key2 = keyNew (0);
1261 :
1262 2 : printf ("Test of relative positions of keys\n");
1263 :
1264 2 : succeed_if (keyIsBelow (key1, 0) == -1, "NULL pointer");
1265 2 : succeed_if (keyIsBelow (0, 0) == -1, "NULL pointer");
1266 2 : succeed_if (keyIsBelow (0, key1) == -1, "NULL pointer");
1267 :
1268 2 : succeed_if (keyIsDirectBelow (key1, 0) == -1, "NULL pointer");
1269 2 : succeed_if (keyIsDirectBelow (0, 0) == -1, "NULL pointer");
1270 2 : succeed_if (keyIsDirectBelow (0, key1) == -1, "NULL pointer");
1271 :
1272 2 : keySetName (key1, "user/valid");
1273 2 : keySetName (key2, "user/valid");
1274 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1275 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1276 :
1277 2 : keySetName (key1, "user/valid");
1278 2 : keySetName (key2, "user/valid/");
1279 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1280 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1281 :
1282 2 : keySetName (key1, "user/valid");
1283 2 : keySetName (key2, "user/valid/below");
1284 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1285 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1286 :
1287 2 : keySetName (key1, "user/valid");
1288 2 : keySetName (key2, "user/valid/b");
1289 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1290 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1291 :
1292 2 : keySetName (key1, "user/valid");
1293 2 : keySetName (key2, "user/valid/b");
1294 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1295 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1296 :
1297 2 : keySetName (key1, "user/valid");
1298 2 : keySetName (key2, "user/valid/b/e");
1299 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1300 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1301 :
1302 2 : keySetName (key1, "/valid");
1303 2 : keySetName (key2, "/valid/b/e");
1304 2 : succeed_if (keyIsBelow (key1, key2), "cascading Key should be below");
1305 2 : succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
1306 :
1307 2 : keySetName (key1, "/");
1308 2 : keySetName (key2, "/valid/b/e");
1309 2 : succeed_if (keyIsBelow (key1, key2), "cascading Key should be below");
1310 2 : succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
1311 :
1312 2 : keySetName (key1, "/");
1313 2 : keySetName (key2, "/v");
1314 2 : succeed_if (keyIsBelow (key1, key2), "cascading Key should be below");
1315 2 : succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
1316 :
1317 2 : keySetName (key1, "user");
1318 2 : keySetName (key2, "user");
1319 2 : succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
1320 2 : succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
1321 :
1322 2 : keySetName (key1, "dir");
1323 2 : keySetName (key2, "dir");
1324 2 : succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
1325 2 : succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
1326 :
1327 2 : keySetName (key1, "/");
1328 2 : keySetName (key2, "dir");
1329 2 : succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
1330 2 : succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
1331 :
1332 2 : keySetName (key1, "/");
1333 2 : keySetName (key2, "system");
1334 2 : succeed_if (!keyIsBelow (key1, key2), "root Key should not be below");
1335 2 : succeed_if (!keyIsBelow (key2, key1), "root Key should not be below");
1336 :
1337 2 : keySetName (key1, "user/a");
1338 2 : keySetName (key2, "user/a");
1339 2 : succeed_if (!keyIsBelow (key1, key2), "cascading Key should not be below");
1340 2 : succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
1341 :
1342 2 : keySetName (key1, "/");
1343 2 : keySetName (key2, "/");
1344 2 : succeed_if (!keyIsBelow (key1, key2), "cascading Key should not be below");
1345 2 : succeed_if (!keyIsBelow (key2, key1), "cascading Key should not be below");
1346 :
1347 2 : keySetName (key1, "user/valide");
1348 2 : keySetName (key2, "user/valid/e");
1349 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1350 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1351 :
1352 2 : keySetName (key1, "user/valid/b");
1353 2 : keySetName (key2, "user/valid/e");
1354 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1355 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1356 :
1357 2 : keySetName (key1, "user/valide");
1358 2 : keySetName (key2, "user/valid/valide");
1359 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1360 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1361 :
1362 2 : keySetName (key1, "system/infos");
1363 2 : keySetName (key2, "/infos/constants");
1364 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1365 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1366 :
1367 2 : keySetName (key1, "/");
1368 2 : keySetName (key2, "/infos/constants");
1369 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1370 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1371 :
1372 2 : keySetName (key1, "system");
1373 2 : keySetName (key2, "/infos/constants");
1374 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1375 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1376 :
1377 2 : keySetName (key1, "/infos");
1378 2 : keySetName (key2, "system/infos/constants");
1379 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1380 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1381 :
1382 2 : keySetName (key1, "system/infos/constants");
1383 2 : keySetName (key2, "/infos/constants/syste");
1384 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1385 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1386 :
1387 2 : keySetName (key1, "/");
1388 2 : keySetName (key2, "system/infos/constants");
1389 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1390 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1391 :
1392 2 : keySetName (key1, "/infos");
1393 2 : keySetName (key2, "/infos/constants");
1394 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1395 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1396 :
1397 2 : keySetName (key1, "/");
1398 2 : keySetName (key2, "system/infos/constants/version/version");
1399 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1400 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1401 :
1402 2 : keySetName (key1, "user/valid");
1403 2 : keySetName (key2, "user/valid\\/e");
1404 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1405 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1406 :
1407 2 : keySetName (key1, "user/valid\\/");
1408 2 : keySetName (key2, "user/valid/e");
1409 2 : succeed_if (!keyIsBelow (key1, key2), "Key should not be below");
1410 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1411 :
1412 2 : keySetName (key1, "/valid\\/");
1413 2 : keySetName (key2, "user/valid\\//valid");
1414 2 : succeed_if (keyIsBelow (key1, key2), "Key should be below");
1415 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1416 :
1417 2 : keySetName (key1, "/a/b/c");
1418 2 : keySetName (key2, "/a/b/d");
1419 2 : succeed_if (!keyIsBelow (key1, key2), "Key should be below");
1420 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1421 :
1422 2 : keySetName (key1, "/a");
1423 2 : keySetName (key2, "/b");
1424 2 : succeed_if (!keyIsBelow (key1, key2), "Key should be below");
1425 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1426 :
1427 2 : keySetName (key1, "/valid\\/");
1428 2 : keySetName (key2, "user/valid\\/valid");
1429 2 : succeed_if (!keyIsBelow (key1, key2), "Key should be below");
1430 2 : succeed_if (!keyIsBelow (key2, key1), "Key should not be below");
1431 :
1432 :
1433 2 : keySetName (key1, "user/valid");
1434 2 : keySetName (key2, "user/valid/valide");
1435 2 : succeed_if (keyIsDirectBelow (key1, key2), "Key should be below");
1436 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1437 :
1438 2 : keySetName (key1, "user/valid");
1439 2 : keySetName (key2, "user/valid/non/valid");
1440 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1441 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1442 :
1443 2 : keySetName (key1, "user/valid/a");
1444 2 : keySetName (key2, "user/valid/b");
1445 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1446 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1447 :
1448 2 : keySetName (key1, "user/valid\\/");
1449 2 : keySetName (key2, "user/valid\\a");
1450 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1451 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1452 :
1453 2 : keySetName (key1, "user/valid\\/");
1454 2 : keySetName (key2, "user/valid\\/a");
1455 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1456 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1457 :
1458 2 : keySetName (key1, "user/valid\\/");
1459 2 : keySetName (key2, "user/valid\\/");
1460 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1461 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1462 :
1463 2 : keySetName (key1, "user/valid\\/");
1464 2 : keySetName (key2, "user/valid\\/a");
1465 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1466 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1467 :
1468 2 : keySetName (key1, "user/valid\\"); // this is an invalid name, so this situation cannot happen!
1469 2 : succeed_if_same_string (keyName (key1), "");
1470 2 : keySetName (key2, "user/valid\\/a");
1471 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1472 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1473 :
1474 2 : keySetName (key1, "user/valid\\/");
1475 2 : keySetName (key2, "user/valid\\/\\/");
1476 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1477 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1478 :
1479 2 : keySetName (key1, "user/valid\\/");
1480 2 : keySetName (key2, "user/valid\\/ab");
1481 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1482 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1483 :
1484 2 : keySetName (key1, "user/valid");
1485 2 : keySetName (key2, "user/valid");
1486 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1487 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1488 :
1489 2 : keySetName (key1, "user/valid/a/b");
1490 2 : keySetName (key2, "user/valid");
1491 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1492 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1493 :
1494 2 : keySetName (key1, "user/valid/a");
1495 2 : keySetName (key2, "user/valid");
1496 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1497 2 : succeed_if (keyIsDirectBelow (key2, key1), "Key should be below");
1498 :
1499 2 : keySetName (key1, "user/tests/ini-section-write");
1500 2 : keySetName (key2, "user/tests/ini-section-write/akey\\/looking\\/like\\/sections");
1501 2 : succeed_if (keyIsDirectBelow (key1, key2), "looking like sections not recognised");
1502 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1503 :
1504 2 : keySetName (key1, "user/valid");
1505 2 : keySetName (key2, "/valid/valide");
1506 2 : succeed_if (keyIsDirectBelow (key1, key2), "Key should be below");
1507 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1508 :
1509 2 : keySetName (key1, "user/valid");
1510 2 : keySetName (key2, "/valid/non/valid");
1511 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1512 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1513 :
1514 2 : keySetName (key1, "/valid");
1515 2 : keySetName (key2, "user/valid/valide");
1516 2 : succeed_if (keyIsDirectBelow (key1, key2), "Key should be below");
1517 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1518 :
1519 2 : keySetName (key1, "/valid");
1520 2 : keySetName (key2, "user/valid/non/valid");
1521 2 : succeed_if (!keyIsDirectBelow (key1, key2), "Key should not be below");
1522 2 : succeed_if (!keyIsDirectBelow (key2, key1), "Key should not be below");
1523 :
1524 :
1525 2 : keyDel (key1);
1526 2 : keyDel (key2);
1527 2 : }
1528 :
1529 2 : static void test_keyDup (void)
1530 : {
1531 : Key *orig, *copy;
1532 :
1533 2 : printf ("Test key duplication\n");
1534 :
1535 2 : succeed_if (keyDup (0) == 0, "could not duplicate null");
1536 :
1537 : // Create test key
1538 2 : orig = keyNew ("user:yl/foo/bar", KEY_BINARY, KEY_SIZE, 6, KEY_VALUE, "foobar", KEY_COMMENT, "mycomment", KEY_UID, 123, KEY_GID,
1539 : 456, KEY_MODE, 0644, KEY_END);
1540 :
1541 :
1542 : // Dup the key
1543 2 : succeed_if ((copy = keyDup (orig)) != 0, "keyDup failed");
1544 2 : compare_key (orig, copy);
1545 2 : keyDel (orig); // everything independent from original!
1546 :
1547 : // Check the duplication
1548 2 : succeed_if_same_string (keyName (copy), "user/foo/bar");
1549 2 : succeed_if (strncmp (keyValue (copy), "foobar", 6) == 0, "keyDup: key value copy error");
1550 2 : succeed_if (keyIsBinary (copy), "keyDup: key type copy error");
1551 :
1552 : // Dup the key again
1553 : Key * ccopy;
1554 2 : succeed_if ((ccopy = keyDup (copy)) != 0, "keyDup failed");
1555 2 : compare_key (copy, ccopy);
1556 2 : keyDel (copy); // everything independent from original!
1557 :
1558 2 : succeed_if_same_string (keyName (ccopy), "user/foo/bar");
1559 2 : succeed_if (strncmp (keyValue (ccopy), "foobar", 6) == 0, "keyDup: key value ccopy error");
1560 2 : succeed_if (keyIsBinary (ccopy), "keyDup: key type ccopy error");
1561 :
1562 2 : keyDel (ccopy);
1563 :
1564 2 : orig = keyNew (0);
1565 2 : keySetName (orig, "invalid");
1566 :
1567 2 : succeed_if ((copy = keyDup (orig)) != 0, "keyDup failed");
1568 2 : succeed_if_same_string (keyName (orig), "");
1569 2 : succeed_if_same_string (keyName (copy), "");
1570 2 : succeed_if (keyGetNameSize (orig) == 1, "orig name size");
1571 2 : succeed_if (keyGetNameSize (copy) == 1, "orig name size");
1572 2 : succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
1573 2 : succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
1574 :
1575 2 : keyDel (orig);
1576 2 : keyDel (copy);
1577 2 : }
1578 :
1579 2 : static void test_keyCopy (void)
1580 : {
1581 : Key *orig, *copy;
1582 :
1583 2 : printf ("Test key copy\n");
1584 :
1585 : // Create test key
1586 2 : orig = keyNew ("user:yl/foo/bar", KEY_BINARY, KEY_SIZE, 6, KEY_VALUE, "foobar", KEY_COMMENT, "mycomment", KEY_UID, 123, KEY_GID,
1587 : 456, KEY_MODE, 0644, KEY_END);
1588 :
1589 :
1590 : // Copy the key
1591 2 : copy = keyNew (0);
1592 2 : succeed_if (keyCopy (copy, orig) == 1, "keyCopy failed");
1593 2 : succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
1594 2 : succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
1595 2 : compare_key (orig, copy);
1596 :
1597 2 : succeed_if (keyCopy (copy, orig) == 1, "keyCopy failed");
1598 2 : succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
1599 2 : succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
1600 2 : compare_key (orig, copy);
1601 2 : keyDel (orig); // everything independent from original!
1602 :
1603 : // Check the duplication
1604 2 : succeed_if_same_string (keyName (copy), "user/foo/bar");
1605 2 : succeed_if (strncmp (keyValue (copy), "foobar", 6) == 0, "keyCopy: key value copy error");
1606 :
1607 2 : orig = keyNew (0);
1608 2 : succeed_if (keyCopy (copy, orig) == 1, "make a key copy of an unmodified key");
1609 2 : compare_key (orig, copy);
1610 :
1611 2 : succeed_if (keyCopy (copy, 0) == 0, "make the key copy fresh");
1612 2 : compare_key (orig, copy);
1613 2 : keyDel (orig);
1614 :
1615 2 : keyDel (copy);
1616 :
1617 2 : orig = keyNew (0);
1618 2 : keySetName (orig, "invalid");
1619 :
1620 2 : copy = keyNew (0);
1621 2 : succeed_if (keyCopy (copy, orig) == 1, "keyCopy failed");
1622 2 : succeed_if_same_string (keyName (orig), "");
1623 2 : succeed_if_same_string (keyName (copy), "");
1624 2 : succeed_if (keyGetNameSize (orig) == 1, "orig name size");
1625 2 : succeed_if (keyGetNameSize (copy) == 1, "orig name size");
1626 2 : succeed_if (keyGetRef (orig) == 0, "orig ref counter should be 0");
1627 2 : succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
1628 :
1629 2 : keyDel (orig);
1630 2 : keyDel (copy);
1631 :
1632 2 : orig = keyNew ("user/orig", KEY_END);
1633 2 : succeed_if (keyNeedSync (orig), "fresh key does not need sync?");
1634 2 : KeySet * ks = ksNew (20, KS_END);
1635 2 : ksAppendKey (ks, orig);
1636 2 : copy = keyNew ("user/othername", KEY_END);
1637 2 : succeed_if (keyNeedSync (copy), "fresh key does not need sync?");
1638 2 : succeed_if (keyGetRef (orig) == 1, "orig ref counter should be 1");
1639 2 : succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 0");
1640 2 : succeed_if (keyCopy (orig, copy) == -1, "copy should not be allowed when key is already referred to");
1641 2 : succeed_if (keyNeedSync (orig), "copied key does not need sync?");
1642 2 : succeed_if (keyNeedSync (copy), "copied key does not need sync?");
1643 :
1644 2 : succeed_if (keyGetRef (orig) == 1, "orig ref counter should be 1");
1645 2 : succeed_if (keyGetRef (copy) == 0, "copy ref counter should be 1");
1646 :
1647 2 : succeed_if_same_string (keyName (orig), "user/orig");
1648 2 : succeed_if_same_string (keyName (copy), "user/othername");
1649 :
1650 2 : keyDel (copy);
1651 2 : ksRewind (ks);
1652 2 : succeed_if_same_string (keyName (ksNext (ks)), "user/orig");
1653 2 : ksDel (ks);
1654 2 : }
1655 :
1656 :
1657 : typedef void (*fun_t) (void);
1658 0 : static void fun (void)
1659 : {
1660 0 : }
1661 :
1662 2 : static void test_binary (void)
1663 : {
1664 2 : printf ("Test binary values\n");
1665 :
1666 2 : Key * k = 0;
1667 :
1668 2 : int i = 20;
1669 2 : int * p = &i;
1670 :
1671 2 : k = keyNew (0);
1672 2 : succeed_if (keySetBinary (k, &p, sizeof (p)) == sizeof (p), "could not set binary");
1673 :
1674 : int * q;
1675 2 : succeed_if (keyGetBinary (k, &q, sizeof (q)) == sizeof (q), "could not get binary");
1676 2 : succeed_if (p == q, "pointers to int are not equal");
1677 2 : succeed_if (*p == *q, "values are not equal");
1678 2 : succeed_if (*q == 20, "values are not equal");
1679 2 : succeed_if (*p == 20, "values are not equal");
1680 :
1681 2 : keyDel (k);
1682 :
1683 :
1684 : union
1685 : {
1686 : void (*f) (void);
1687 : void * v;
1688 : } conversation;
1689 :
1690 2 : k = keyNew (0);
1691 2 : conversation.f = fun;
1692 2 : succeed_if (keySetBinary (k, &conversation.v, sizeof (conversation)) == sizeof (conversation), "could not set binary");
1693 :
1694 2 : conversation.v = 0;
1695 : conversation.f = 0;
1696 2 : void (*g) (void) = 0;
1697 2 : succeed_if (keyGetBinary (k, &conversation.v, sizeof (conversation)) == sizeof (conversation), "could not get binary");
1698 2 : g = conversation.f;
1699 2 : succeed_if (g == fun, "pointers to functions are not equal");
1700 :
1701 2 : keyDel (k);
1702 :
1703 :
1704 2 : conversation.f = fun;
1705 2 : k = keyNew ("system/symbols/fun", KEY_BINARY, KEY_SIZE, sizeof (conversation), KEY_VALUE, &conversation.v, KEY_END);
1706 :
1707 2 : conversation.v = 0;
1708 : conversation.f = 0;
1709 2 : succeed_if (keyGetBinary (k, &conversation.v, sizeof (conversation)) == sizeof (conversation), "could not get binary");
1710 2 : g = conversation.f;
1711 2 : succeed_if (g == fun, "pointers to functions are not equal");
1712 :
1713 2 : keyDel (k);
1714 :
1715 :
1716 2 : fun_t tmp = fun;
1717 :
1718 2 : k = keyNew ("system/symbol/fun", KEY_BINARY, KEY_SIZE, sizeof (fun_t), KEY_VALUE, &tmp, KEY_END);
1719 :
1720 2 : fun_t myfun = 0;
1721 2 : succeed_if (keyGetBinary (k, &myfun, sizeof (fun_t)) == sizeof (fun_t), "could not get binary");
1722 :
1723 2 : succeed_if (fun == myfun, "pointers not equal");
1724 :
1725 2 : keyDel (k);
1726 :
1727 :
1728 2 : k = keyNew ("system/symbol/cool", KEY_FUNC, fun, KEY_END);
1729 :
1730 2 : succeed_if (keyGetBinary (k, &myfun, sizeof (fun_t)) == sizeof (fun_t), "could not get binary");
1731 :
1732 2 : succeed_if (fun == myfun, "pointers not equal");
1733 :
1734 2 : keyDel (k);
1735 :
1736 : char data[10];
1737 2 : k = keyNew ("system/empty_binary", KEY_END);
1738 2 : succeed_if (keySetBinary (k, 0, 0) == 0, "could not set binary will null pointer");
1739 2 : succeed_if (keyIsBinary (k), "key is not binary");
1740 2 : succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
1741 2 : succeed_if (keyValue (k) == 0, "did not get back null pointer");
1742 :
1743 2 : succeed_if (keySetBinary (k, 0, 1) == 0, "could not set binary will null pointer");
1744 2 : succeed_if (keyIsBinary (k), "key is not binary");
1745 2 : succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
1746 2 : succeed_if (keyValue (k) == 0, "did not get back null pointer");
1747 :
1748 2 : succeed_if (keySetBinary (k, 0, 5) == 0, "could not set binary will null pointer");
1749 2 : succeed_if (keyIsBinary (k), "key is not binary");
1750 2 : succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
1751 2 : succeed_if (keyValue (k) == 0, "did not get back null pointer");
1752 :
1753 2 : succeed_if (keySetBinary (k, 0, -1) == -1, "misusage: this will fail");
1754 2 : succeed_if (keyIsBinary (k), "key is not binary (should be from previous calls)");
1755 2 : succeed_if (keyGetBinary (k, data, 1) == 0, "could not get empty binary");
1756 2 : succeed_if (keyValue (k) == 0, "did not get back null pointer");
1757 2 : keyDel (k);
1758 2 : }
1759 :
1760 2 : static void test_keyBelowOrSame (void)
1761 : {
1762 2 : Key * key1 = keyNew (0);
1763 2 : Key * key2 = keyNew (0);
1764 :
1765 2 : printf ("Test of keyBelowOrSame\n");
1766 :
1767 2 : succeed_if (keyIsBelowOrSame (key1, 0) == -1, "NULL pointer");
1768 2 : succeed_if (keyIsBelowOrSame (0, 0) == -1, "NULL pointer");
1769 2 : succeed_if (keyIsBelowOrSame (0, key1) == -1, "NULL pointer");
1770 :
1771 2 : keySetName (key1, "user/valid");
1772 2 : keySetName (key2, "user/valid");
1773 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1774 2 : succeed_if (keyIsBelowOrSame (key2, key1), "Key should be below");
1775 :
1776 2 : keySetName (key1, "user/valid");
1777 2 : keySetName (key2, "user/valid/");
1778 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1779 2 : succeed_if (keyIsBelowOrSame (key2, key1), "Key should be below");
1780 :
1781 2 : keySetName (key1, "user/valid");
1782 2 : keySetName (key2, "user/valid/below");
1783 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1784 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1785 :
1786 2 : keySetName (key1, "user/valid");
1787 2 : keySetName (key2, "user/valid/b");
1788 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1789 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1790 :
1791 2 : keySetName (key1, "user/valid");
1792 2 : keySetName (key2, "user/valid/b");
1793 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1794 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1795 :
1796 2 : keySetName (key1, "user/valid");
1797 2 : keySetName (key2, "user/valid/b/e");
1798 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1799 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1800 :
1801 2 : keySetName (key1, "/valid");
1802 2 : keySetName (key2, "/valid/b/e");
1803 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1804 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1805 :
1806 2 : keySetName (key1, "/");
1807 2 : keySetName (key2, "/valid/b/e");
1808 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1809 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1810 :
1811 2 : keySetName (key1, "/");
1812 2 : keySetName (key2, "/v");
1813 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1814 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1815 :
1816 2 : keySetName (key1, "/");
1817 2 : keySetName (key2, "/");
1818 2 : succeed_if (keyIsBelowOrSame (key1, key2), "Key should be below");
1819 2 : succeed_if (keyIsBelowOrSame (key2, key1), "Key should be below");
1820 :
1821 2 : keySetName (key1, "user/valide");
1822 2 : keySetName (key2, "user/valid/e");
1823 2 : succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
1824 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1825 :
1826 2 : keySetName (key1, "user/valid/b");
1827 2 : keySetName (key2, "user/valid/e");
1828 2 : succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
1829 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1830 :
1831 2 : keySetName (key1, "user/export/a");
1832 2 : keySetName (key2, "user/export-backup/b");
1833 2 : succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
1834 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1835 :
1836 2 : keySetName (key1, "user/export");
1837 2 : keySetName (key2, "user/export-backup-2/x");
1838 2 : succeed_if (!keyIsBelowOrSame (key1, key2), "Key should not be below");
1839 2 : succeed_if (!keyIsBelowOrSame (key2, key1), "Key should not be below");
1840 :
1841 2 : keyDel (key1);
1842 2 : keyDel (key2);
1843 2 : }
1844 :
1845 2 : static void test_keyNameSpecial (void)
1846 : {
1847 2 : printf ("Test special keynames\n");
1848 2 : Key * k = keyNew (0);
1849 2 : succeed_if_same_string (keyName (k), "");
1850 :
1851 2 : succeed_if (keySetName (k, "system"), "could not set key name with system");
1852 2 : succeed_if_same_string (keyName (k), "system");
1853 :
1854 2 : succeed_if (keySetName (k, 0) == 0, "could not set key name with 0");
1855 2 : succeed_if_same_string (keyName (k), "");
1856 :
1857 2 : succeed_if (keySetName (k, "system"), "could not set key name with system");
1858 2 : succeed_if_same_string (keyName (k), "system");
1859 :
1860 2 : succeed_if (keySetName (k, "") == 0, "could not set key name with empty string");
1861 2 : succeed_if_same_string (keyName (k), "");
1862 :
1863 2 : succeed_if (keySetName (k, "system"), "could not set key name with system");
1864 2 : succeed_if_same_string (keyName (k), "system");
1865 :
1866 2 : succeed_if (keySetName (k, "invalid") == -1, "could not set key name invalid");
1867 2 : succeed_if_same_string (keyName (k), "");
1868 :
1869 :
1870 2 : succeed_if (keySetName (k, "system/something/.."), "could not set key name with ..");
1871 2 : succeed_if_same_string (keyName (k), "system");
1872 :
1873 2 : succeed_if (keySetName (k, "system/something/.."), "could not set key name with ..");
1874 2 : succeed_if_same_string (keyName (k), "system");
1875 :
1876 2 : succeed_if (keySetName (k, "system/something/../.."), "could not set key name with ..");
1877 2 : succeed_if_same_string (keyName (k), "system");
1878 :
1879 2 : succeed_if (keySetName (k, "system/something/../../.."), "could not set key name with ..");
1880 2 : succeed_if_same_string (keyName (k), "system");
1881 :
1882 2 : succeed_if (keySetName (k, "system/something/../../../.."), "could not set key name with ..");
1883 2 : succeed_if_same_string (keyName (k), "system");
1884 :
1885 2 : succeed_if (keySetName (k, "system/something/../../../../.."), "could not set key name with ..");
1886 2 : succeed_if_same_string (keyName (k), "system");
1887 :
1888 :
1889 2 : succeed_if (keySetName (k, "system/../something"), "could not set key name with ..");
1890 2 : succeed_if_same_string (keyName (k), "system/something");
1891 :
1892 2 : succeed_if (keySetName (k, "system/../../something"), "could not set key name with ..");
1893 2 : succeed_if_same_string (keyName (k), "system/something");
1894 :
1895 2 : succeed_if (keySetName (k, "system/../../../something"), "could not set key name with ..");
1896 2 : succeed_if_same_string (keyName (k), "system/something");
1897 :
1898 2 : succeed_if (keySetName (k, "system/../../../../something"), "could not set key name with ..");
1899 2 : succeed_if_same_string (keyName (k), "system/something");
1900 :
1901 2 : succeed_if (keySetName (k, "system/../../../../../something"), "could not set key name with ..");
1902 2 : succeed_if_same_string (keyName (k), "system/something");
1903 :
1904 :
1905 2 : succeed_if (keySetName (k, "system/a/b/c/.."), "could not set key name with ..");
1906 2 : succeed_if_same_string (keyName (k), "system/a/b");
1907 :
1908 2 : succeed_if (keySetName (k, "system/a/b/c/../.."), "could not set key name with ..");
1909 2 : succeed_if_same_string (keyName (k), "system/a");
1910 :
1911 2 : succeed_if (keySetName (k, "system/a/b/c/../../.."), "could not set key name with ..");
1912 2 : succeed_if_same_string (keyName (k), "system");
1913 :
1914 2 : succeed_if (keySetName (k, "system/a/b/c/../../../.."), "could not set key name with ..");
1915 2 : succeed_if_same_string (keyName (k), "system");
1916 :
1917 2 : succeed_if (keySetName (k, "system/a/b/c/../../../../.."), "could not set key name with ..");
1918 2 : succeed_if_same_string (keyName (k), "system");
1919 :
1920 :
1921 2 : succeed_if (keySetName (k, "system/../a/b/c"), "could not set key name with ..");
1922 2 : succeed_if_same_string (keyName (k), "system/a/b/c");
1923 :
1924 2 : succeed_if (keySetName (k, "system/../../a/b/c"), "could not set key name with ..");
1925 2 : succeed_if_same_string (keyName (k), "system/a/b/c");
1926 :
1927 2 : succeed_if (keySetName (k, "system/../../../a/b/c"), "could not set key name with ..");
1928 2 : succeed_if_same_string (keyName (k), "system/a/b/c");
1929 :
1930 2 : succeed_if (keySetName (k, "system/../../../../a/b/c"), "could not set key name with ..");
1931 2 : succeed_if_same_string (keyName (k), "system/a/b/c");
1932 :
1933 2 : succeed_if (keySetName (k, "system/../../../../../a/b/c"), "could not set key name with ..");
1934 2 : succeed_if_same_string (keyName (k), "system/a/b/c");
1935 :
1936 :
1937 2 : keyDel (k);
1938 2 : }
1939 :
1940 2 : static void test_keyClear (void)
1941 : {
1942 2 : printf ("Test clear of key\n");
1943 :
1944 2 : Key * k1 = keyNew ("system/abc", KEY_END);
1945 2 : succeed_if_same_string (keyName (k1), "system/abc");
1946 :
1947 2 : succeed_if (keyGetRef (k1) == 0, "New key reference");
1948 2 : keyIncRef (k1);
1949 2 : succeed_if (keyGetRef (k1) == 1, "Incremented key reference");
1950 2 : Key * k2 = k1; // create an alias for k1
1951 2 : succeed_if_same_string (keyName (k2), "system/abc");
1952 2 : succeed_if (keyGetRef (k1) == 1, "Incremented key reference");
1953 2 : succeed_if (keyGetRef (k2) == 1, "Incremented key reference");
1954 :
1955 2 : keyIncRef (k1);
1956 2 : Key * k3 = k1; // create an alias for k1
1957 2 : succeed_if_same_string (keyName (k3), "system/abc");
1958 2 : succeed_if (keyGetRef (k1) == 2, "Incremented key reference");
1959 2 : succeed_if (keyGetRef (k2) == 2, "Incremented key reference");
1960 2 : succeed_if (keyGetRef (k3) == 2, "Incremented key reference");
1961 :
1962 2 : keyClear (k1);
1963 2 : succeed_if_same_string (keyName (k1), "");
1964 2 : succeed_if_same_string (keyName (k2), "");
1965 2 : succeed_if_same_string (keyName (k3), "");
1966 :
1967 2 : keySetMeta (k1, "test_meta", "test_value");
1968 2 : succeed_if_same_string (keyValue (keyGetMeta (k1, "test_meta")), "test_value");
1969 2 : succeed_if_same_string (keyValue (keyGetMeta (k2, "test_meta")), "test_value");
1970 2 : succeed_if_same_string (keyValue (keyGetMeta (k3, "test_meta")), "test_value");
1971 :
1972 2 : keyClear (k2);
1973 2 : succeed_if (keyGetMeta (k1, "test_meta") == 0, "there should be no meta after keyClear");
1974 2 : succeed_if (keyGetMeta (k2, "test_meta") == 0, "there should be no meta after keyClear");
1975 2 : succeed_if (keyGetMeta (k3, "test_meta") == 0, "there should be no meta after keyClear");
1976 :
1977 2 : keySetString (k1, "mystring");
1978 2 : succeed_if_same_string (keyValue (k1), "mystring");
1979 2 : succeed_if_same_string (keyValue (k2), "mystring");
1980 2 : succeed_if_same_string (keyValue (k3), "mystring");
1981 :
1982 2 : keyClear (k3);
1983 2 : succeed_if_same_string (keyValue (k1), "");
1984 2 : succeed_if_same_string (keyValue (k2), "");
1985 2 : succeed_if_same_string (keyValue (k3), "");
1986 :
1987 2 : succeed_if (keyGetRef (k1) == 2, "Incremented key reference");
1988 2 : succeed_if (keyGetRef (k2) == 2, "Incremented key reference");
1989 2 : succeed_if (keyGetRef (k3) == 2, "Incremented key reference");
1990 :
1991 2 : keyDel (k3); // does nothing
1992 2 : keyDecRef (k3);
1993 2 : k3 = 0; // remove alias
1994 2 : succeed_if (keyGetRef (k1) == 1, "Incremented key reference");
1995 2 : succeed_if (keyGetRef (k2) == 1, "Incremented key reference");
1996 :
1997 2 : keyDel (k2); // does nothing
1998 2 : keyDecRef (k2);
1999 2 : k2 = 0; // remove alias
2000 2 : succeed_if (keyGetRef (k1) == 0, "Incremented key reference");
2001 :
2002 2 : keyDel (k1);
2003 2 : }
2004 :
2005 2 : static void test_keyBaseName (void)
2006 : {
2007 2 : printf ("Test basename\n");
2008 2 : Key * k = keyNew ("user:yl///foo\\///bar\\/foo_bar\\/", KEY_END);
2009 2 : succeed_if_same_string (keyName (k), "user/foo\\//bar\\/foo_bar\\/");
2010 2 : succeed_if_same_string (keyBaseName (k), "bar/foo_bar/");
2011 :
2012 2 : keySetName (k, "system");
2013 2 : succeed_if_same_string (keyBaseName (k), "");
2014 :
2015 2 : keySetName (k, "system/valid//////");
2016 2 : succeed_if_same_string (keyName (k), "system/valid");
2017 2 : succeed_if_same_string (keyBaseName (k), "valid");
2018 :
2019 2 : keySetName (k, "system//////valid//////");
2020 2 : succeed_if_same_string (keyName (k), "system/valid");
2021 2 : succeed_if_same_string (keyBaseName (k), "valid");
2022 :
2023 2 : keySetName (k, "system///.///valid//.////");
2024 2 : succeed_if_same_string (keyName (k), "system/valid");
2025 2 : succeed_if_same_string (keyBaseName (k), "valid");
2026 :
2027 2 : keySetName (k, "user");
2028 2 : succeed_if_same_string (keyBaseName (k), "");
2029 :
2030 2 : keySetName (k, "user/valid//////");
2031 2 : succeed_if_same_string (keyName (k), "user/valid");
2032 2 : succeed_if_same_string (keyBaseName (k), "valid");
2033 :
2034 2 : keySetName (k, "user//////valid//////");
2035 2 : succeed_if_same_string (keyName (k), "user/valid");
2036 2 : succeed_if_same_string (keyBaseName (k), "valid");
2037 :
2038 2 : keySetName (k, "user///.///valid//.////");
2039 2 : succeed_if_same_string (keyName (k), "user/valid");
2040 2 : succeed_if_same_string (keyBaseName (k), "valid");
2041 :
2042 :
2043 2 : keySetName (k, "user:yl///foo\\///bar\\/foo_bar\\/");
2044 2 : succeed_if_same_string (keyName (k), "user/foo\\//bar\\/foo_bar\\/");
2045 2 : succeed_if_same_string (keyBaseName (k), "bar/foo_bar/");
2046 :
2047 2 : keySetName (k, "user//////foo_bar\\/");
2048 2 : succeed_if_same_string (keyName (k), "user/foo_bar\\/");
2049 2 : succeed_if_same_string (keyBaseName (k), "foo_bar/");
2050 :
2051 2 : keySetName (k, "user//////%");
2052 2 : succeed_if_same_string (keyName (k), "user/%");
2053 2 : succeed_if_same_string (keyBaseName (k), "");
2054 :
2055 2 : keySetName (k, "user//////\\%");
2056 2 : succeed_if_same_string (keyName (k), "user/\\%");
2057 2 : succeed_if_same_string (keyBaseName (k), "%");
2058 :
2059 2 : keySetName (k, "user//////\\\\%");
2060 2 : succeed_if_same_string (keyName (k), "user/\\\\%");
2061 2 : succeed_if_same_string (keyBaseName (k), "\\%");
2062 :
2063 2 : keySetName (k, "user//////\\\\\\%");
2064 2 : succeed_if_same_string (keyName (k), "user/\\\\\\%");
2065 2 : succeed_if_same_string (keyBaseName (k), "\\\\%");
2066 2 : keyDel (k);
2067 2 : }
2068 :
2069 2 : static void test_keySetBaseName (void)
2070 : {
2071 2 : printf ("Test set basename\n");
2072 :
2073 2 : Key * k = keyNew (0);
2074 :
2075 2 : succeed_if (keySetBaseName (k, "abc") == -1, "invalid key");
2076 2 : succeed_if_same_string (keyName (k), "");
2077 2 : succeed_if_same_string (keyBaseName (k), "");
2078 :
2079 2 : keySetName (k, "spec");
2080 2 : succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
2081 2 : succeed_if_same_string (keyName (k), "spec");
2082 2 : succeed_if_same_string (keyBaseName (k), "");
2083 :
2084 2 : keySetName (k, "proc");
2085 2 : succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
2086 2 : succeed_if_same_string (keyName (k), "proc");
2087 2 : succeed_if_same_string (keyBaseName (k), "");
2088 :
2089 2 : keySetName (k, "dir");
2090 2 : succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
2091 2 : succeed_if_same_string (keyName (k), "dir");
2092 2 : succeed_if_same_string (keyBaseName (k), "");
2093 :
2094 2 : keySetName (k, "user");
2095 2 : succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
2096 2 : succeed_if_same_string (keyName (k), "user");
2097 2 : succeed_if_same_string (keyBaseName (k), "");
2098 :
2099 2 : keySetName (k, "system");
2100 2 : succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
2101 2 : succeed_if_same_string (keyName (k), "system");
2102 2 : succeed_if_same_string (keyBaseName (k), "");
2103 :
2104 2 : keySetName (k, "/");
2105 2 : succeed_if (keySetBaseName (k, 0) == -1, "could remove root name");
2106 2 : succeed_if_same_string (keyName (k), "/");
2107 2 : succeed_if_same_string (keyBaseName (k), "");
2108 :
2109 2 : keySetName (k, "/x");
2110 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing single character basename of cascading key with depth 1 failed");
2111 2 : succeed_if_same_string (keyName (k), "/");
2112 2 : succeed_if_same_string (keyBaseName (k), "");
2113 :
2114 2 : keySetName (k, "/cascading");
2115 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing basename of cascading key with depth 1 failed");
2116 2 : succeed_if_same_string (keyName (k), "/");
2117 2 : succeed_if_same_string (keyBaseName (k), "");
2118 :
2119 2 : keySetName (k, "system/notCascading");
2120 2 : succeed_if (keySetBaseName (k, 0) >= 0, "removing basename of non cascading key with depth 1 failed");
2121 2 : succeed_if_same_string (keyName (k), "system");
2122 2 : succeed_if_same_string (keyBaseName (k), "");
2123 :
2124 2 : keySetName (k, "system/foo/bar");
2125 2 : succeed_if (keySetBaseName (k, 0) >= 0, "removing basename of non cascading key with depth 2 failed");
2126 2 : succeed_if_same_string (keyName (k), "system/foo");
2127 2 : succeed_if_same_string (keyBaseName (k), "foo");
2128 2 : succeed_if (keySetBaseName (k, 0) >= 0, "second removing basename of non cascading key with depth 2 failed");
2129 2 : succeed_if_same_string (keyName (k), "system");
2130 2 : succeed_if_same_string (keyBaseName (k), "");
2131 :
2132 2 : keySetName (k, "/foo/bar");
2133 2 : succeed_if (keySetBaseName (k, 0) >= 0, "removing basename of cascading key with depth 2 failed");
2134 2 : succeed_if_same_string (keyName (k), "/foo");
2135 2 : succeed_if_same_string (keyBaseName (k), "foo");
2136 2 : succeed_if (keySetBaseName (k, 0) == 2, "second removing basename of cascading key with depth 2 failed");
2137 2 : succeed_if_same_string (keyName (k), "/");
2138 2 : succeed_if_same_string (keyBaseName (k), "");
2139 2 : succeed_if (keySetBaseName (k, 0) == -1, "third removing basename of cascading key with depth 2 was possible");
2140 2 : succeed_if_same_string (keyName (k), "/");
2141 2 : succeed_if_same_string (keyBaseName (k), "");
2142 :
2143 2 : keySetName (k, "/\\/");
2144 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing basename of single character escaped cascading key with depth 1 failed");
2145 2 : succeed_if_same_string (keyName (k), "/");
2146 2 : succeed_if_same_string (keyBaseName (k), "");
2147 :
2148 2 : keySetName (k, "/\\.");
2149 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing basename of single character escaped dot cascading key with depth 1 failed");
2150 2 : succeed_if_same_string (keyName (k), "/");
2151 2 : succeed_if_same_string (keyBaseName (k), "");
2152 :
2153 2 : keySetName (k, "/\\..");
2154 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing basename of escaped dot dot cascading key with depth 1 failed");
2155 2 : succeed_if_same_string (keyName (k), "/");
2156 2 : succeed_if_same_string (keyBaseName (k), "");
2157 :
2158 2 : keySetName (k, "/\\%");
2159 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing basename of single character escaped % cascading key with depth 1 failed");
2160 2 : succeed_if_same_string (keyName (k), "/");
2161 2 : succeed_if_same_string (keyBaseName (k), "");
2162 :
2163 2 : keySetName (k, "/#_1");
2164 2 : succeed_if (keySetBaseName (k, 0) == 2, "removing basename of array cascading key with depth 1 failed");
2165 2 : succeed_if_same_string (keyName (k), "/");
2166 2 : succeed_if_same_string (keyBaseName (k), "");
2167 :
2168 2 : keySetName (k, "system");
2169 2 : succeed_if (keySetBaseName (k, "valid") == -1, "add root name, but set was used");
2170 2 : succeed_if_same_string (keyName (k), "system");
2171 2 : succeed_if_same_string (keyBaseName (k), "");
2172 :
2173 2 : keySetName (k, "proc");
2174 2 : succeed_if (keySetBaseName (k, "a") == -1, "add root name, but set was used");
2175 2 : succeed_if_same_string (keyName (k), "proc");
2176 2 : succeed_if_same_string (keyBaseName (k), "");
2177 :
2178 2 : keySetName (k, "system/valid");
2179 2 : succeed_if (keySetBaseName (k, 0) == sizeof ("system"), "could not remove base name");
2180 2 : succeed_if_same_string (keyName (k), "system");
2181 2 : succeed_if_same_string (keyBaseName (k), "");
2182 :
2183 2 : keySetName (k, "system/valid");
2184 2 : succeed_if (keySetBaseName (k, "") > 0, "could not set empty name");
2185 2 : succeed_if_same_string (keyName (k), "system/%"); // is an empty name
2186 2 : succeed_if_same_string (keyBaseName (k), "");
2187 :
2188 2 : keySetName (k, "system/valid");
2189 2 : succeed_if (keySetBaseName (k, "a") >= 0, "escaped slash ok");
2190 2 : succeed_if_same_string (keyName (k), "system/a");
2191 2 : succeed_if_same_string (keyBaseName (k), "a");
2192 :
2193 2 : keySetName (k, "system/valid");
2194 2 : succeed_if (keySetBaseName (k, "/") >= 0, "escaped slash ok");
2195 2 : succeed_if_same_string (keyName (k), "system/\\/");
2196 2 : succeed_if_same_string (keyBaseName (k), "/");
2197 :
2198 2 : keySetName (k, "system/valid");
2199 2 : succeed_if (keySetBaseName (k, "\\/") >= 0, "escaped slash ok");
2200 2 : succeed_if_same_string (keyName (k), "system/\\\\\\/");
2201 2 : succeed_if_same_string (keyBaseName (k), "\\/");
2202 :
2203 2 : keySetName (k, "system/valid");
2204 2 : succeed_if (keySetBaseName (k, "\\\\/") >= 0, "backslash escaped, but slash unescaped");
2205 2 : succeed_if_same_string (keyName (k), "system/\\\\\\\\\\/");
2206 2 : succeed_if_same_string (keyBaseName (k), "\\\\/");
2207 :
2208 2 : keySetName (k, "system/valid");
2209 2 : succeed_if (keySetBaseName (k, "\\\\\\/") >= 0, "backslash escaped, slash escaped");
2210 2 : succeed_if_same_string (keyName (k), "system/\\\\\\\\\\\\\\/");
2211 2 : succeed_if_same_string (keyBaseName (k), "\\\\\\/");
2212 :
2213 2 : keySetName (k, "system/valid");
2214 2 : succeed_if (keySetBaseName (k, "%") == sizeof ("system/\\%"), "could not set basename");
2215 2 : succeed_if_same_string (keyBaseName (k), "%");
2216 2 : succeed_if_same_string (keyName (k), "system/\\%");
2217 2 : succeed_if_same_string (keyBaseName (k), "%");
2218 :
2219 2 : keySetName (k, "system/valid");
2220 2 : succeed_if (keySetBaseName (k, ".") == sizeof ("system/\\%"), "could not set basename");
2221 2 : succeed_if_same_string (keyBaseName (k), ".");
2222 2 : succeed_if_same_string (keyName (k), "system/\\.");
2223 2 : succeed_if_same_string (keyBaseName (k), ".");
2224 :
2225 2 : keySetName (k, "system/valid");
2226 2 : succeed_if (keySetBaseName (k, "..") == sizeof ("system/\\.."), "could not set basename");
2227 2 : succeed_if_same_string (keyBaseName (k), "..");
2228 2 : succeed_if_same_string (keyName (k), "system/\\..");
2229 2 : succeed_if_same_string (keyBaseName (k), "..");
2230 :
2231 2 : keySetName (k, "system/valid");
2232 2 : succeed_if (keySetBaseName (k, "\\\\\\\\") >= 0, "backslash escaped, backslash escaped");
2233 2 : succeed_if_same_string (keyName (k), "system/\\\\\\\\\\\\\\\\");
2234 2 : succeed_if_same_string (keyBaseName (k), "\\\\\\\\");
2235 :
2236 2 : keySetName (k, "system/valid");
2237 2 : succeed_if (keySetBaseName (k, "\\\\") >= 0, "escaped backslash ok");
2238 2 : succeed_if_same_string (keyName (k), "system/\\\\\\\\");
2239 2 : succeed_if_same_string (keyBaseName (k), "\\\\");
2240 :
2241 2 : keySetName (k, "system/valid");
2242 2 : succeed_if (keySetBaseName (k, "\\.") >= 0, "escaped dot");
2243 2 : succeed_if_same_string (keyName (k), "system/\\\\.");
2244 2 : succeed_if_same_string (keyBaseName (k), "\\.");
2245 :
2246 2 : keySetName (k, "system/valid");
2247 2 : succeed_if (keySetBaseName (k, "\\..") >= 0, "escaped dot-dot");
2248 2 : succeed_if_same_string (keyName (k), "system/\\\\..");
2249 2 : succeed_if_same_string (keyBaseName (k), "\\..");
2250 :
2251 2 : keySetName (k, "system/valid");
2252 2 : succeed_if (keySetBaseName (k, "%") == sizeof ("system/\\%"), "add some char");
2253 2 : succeed_if_same_string (keyName (k), "system/\\%");
2254 2 : succeed_if_same_string (keyBaseName (k), "%");
2255 :
2256 2 : keySetName (k, "system/valid");
2257 2 : succeed_if (keySetBaseName (k, "#1") == sizeof ("system/#1"), "valid array entry");
2258 2 : succeed_if_same_string (keyName (k), "system/#1");
2259 2 : succeed_if_same_string (keyBaseName (k), "#1");
2260 :
2261 2 : keySetName (k, "system/valid");
2262 2 : succeed_if (keySetBaseName (k, "#_10") >= 0, "valid array entry");
2263 2 : succeed_if_same_string (keyName (k), "system/#_10");
2264 2 : succeed_if_same_string (keyBaseName (k), "#_10");
2265 :
2266 2 : keySetName (k, "user/tests/yajl/___empty_map");
2267 2 : succeed_if_same_string (keyBaseName (k), "___empty_map");
2268 2 : keySetBaseName (k, "#0");
2269 2 : succeed_if_same_string (keyBaseName (k), "#0");
2270 :
2271 2 : keySetBaseName (k, "nullkey");
2272 2 : succeed_if_same_string (keyBaseName (k), "nullkey");
2273 2 : succeed_if_same_string (keyName (k), "user/tests/yajl/nullkey");
2274 :
2275 : //! [base1]
2276 2 : keySetName (k, "system/valid");
2277 2 : keySetBaseName (k, ".hiddenkey");
2278 2 : succeed_if_same_string (keyName (k), "system/.hiddenkey");
2279 2 : succeed_if_same_string (keyBaseName (k), ".hiddenkey");
2280 : //! [base1]
2281 :
2282 : //! [base2]
2283 2 : keySetName (k, "system/valid");
2284 2 : keySetBaseName (k, "");
2285 2 : succeed_if_same_string (keyName (k), "system/%");
2286 2 : succeed_if_same_string (keyBaseName (k), "");
2287 : //! [base2]
2288 :
2289 : //! [base3]
2290 2 : keySetName (k, "system/valid");
2291 2 : keySetBaseName (k, "%");
2292 2 : succeed_if_same_string (keyName (k), "system/\\%");
2293 2 : succeed_if_same_string (keyBaseName (k), "%");
2294 : //! [base3]
2295 :
2296 2 : keyDel (k);
2297 2 : }
2298 :
2299 2 : static void test_keyAddBaseName (void)
2300 : {
2301 2 : printf ("Test add basename\n");
2302 :
2303 2 : Key * k = keyNew (0);
2304 :
2305 : //![base0 empty]
2306 2 : keySetName (k, "");
2307 2 : succeed_if_same_string (keyBaseName (k), "");
2308 2 : keySetName (k, "user");
2309 2 : succeed_if_same_string (keyBaseName (k), "");
2310 : //![base0 empty]
2311 :
2312 : //![base1 empty]
2313 2 : keySetName (k, "system/valid");
2314 2 : succeed_if (keyAddBaseName (k, "") >= 0, "could not add a base name");
2315 2 : succeed_if_same_string (keyName (k), "system/valid/%");
2316 2 : succeed_if_same_string (keyBaseName (k), "");
2317 : //![base1 empty]
2318 :
2319 2 : keySetName (k, "system/valid");
2320 2 : succeed_if (keyAddBaseName (k, "%") >= 0, "could not add a base name");
2321 2 : succeed_if_same_string (keyName (k), "system/valid/\\%");
2322 2 : succeed_if_same_string (keyBaseName (k), "%");
2323 :
2324 2 : keySetName (k, "system/valid");
2325 2 : succeed_if (keyAddBaseName (k, "#") == sizeof ("system/valid/#"), "could not add a base name");
2326 2 : succeed_if_same_string (keyName (k), "system/valid/#");
2327 2 : succeed_if_same_string (keyBaseName (k), "#");
2328 :
2329 2 : keySetName (k, "system/valid");
2330 2 : succeed_if (keyAddBaseName (k, "#_2") >= 0, "could not add a base name");
2331 2 : succeed_if_same_string (keyName (k), "system/valid/#_2");
2332 2 : succeed_if_same_string (keyBaseName (k), "#_2");
2333 :
2334 : //![base1 add]
2335 2 : keySetName (k, "system/valid");
2336 2 : succeed_if (keyAddBaseName (k, ".") >= 0, "could not add a base name");
2337 2 : succeed_if_same_string (keyName (k), "system/valid/\\.");
2338 2 : succeed_if_same_string (keyBaseName (k), ".");
2339 : //![base1 add]
2340 :
2341 2 : keySetName (k, "system/valid");
2342 2 : succeed_if (keyAddBaseName (k, "..") >= 0, "could not add a base name");
2343 2 : succeed_if_same_string (keyName (k), "system/valid/\\..");
2344 2 : succeed_if_same_string (keyBaseName (k), "..");
2345 :
2346 :
2347 2 : keySetName (k, "system/valid");
2348 2 : succeed_if (keyAddBaseName (k, "hello%#") >= 0, "could not add a base name");
2349 2 : succeed_if_same_string (keyName (k), "system/valid/hello%#");
2350 2 : succeed_if_same_string (keyBaseName (k), "hello%#");
2351 :
2352 2 : keySetName (k, "system/valid");
2353 2 : succeed_if (keyAddBaseName (k, "hello..") >= 0, "could not add a base name");
2354 2 : succeed_if_same_string (keyName (k), "system/valid/hello..");
2355 2 : succeed_if_same_string (keyBaseName (k), "hello..");
2356 :
2357 2 : keySetName (k, "system/valid");
2358 2 : succeed_if (keyAddBaseName (k, "..hello..") >= 0, "could not add a base name");
2359 2 : succeed_if_same_string (keyName (k), "system/valid/..hello..");
2360 2 : succeed_if_same_string (keyBaseName (k), "..hello..");
2361 :
2362 2 : keySetName (k, "system/valid");
2363 2 : succeed_if (keyAddBaseName (k, "has/slash") >= 0, "could not add a base name");
2364 2 : succeed_if_same_string (keyName (k), "system/valid/has\\/slash");
2365 2 : succeed_if_same_string (keyBaseName (k), "has/slash");
2366 :
2367 2 : keySetName (k, "system/valid");
2368 2 : keyAddBaseName (k, "#0");
2369 2 : succeed_if_same_string (keyName (k), "system/valid/#0");
2370 2 : succeed_if_same_string (keyBaseName (k), "#0");
2371 :
2372 2 : keyDel (k);
2373 2 : }
2374 :
2375 2 : static void test_keyDirectBelow (void)
2376 : {
2377 2 : printf ("Test direct below check\n");
2378 :
2379 2 : Key * k1 = keyNew ("/dir", KEY_CASCADING_NAME, KEY_END);
2380 2 : Key * k2 = keyNew ("/dir/directbelow", KEY_CASCADING_NAME, KEY_END);
2381 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2382 :
2383 2 : keySetName (k1, "user/dir");
2384 2 : keySetName (k2, "user/dir/directbelow");
2385 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2386 :
2387 2 : keySetName (k1, "user/dir");
2388 2 : keySetName (k2, "user/dir/direct\\/below");
2389 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2390 :
2391 2 : keySetName (k1, "user/dir");
2392 2 : keySetName (k2, "user/dir/direct\\/");
2393 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2394 :
2395 2 : keySetName (k1, "user/dir");
2396 2 : succeed_if (keySetName (k2, "user/dir/direct\\\\") > -1, "could not set correct name");
2397 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2398 :
2399 2 : keySetName (k1, "user/dir");
2400 2 : succeed_if (keySetName (k2, "user/dir/direct\\") == -1, "could set incorrect name");
2401 2 : succeed_if (keyIsDirectBelow (k1, k2) == 0, "invalid name: should not be direct below");
2402 :
2403 2 : keySetName (k1, "user/dir");
2404 2 : keySetName (k2, "user/dir/direct\\\\\\/below");
2405 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2406 :
2407 2 : keySetName (k1, "user/dir");
2408 2 : keySetName (k2, "user/dir/direct\\\\below");
2409 2 : succeed_if (keyIsBelow (k1, k2) == 1, "below");
2410 2 : succeed_if (keyIsDirectBelow (k1, k2) == 1, "not direct below");
2411 :
2412 2 : keySetName (k1, "user/dir");
2413 2 : keySetName (k2, "user/dir/direct\\\\/b");
2414 2 : succeed_if_same_string (keyName (k2), "user/dir/direct\\\\/b");
2415 2 : succeed_if (keyIsBelow (k1, k2) == 1, "below");
2416 2 : succeed_if (keyIsDirectBelow (k1, k2) == 0, "direct below, but shouldnt be");
2417 :
2418 2 : keySetName (k1, "user/dir");
2419 2 : keySetName (k2, "user/dir/direct\\\\/below");
2420 2 : succeed_if (keyIsBelow (k1, k2) == 1, "below");
2421 2 : succeed_if (keyIsDirectBelow (k1, k2) == 0, "direct below, but shouldnt be");
2422 :
2423 2 : keyDel (k1);
2424 2 : keyDel (k2);
2425 2 : }
2426 :
2427 2 : static void test_keyEscape (void)
2428 : {
2429 2 : printf ("test escape in basename\n");
2430 :
2431 2 : Key * k = keyNew ("/valid", KEY_END);
2432 : char buffer[500];
2433 :
2434 : #define TEST_ESCAPE_PART(A, S) \
2435 : do \
2436 : { \
2437 : succeed_if (keySetBaseName (k, A) != -1, "keySetBaseName returned an error"); \
2438 : succeed_if_same_string (keyBaseName (k), A); \
2439 : succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName returned an error"); \
2440 : succeed_if_same_string (buffer, A); \
2441 : } while (0)
2442 :
2443 : #include <data_escape.c>
2444 :
2445 2 : keySetName (k, "spec/valid");
2446 :
2447 : #include <data_escape.c>
2448 :
2449 2 : keySetName (k, "proc/valid");
2450 :
2451 : #include <data_escape.c>
2452 :
2453 2 : keySetName (k, "dir/valid");
2454 :
2455 : #include <data_escape.c>
2456 :
2457 2 : keySetName (k, "user/valid");
2458 :
2459 : #include <data_escape.c>
2460 :
2461 2 : keySetName (k, "system/valid");
2462 :
2463 : #include <data_escape.c>
2464 :
2465 : #undef TEST_ESCAPE_PART
2466 : #define TEST_ESCAPE_PART(A, S) \
2467 : do \
2468 : { \
2469 : succeed_if (keySetBaseName (k, A) == -1, "keySetBaseName should have returned an error"); \
2470 : succeed_if_same_string (keyBaseName (k), ""); \
2471 : succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName returned an error"); \
2472 : succeed_if_same_string (buffer, ""); \
2473 : } while (0)
2474 :
2475 12 : for (int i = 0; i < NUMBER_OF_NAMESPACES; ++i)
2476 : {
2477 12 : keySetName (k, namespaces[i]);
2478 :
2479 : #include <data_escape.c>
2480 : }
2481 :
2482 2 : keySetName (k, "/");
2483 2 : succeed_if (keyAddBaseName (k, "valid") != -1, "keyAddBaseName returned an error");
2484 2 : succeed_if_same_string (keyBaseName (k), "valid");
2485 2 : succeed_if_same_string (keyName (k), "/valid");
2486 :
2487 :
2488 : // generates huge key (but fits within 500)
2489 : #undef TEST_ESCAPE_PART
2490 : #define TEST_ESCAPE_PART(A, S) \
2491 : do \
2492 : { \
2493 : succeed_if (keyAddBaseName (k, A) != -1, "keyAddBaseName returned an error"); \
2494 : succeed_if_same_string (keyBaseName (k), A); \
2495 : succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName (for keyAddBaseName) returned an error"); \
2496 : succeed_if_same_string (buffer, A); \
2497 : } while (0)
2498 :
2499 12 : for (int i = 0; i < NUMBER_OF_NAMESPACES; ++i)
2500 : {
2501 12 : keySetName (k, namespaces[i]);
2502 :
2503 : #include <data_escape.c>
2504 : }
2505 :
2506 2 : keyDel (k);
2507 2 : }
2508 :
2509 2 : static void test_keyAdd (void)
2510 : {
2511 2 : printf ("test keyAdd\n");
2512 :
2513 2 : Key * k = keyNew ("", KEY_END);
2514 2 : succeed_if (keyAddName (0, "valid") == -1, "cannot add to null name");
2515 2 : succeed_if (keyAddName (k, "valid") == -1, "added to empty name?");
2516 :
2517 2 : keySetName (k, "/");
2518 2 : succeed_if (keyAddName (k, 0) == 0, "cannot add null pointer");
2519 2 : succeed_if (keyAddName (k, "") == 0, "cannot add empty name");
2520 2 : succeed_if (keyAddName (k, "/") == 0, "cannot add slashes");
2521 2 : succeed_if (keyAddName (k, "//") == 0, "cannot add slashes");
2522 2 : succeed_if (keyAddName (k, "////") == 0, "cannot add slashes");
2523 2 : succeed_if (keyAddName (k, "invalid\\") == -1, "added invalid name");
2524 2 : succeed_if (keyAddName (k, "valid") == sizeof ("/valid"), "added valid name");
2525 :
2526 2 : keySetName (k, "user");
2527 2 : succeed_if (keyAddName (k, 0) == 0, "cannot add null pointer");
2528 2 : succeed_if (keyAddName (k, "") == 0, "cannot add empty name");
2529 2 : succeed_if (keyAddName (k, "/") == 0, "cannot add slashes");
2530 2 : succeed_if (keyAddName (k, "//") == 0, "cannot add slashes");
2531 2 : succeed_if (keyAddName (k, "////") == 0, "cannot add slashes");
2532 2 : succeed_if (keyAddName (k, "invalid\\") == -1, "added invalid name");
2533 2 : succeed_if (keyAddName (k, "valid") == sizeof ("user/valid"), "added valid name");
2534 :
2535 : #undef TEST_NOESCAPE_PART
2536 : #define TEST_NOESCAPE_PART(A, S) \
2537 : do \
2538 : { \
2539 : succeed_if (keyAddName (k, A) != -1, "keyAddName returned an error"); \
2540 : succeed_if_same_string (keyBaseName (k), S); \
2541 : succeed_if (keyGetBaseName (k, buffer, 499) != -1, "keyGetBaseName returned an error"); \
2542 : succeed_if_same_string (buffer, S); \
2543 : } while (0)
2544 : char buffer[500];
2545 :
2546 12 : for (int i = 0; i < NUMBER_OF_NAMESPACES; ++i)
2547 : {
2548 12 : keySetName (k, namespaces[i]);
2549 :
2550 : #include <data_noescape.c>
2551 : }
2552 :
2553 2 : keyDel (k);
2554 2 : }
2555 :
2556 2 : void test_keyCascading (void)
2557 : {
2558 2 : printf ("test cascading\n");
2559 :
2560 2 : Key * k = keyNew ("/", KEY_END);
2561 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2562 2 : succeed_if_same_string (keyName (k), "/");
2563 2 : succeed_if_same_string (keyBaseName (k), "");
2564 :
2565 2 : succeed_if (keyAddName (k, "valid") > 0, "could not add valid");
2566 2 : succeed_if (keyGetNameSize (k) == 7, "size not correct");
2567 2 : succeed_if_same_string (keyName (k), "/valid");
2568 2 : succeed_if_same_string (keyBaseName (k), "valid");
2569 :
2570 2 : keySetName (k, "/");
2571 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2572 2 : succeed_if (keyAddName (k, "/valid") == 7, "could not add valid with starting slash");
2573 2 : succeed_if (keyGetNameSize (k) == 7, "size not correct");
2574 2 : succeed_if_same_string (keyName (k), "/valid");
2575 2 : succeed_if_same_string (keyBaseName (k), "valid");
2576 :
2577 2 : keySetName (k, "////");
2578 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2579 2 : succeed_if (keyAddName (k, "/////valid") == 7, "could not add valid with starting slash");
2580 2 : succeed_if (keyGetNameSize (k) == 7, "size not correct");
2581 2 : succeed_if_same_string (keyName (k), "/valid");
2582 2 : succeed_if_same_string (keyBaseName (k), "valid");
2583 :
2584 2 : keySetName (k, "/");
2585 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2586 2 : succeed_if (keyAddName (k, "/////more/valid") > 0, "could not add valid with starting slash");
2587 2 : succeed_if_same_string (keyName (k), "/more/valid");
2588 2 : succeed_if_same_string (keyBaseName (k), "valid");
2589 :
2590 2 : keySetName (k, "/");
2591 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2592 2 : succeed_if (keyAddName (k, "/////./valid") == 7, "could not add valid with starting slash");
2593 2 : succeed_if (keyGetNameSize (k) == 7, "size not correct");
2594 2 : succeed_if_same_string (keyName (k), "/valid");
2595 2 : succeed_if_same_string (keyBaseName (k), "valid");
2596 :
2597 2 : keySetName (k, "/");
2598 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2599 2 : succeed_if (keyAddName (k, "/////more/../valid") == 7, "could not add valid with ..");
2600 2 : succeed_if (keyGetNameSize (k) == 7, "size not correct");
2601 2 : succeed_if_same_string (keyName (k), "/valid");
2602 2 : succeed_if_same_string (keyBaseName (k), "valid");
2603 :
2604 2 : keySetName (k, "/");
2605 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2606 2 : succeed_if (keyAddName (k, "/////..") == 0, "try to substract root with ..");
2607 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2608 2 : succeed_if_same_string (keyName (k), "/");
2609 2 : succeed_if_same_string (keyBaseName (k), "");
2610 :
2611 2 : keySetName (k, "/");
2612 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2613 2 : succeed_if (keyAddName (k, "/////../more") == sizeof ("/more"), "try to substract root with ..");
2614 2 : succeed_if (keyGetNameSize (k) == sizeof ("/more"), "size not correct");
2615 2 : succeed_if_same_string (keyName (k), "/more");
2616 2 : succeed_if_same_string (keyBaseName (k), "more");
2617 :
2618 :
2619 2 : keySetName (k, "/");
2620 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2621 2 : succeed_if (keyAddName (k, "/////more/..") == 0, "could not add nothing with ..");
2622 2 : succeed_if (keyGetNameSize (k) == 2, "size not correct");
2623 2 : succeed_if_same_string (keyName (k), "/");
2624 2 : succeed_if_same_string (keyBaseName (k), "");
2625 :
2626 :
2627 2 : keySetName (k, "/");
2628 2 : succeed_if (keyAddName (k, "/is//../a//../complex/..///.") == 0, "could not add complex stuff");
2629 2 : succeed_if_same_string (keyName (k), "/");
2630 2 : succeed_if_same_string (keyBaseName (k), "");
2631 :
2632 : // printf ("%s\n", keyName(k));
2633 :
2634 2 : keyDel (k);
2635 2 : }
2636 :
2637 2 : static void test_keyUnescapedName (void)
2638 : {
2639 2 : printf ("test keyUnescapedName\n");
2640 :
2641 2 : Key * k = keyNew ("user/something", KEY_END);
2642 2 : succeed_if (!memcmp (keyUnescapedName (k), "user\0something", sizeof ("user/something")), "unescaped name wrong");
2643 :
2644 2 : keySetName (k, "/something/else");
2645 2 : succeed_if (!memcmp (keyUnescapedName (k), "\0something\0else", sizeof ("/something/else")), "unescaped cascading name wrong");
2646 :
2647 2 : keySetName (k, "/\\/other/more");
2648 2 : succeed_if (!memcmp (keyUnescapedName (k), "\0/other\0more", sizeof ("\0/other\0more")), "unescaped cascading name wrong");
2649 :
2650 2 : keySetName (k, "/\\/other/\\/more");
2651 2 : succeed_if (!memcmp (keyUnescapedName (k), "\0/other\0/more", sizeof ("\0/other\0/more")), "unescaped cascading name wrong");
2652 :
2653 2 : keySetName (k, "system/something/else");
2654 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else", sizeof ("system/something/else")), "unescaped name wrong");
2655 :
2656 2 : keyAddBaseName (k, "more");
2657 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0more", sizeof ("system/something/else/more")),
2658 : "unescaped name wrong");
2659 :
2660 2 : keySetBaseName (k, "else");
2661 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0else", sizeof ("system/something/else/else")),
2662 : "unescaped name wrong");
2663 :
2664 2 : keySetBaseName (k, "");
2665 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0\0", sizeof ("system/something/else/")),
2666 : "unescaped name wrong");
2667 :
2668 2 : keySetBaseName (k, "%");
2669 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0%", sizeof ("system/something/else/%")),
2670 : "unescaped name wrong");
2671 :
2672 2 : keySetBaseName (k, "\\");
2673 2 : succeed_if_same_string (keyBaseName (k), "\\");
2674 2 : char sol1[] = "system\0something\0else\0\\";
2675 2 : succeed_if (!memcmp (keyUnescapedName (k), sol1, sizeof (sol1)), "unescaped name wrong");
2676 :
2677 : /* print memory of keyUnescapedName
2678 : for (size_t i = 0; i<sizeof(sol1); ++i)
2679 : {
2680 : printf ("%c %d\n", (char)((char*)keyUnescapedName(k))[i], (int)((char*)keyUnescapedName(k))[i]);
2681 : }
2682 : */
2683 :
2684 2 : keySetBaseName (k, "\\\\");
2685 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something\0else\0\\\\", sizeof ("system/something/else/\\\\")),
2686 : "unescaped name wrong");
2687 :
2688 2 : keySetName (k, "system/something\\/else");
2689 2 : succeed_if (!memcmp (keyUnescapedName (k), "system\0something/else", sizeof ("system/something/else")), "unescaped name wrong");
2690 :
2691 2 : succeed_if (keySetName (k, "system/something/else/\\") == -1, "tangling backslash");
2692 :
2693 2 : keySetName (k, "system/something/else/\\\\");
2694 2 : char sol2[] = "system\0something\0else\0\\";
2695 2 : succeed_if (!memcmp (keyUnescapedName (k), sol2, sizeof (sol2)), "unescaped name wrong");
2696 : /*
2697 : for (size_t i = 0; i<sizeof(sol2); ++i)
2698 : {
2699 : printf ("%c %d\n", (char)((char*)keyUnescapedName(k))[i], (int)((char*)keyUnescapedName(k))[i]);
2700 : }
2701 : */
2702 :
2703 2 : keyDel (k);
2704 2 : }
2705 :
2706 2 : static void test_keyCanonify (void)
2707 : {
2708 2 : printf ("test canonify\n");
2709 :
2710 2 : Key * k = keyNew ("/a/very/long/#0/name\\/with/sec\\tion/and\\\\/subsection/and!/$%&/chars()/[about]/{some}/_-.,;:/€/»/|/key",
2711 : KEY_CASCADING_NAME, KEY_END);
2712 2 : succeed_if_same_string (
2713 : keyName (k), "/a/very/long/#0/name\\/with/sec\\tion/and\\\\/subsection/and!/$%&/chars()/[about]/{some}/_-.,;:/€/»/|/key");
2714 2 : succeed_if (keyGetNameSize (k) == 105, "name size wrong");
2715 2 : succeed_if (keyGetUnescapedNameSize (k) == 103, "unescaped name size wrong");
2716 2 : succeed_if_same_string ((char *) keyUnescapedName (k), "");
2717 2 : succeed_if_same_string ((char *) keyUnescapedName (k) + 1, "a");
2718 2 : succeed_if_same_string ((char *) keyUnescapedName (k) + 3, "very");
2719 2 : succeed_if_same_string ((char *) keyUnescapedName (k) + 99, "key");
2720 :
2721 2 : keyDel (k);
2722 2 : }
2723 :
2724 2 : int main (int argc, char ** argv)
2725 : {
2726 2 : printf ("KEY ABI TESTS\n");
2727 2 : printf ("==================\n\n");
2728 :
2729 2 : init (argc, argv);
2730 :
2731 2 : test_keyNewSpecial ();
2732 2 : test_keyNewSystem ();
2733 2 : test_keyNewUser ();
2734 2 : test_keyReference ();
2735 2 : test_keyName ();
2736 2 : test_keyNameSlashes ();
2737 2 : test_keyValue ();
2738 2 : test_keyBinary ();
2739 2 : test_keyInactive ();
2740 2 : test_keyBelow ();
2741 2 : test_keyDup ();
2742 2 : test_keyCopy ();
2743 2 : test_binary ();
2744 2 : test_keyBelowOrSame ();
2745 2 : test_keyNameSpecial ();
2746 2 : test_keyClear ();
2747 2 : test_keyBaseName ();
2748 2 : test_keySetBaseName ();
2749 2 : test_keyAddBaseName ();
2750 2 : test_keyDirectBelow ();
2751 2 : test_keyEscape ();
2752 2 : test_keyAdd ();
2753 2 : test_keyCascading ();
2754 2 : test_keyUnescapedName ();
2755 2 : test_keyCanonify ();
2756 :
2757 2 : printf ("\ntestabi_key RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
2758 :
2759 2 : return nbError;
2760 : }
|