Line data Source code
1 : /**
2 : * @file
3 : *
4 : * @brief Test suite for meta information.
5 : *
6 : * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
7 : */
8 :
9 : #include <tests.h>
10 :
11 2 : static void test_basic (void)
12 : {
13 : Key * key;
14 2 : key = keyNew ("user/key_with_meta", KEY_END);
15 2 : exit_if_fail (key, "could not create new key");
16 2 : succeed_if (keyGetMeta (key, "hello") == 0, "hello was not set up to now");
17 2 : succeed_if (keyGetMeta (key, "error") == 0, "hello was not set up to now");
18 :
19 2 : keySetMeta (key, "hello", "hello_world");
20 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "hello_world");
21 :
22 2 : keySetMeta (key, "mode", "0644");
23 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "hello_world");
24 :
25 2 : keySetMeta (key, "time", "1271234264");
26 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "hello_world");
27 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0644");
28 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271234264");
29 :
30 2 : keySetMeta (key, "hello", "between");
31 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "hello")), "between");
32 :
33 2 : keySetMeta (key, "hello", 0);
34 2 : succeed_if (keyValue (keyGetMeta (key, "hello")) == 0, "could not remove metadata");
35 :
36 2 : keySetMeta (key, "hello", "goodbye");
37 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "goodbye"), "could not set meta information again (2x)");
38 :
39 2 : keySetMeta (key, "empty", "");
40 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
41 :
42 2 : keySetMeta (key, "owner", "hugo");
43 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "hugo");
44 :
45 2 : keySetMeta (key, "mode", "775");
46 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "owner")), "hugo");
47 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "775");
48 :
49 2 : keySetMeta (key, "", "empty");
50 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "empty");
51 :
52 2 : keySetMeta (key, "", "");
53 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "");
54 :
55 2 : keySetMeta (key, "", 0);
56 2 : succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
57 :
58 :
59 2 : keyDel (key);
60 2 : }
61 :
62 2 : static void test_iterate (void)
63 : {
64 : Key * key;
65 :
66 2 : key = keyNew ("user/test", KEY_END);
67 2 : exit_if_fail (key, "could not create new key");
68 2 : succeed_if (keyRewindMeta (key) == 0, "Could not rewind empty key");
69 2 : succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty");
70 2 : succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty");
71 :
72 2 : keySetMeta (key, "meta1", "meta_value");
73 2 : succeed_if (keyRewindMeta (key) == 0, "Could not rewind key");
74 2 : succeed_if_same_string (keyName (keyNextMeta (key)), "meta1");
75 2 : succeed_if_same_string (keyValue (keyCurrentMeta (key)), "meta_value");
76 :
77 2 : succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty at 2. iteration");
78 2 : succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty at 2. iteration");
79 :
80 2 : succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty at 3. iteration");
81 2 : succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty at 3. iteration");
82 :
83 2 : succeed_if (keyNextMeta (key) == 0, "Could get next metaname, even if it is empty at 4. iteration");
84 2 : succeed_if (keyCurrentMeta (key) == 0, "Could get next metavalue, even if it is empty at 4. iteration");
85 :
86 2 : keyDel (key);
87 2 : }
88 :
89 2 : static void test_size (void)
90 : {
91 : Key * key;
92 : char * buffer;
93 :
94 2 : key = keyNew ("user/test", KEY_END);
95 2 : exit_if_fail (key, "could not create new key");
96 2 : succeed_if (keyValue (keyGetMeta (key, "hello")) == 0, "hello was not set up to now");
97 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == -1, "got wrong size for empty metavalue");
98 :
99 2 : keySetMeta (key, "hello", "hello_world");
100 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "hello_world"), "could not receive previously set meta information");
101 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == sizeof ("hello_world"), "got wrong size");
102 :
103 2 : keySetMeta (key, "mode", "0644");
104 2 : keySetMeta (key, "time", "1271234264");
105 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "hello_world"), "meta info changed unexpectly");
106 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0644");
107 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "mode")) == sizeof ("0644"), "got wrong size");
108 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271234264");
109 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "time")) == sizeof ("1271234264"), "got wrong size");
110 :
111 2 : keySetMeta (key, "hello", "between");
112 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "between"), "could not set meta information again");
113 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == sizeof ("between"), "got wrong size");
114 2 : buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "hello")));
115 2 : succeed_if (keyGetString (keyGetMeta (key, "hello"), buffer, keyGetValueSize (keyGetMeta (key, "hello"))) ==
116 : keyGetValueSize (keyGetMeta (key, "hello")),
117 : "could not get meta");
118 2 : succeed_if_same_string (buffer, "between");
119 2 : elektraFree (buffer);
120 :
121 :
122 2 : keySetMeta (key, "hello", 0);
123 2 : succeed_if (keyValue (keyGetMeta (key, "hello")) == 0, "could not remove metadata");
124 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == -1, "got wrong size");
125 :
126 2 : keySetMeta (key, "hello", "goodbye");
127 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "goodbye"), "could not set meta information again (2x)");
128 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "hello")) == sizeof ("goodbye"), "got wrong size");
129 2 : buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "hello")));
130 2 : succeed_if (keyGetString (keyGetMeta (key, "hello"), buffer, keyGetValueSize (keyGetMeta (key, "hello"))) ==
131 : keyGetValueSize (keyGetMeta (key, "hello")),
132 : "could not get meta");
133 2 : succeed_if_same_string (buffer, "goodbye");
134 2 : elektraFree (buffer);
135 :
136 2 : keySetMeta (key, "empty", "");
137 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
138 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "empty")) == sizeof (""), "got wrong size");
139 2 : buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "empty")));
140 2 : succeed_if (keyGetString (keyGetMeta (key, "empty"), buffer, keyGetValueSize (keyGetMeta (key, "empty"))) ==
141 : keyGetValueSize (keyGetMeta (key, "empty")),
142 : "could not get meta");
143 2 : succeed_if_same_string (buffer, "");
144 2 : elektraFree (buffer);
145 :
146 2 : keySetMeta (key, "", "empty");
147 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "empty");
148 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "")) == sizeof ("empty"), "got wrong size");
149 2 : buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "")));
150 2 : succeed_if (keyGetString (keyGetMeta (key, ""), buffer, keyGetValueSize (keyGetMeta (key, ""))) ==
151 : keyGetValueSize (keyGetMeta (key, "")),
152 : "could not get meta");
153 2 : succeed_if_same_string (buffer, "empty");
154 2 : elektraFree (buffer);
155 :
156 2 : keySetMeta (key, "", "");
157 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "");
158 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "")) == sizeof (""), "got wrong size");
159 2 : buffer = calloc (1, keyGetValueSize (keyGetMeta (key, "")));
160 2 : succeed_if (keyGetString (keyGetMeta (key, ""), buffer, keyGetValueSize (keyGetMeta (key, ""))) ==
161 : keyGetValueSize (keyGetMeta (key, "")),
162 : "could not get meta");
163 2 : succeed_if_same_string (buffer, "");
164 2 : elektraFree (buffer);
165 :
166 2 : keySetMeta (key, "", 0);
167 2 : succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
168 2 : succeed_if (keyGetValueSize (keyGetMeta (key, "")) == -1, "got wrong size");
169 :
170 :
171 2 : keyDel (key);
172 2 : }
173 :
174 2 : static void test_dup (void)
175 : {
176 : Key * key;
177 : Key * dup;
178 :
179 2 : key = keyNew ("user/orig", KEY_END);
180 2 : succeed_if (keySetMeta (key, "test", "some_meta_test") == sizeof ("some_meta_test"), "could not set meta");
181 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "test")), "some_meta_test");
182 :
183 2 : dup = keyDup (key);
184 2 : succeed_if_same_string (keyValue (keyGetMeta (dup, "test")), "some_meta_test");
185 2 : succeed_if (keySetMeta (dup, "test", "some_other_meta_test") == sizeof ("some_other_meta_test"), "sizeof meta test wrong");
186 2 : succeed_if_same_string (keyValue (keyGetMeta (dup, "test")), "some_other_meta_test");
187 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "test")), "some_meta_test");
188 2 : keyDel (dup);
189 :
190 2 : keyDel (key);
191 2 : }
192 :
193 : Key * g_c;
194 :
195 2 : static void j (Key * k)
196 : {
197 2 : size_t size = keyGetValueSize (k);
198 2 : char * value = elektraMalloc (size);
199 2 : int bstring = keyIsString (k);
200 :
201 : // receive key g_c
202 2 : memcpy (value, keyValue (k), size);
203 2 : keyCopy (k, g_c);
204 2 : if (bstring)
205 2 : keySetString (k, value);
206 : else
207 0 : keySetBinary (k, value, size);
208 2 : elektraFree (value);
209 : // the caller will see the changed key k
210 : // with the metadata from g_c
211 2 : }
212 :
213 : static void l (Key * k)
214 : {
215 : // receive g_c
216 2 : keyCopyMeta (k, g_c, "type");
217 : // the caller will see the changed key k
218 : // with the metadata "type" from g_c
219 : }
220 :
221 2 : static void test_examples (void)
222 : {
223 : Key * key;
224 2 : key = keyNew (0);
225 2 : keySetMeta (key, "def", "abc");
226 2 : keySetMeta (key, "nop", "cup");
227 :
228 2 : g_c = keyNew (0);
229 2 : keySetMeta (g_c, "xef", "ybc");
230 2 : keySetMeta (g_c, "xop", "yup");
231 :
232 2 : j (key);
233 :
234 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "xef")), "ybc");
235 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "xop")), "yup");
236 2 : succeed_if (keyValue (keyGetMeta (key, "def")) == 0, "old metadata remained");
237 2 : succeed_if (keyValue (keyGetMeta (key, "nop")) == 0, "old metadata remained");
238 :
239 2 : keyDel (key);
240 2 : keyDel (g_c);
241 :
242 2 : key = keyNew (0);
243 2 : keySetMeta (key, "def", "abc");
244 2 : keySetMeta (key, "nop", "cup");
245 :
246 2 : g_c = keyNew (0);
247 2 : keySetMeta (g_c, "type", "boolean");
248 2 : keySetMeta (g_c, "xop", "yup");
249 :
250 2 : l (key);
251 :
252 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "def")), "abc");
253 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "nop")), "cup");
254 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "type")), "boolean");
255 2 : succeed_if (keyValue (keyGetMeta (key, "xop")) == 0, "this metadata was not requested to be copied");
256 :
257 2 : keyDel (key);
258 2 : keyDel (g_c);
259 2 : }
260 :
261 2 : static void test_copy (void)
262 : {
263 2 : printf ("Test key meta copy\n");
264 :
265 : Key * key1;
266 : Key * key2;
267 :
268 2 : succeed_if (key1 = keyNew (0), "could not create key");
269 2 : succeed_if (key2 = keyNew (0), "could not create key");
270 :
271 2 : succeed_if (keyCopyMeta (key2, key1, "nonexist") == 0, "could not do anything");
272 :
273 2 : succeed_if (keyValue (keyGetMeta (key2, "nonexist")) == 0, "should not be there");
274 :
275 2 : keyDel (key1);
276 2 : keyDel (key2);
277 :
278 :
279 2 : succeed_if (key1 = keyNew (0), "could not create key");
280 2 : succeed_if (key2 = keyNew (0), "could not create key");
281 :
282 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
283 2 : succeed_if (keyCopyMeta (key2, key1, "mymeta") == 1, "could not copy metavalue");
284 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
285 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
286 2 : succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
287 :
288 2 : succeed_if (keyCopyMeta (key1, key2, "mymeta") == 1, "did nothing in the end");
289 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
290 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
291 2 : succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
292 :
293 2 : keyDel (key1);
294 2 : keyDel (key2);
295 :
296 :
297 2 : succeed_if (key1 = keyNew (0), "could not create key");
298 2 : succeed_if (key2 = keyNew (0), "could not create key");
299 :
300 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
301 2 : succeed_if (keyCopyMeta (key2, key1, "mymeta") == 1, "could not copy metavalue");
302 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
303 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
304 2 : succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
305 :
306 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
307 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
308 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
309 2 : succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key");
310 :
311 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue2") == sizeof ("a longer metavalue2"), "could not set metavalue2");
312 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue2");
313 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
314 2 : succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key (with another value)");
315 :
316 2 : keyDel (key1);
317 2 : keyDel (key2);
318 :
319 : Key * k;
320 : Key * c;
321 :
322 : // clang-format off
323 2 : k=keyNew ("user/metakey",
324 : KEY_META, "t", "test1",
325 : KEY_META, "a", "another",
326 : KEY_META, "cya", "see the metadata later",
327 : KEY_META, "mode", "0775",
328 : KEY_END);
329 : // clang-format on
330 2 : c = keyNew ("user/metacopy", KEY_END);
331 :
332 2 : succeed_if (keyGetMeta (k, "t") != 0, "could not get metakey");
333 2 : succeed_if (keyGetMeta (k, "a") != 0, "could not get metakey");
334 :
335 2 : succeed_if (keyGetMeta (c, "t") == 0, "could get metakey not there");
336 2 : succeed_if (keyGetMeta (c, "a") == 0, "could get metakey not there");
337 :
338 2 : succeed_if (keyCopyMeta (c, k, "t") == 1, "could not copy metadata");
339 2 : succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
340 :
341 2 : succeed_if (keyCopyMeta (c, k, "a") == 1, "could not copy metadata");
342 2 : succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
343 :
344 2 : keyDel (k);
345 2 : keyDel (c);
346 :
347 :
348 : // clang-format off
349 2 : k=keyNew ("user/metakey",
350 : KEY_META, "t", "test1",
351 : KEY_META, "a", "another",
352 : KEY_META, "cya", "see the metadata later",
353 : KEY_META, "mode", "0775",
354 : KEY_END);
355 2 : c=keyNew ("user/metacopy",
356 : KEY_META, "t", "test1",
357 : KEY_META, "a", "wrong",
358 : KEY_META, "old", "will stay",
359 : KEY_END);
360 : // clang-format on
361 :
362 2 : succeed_if (keyGetMeta (k, "t") != 0, "could not get metakey");
363 2 : succeed_if (keyGetMeta (k, "a") != 0, "could not get metakey");
364 :
365 2 : succeed_if (keyCopyMeta (c, k, "t") == 1, "could not copy metadata");
366 2 : succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
367 2 : succeed_if_same_string (keyValue (keyGetMeta (k, "t")), "test1");
368 2 : succeed_if_same_string (keyValue (keyGetMeta (c, "t")), "test1");
369 :
370 2 : succeed_if (keyCopyMeta (c, k, "a") == 1, "could not copy metadata");
371 2 : succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
372 2 : succeed_if_same_string (keyValue (keyGetMeta (k, "a")), "another");
373 2 : succeed_if_same_string (keyValue (keyGetMeta (c, "a")), "another");
374 :
375 2 : succeed_if_same_string (keyValue (keyGetMeta (c, "old")), "will stay");
376 2 : succeed_if (keyGetMeta (c, "cya") == 0, "metakey should not be there");
377 2 : succeed_if (keyGetMeta (c, "mode") == 0, "metakey should not be there");
378 :
379 2 : keyDel (k);
380 2 : keyDel (c);
381 2 : }
382 :
383 2 : static void test_new (void)
384 : {
385 : Key * key;
386 : // clang-format off
387 2 : key = keyNew ("user/test",
388 : KEY_META, "hello", "hello_world",
389 : KEY_META, "mode", "0644",
390 : KEY_META, "time", "1271234264",
391 : KEY_META, "empty", "",
392 : KEY_META, "", "empty",
393 : KEY_END);
394 : // clang-format on
395 :
396 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "hello_world"), "could not receive previously set meta information");
397 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0644");
398 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271234264");
399 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
400 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "empty");
401 :
402 2 : keySetMeta (key, "", "full");
403 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "full");
404 :
405 2 : keySetMeta (key, "", 0);
406 2 : succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
407 :
408 2 : keyDel (key);
409 :
410 : // clang-format off
411 2 : key = keyNew ("user/test",
412 : KEY_META, "hello", "goodbye",
413 : KEY_META, "mode", "0775",
414 : KEY_META, "time", "1271939923",
415 : KEY_META, "empty", "",
416 : KEY_META, "", "",
417 : KEY_END);
418 : // clang-format on
419 :
420 2 : succeed_if (!strcmp (keyValue (keyGetMeta (key, "hello")), "goodbye"), "could not receive previously set meta information");
421 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "mode")), "0775");
422 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "time")), "1271939923");
423 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "empty")), "");
424 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "");
425 :
426 2 : keySetMeta (key, "", "full");
427 2 : succeed_if_same_string (keyValue (keyGetMeta (key, "")), "full");
428 :
429 2 : keySetMeta (key, "", 0);
430 2 : succeed_if (keyValue (keyGetMeta (key, "")) == 0, "could not remove empty metadata");
431 :
432 2 : keyDel (key);
433 2 : }
434 :
435 :
436 2 : static void test_copyall (void)
437 : {
438 2 : printf ("Test key meta copy all\n");
439 :
440 : Key * key1;
441 : Key * key2;
442 :
443 2 : succeed_if (key1 = keyNew (0), "could not create key");
444 2 : succeed_if (key2 = keyNew (0), "could not create key");
445 :
446 2 : succeed_if (keyCopyAllMeta (key2, key1) == 0, "could not do anything");
447 :
448 2 : succeed_if (keyValue (keyGetMeta (key2, "nonexist")) == 0, "should not be there");
449 :
450 2 : keyDel (key1);
451 2 : keyDel (key2);
452 :
453 :
454 2 : succeed_if (key1 = keyNew (0), "could not create key");
455 2 : succeed_if (key2 = keyNew (0), "could not create key");
456 :
457 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
458 2 : succeed_if (keyCopyAllMeta (key2, key1) == 1, "could not copy metavalue");
459 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
460 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
461 2 : succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
462 :
463 2 : succeed_if (keyCopyAllMeta (key1, key2) == 1, "did nothing in the end");
464 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
465 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
466 2 : succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
467 :
468 2 : keyDel (key1);
469 2 : keyDel (key2);
470 :
471 :
472 2 : succeed_if (key1 = keyNew (0), "could not create key");
473 2 : succeed_if (key2 = keyNew (0), "could not create key");
474 :
475 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
476 2 : succeed_if (keyCopyAllMeta (key2, key1) == 1, "could not copy metavalue");
477 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
478 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
479 2 : succeed_if (keyGetMeta (key1, "mymeta") == keyGetMeta (key2, "mymeta"), "reference to the same key");
480 :
481 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue") == sizeof ("a longer metavalue"), "could not set metavalue");
482 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue");
483 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
484 2 : succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key");
485 :
486 2 : succeed_if (keySetMeta (key1, "mymeta", "a longer metavalue2") == sizeof ("a longer metavalue2"), "could not set metavalue2");
487 2 : succeed_if_same_string (keyValue (keyGetMeta (key1, "mymeta")), "a longer metavalue2");
488 2 : succeed_if_same_string (keyValue (keyGetMeta (key2, "mymeta")), "a longer metavalue");
489 2 : succeed_if (keyGetMeta (key1, "mymeta") != keyGetMeta (key2, "mymeta"), "reference to another key (with another value)");
490 :
491 2 : keyDel (key1);
492 2 : keyDel (key2);
493 :
494 : Key * k;
495 : Key * c;
496 :
497 : // clang-format off
498 2 : k=keyNew ("user/metakey",
499 : KEY_META, "t", "test1",
500 : KEY_META, "a", "another",
501 : KEY_META, "cya", "see the metadata later",
502 : KEY_META, "mode", "0775",
503 : KEY_END);
504 : // clang-format on
505 2 : c = keyNew ("user/metacopy", KEY_END);
506 :
507 2 : succeed_if (keyGetMeta (k, "t") != 0, "could not get metakey");
508 2 : succeed_if (keyGetMeta (k, "a") != 0, "could not get metakey");
509 :
510 2 : succeed_if (keyGetMeta (c, "t") == 0, "could get metakey not there");
511 2 : succeed_if (keyGetMeta (c, "a") == 0, "could get metakey not there");
512 :
513 2 : succeed_if (keyCopyAllMeta (c, k) == 1, "could not copy metadata");
514 2 : succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
515 2 : succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
516 2 : succeed_if (keyGetMeta (k, "cya") == keyGetMeta (c, "cya"), "not the same metadata after copy");
517 2 : succeed_if (keyGetMeta (k, "mode") == keyGetMeta (c, "mode"), "not the same metadata after copy");
518 2 : succeed_if (keyValue (keyGetMeta (k, "nonexist")) == 0, "should not be there");
519 2 : succeed_if (keyValue (keyGetMeta (c, "nonexist")) == 0, "should not be there");
520 :
521 2 : succeed_if (keyCopyAllMeta (c, k) == 1, "could not copy metadata (again)");
522 2 : succeed_if (keyGetMeta (k, "t") == keyGetMeta (c, "t"), "not the same metadata after copy");
523 2 : succeed_if (keyGetMeta (k, "a") == keyGetMeta (c, "a"), "not the same metadata after copy");
524 2 : succeed_if (keyGetMeta (k, "cya") == keyGetMeta (c, "cya"), "not the same metadata after copy");
525 2 : succeed_if (keyGetMeta (k, "mode") == keyGetMeta (c, "mode"), "not the same metadata after copy");
526 2 : succeed_if (keyValue (keyGetMeta (k, "nonexist")) == 0, "should not be there");
527 2 : succeed_if (keyValue (keyGetMeta (c, "nonexist")) == 0, "should not be there");
528 :
529 2 : keyDel (k);
530 2 : keyDel (c);
531 2 : }
532 :
533 2 : static void test_type (void)
534 : {
535 : Key * key;
536 :
537 2 : succeed_if (key = keyNew (0), "could not create a new key");
538 2 : succeed_if (keyValue (keyGetMeta (key, "binary")) == 0, "wrong type after key creation");
539 2 : succeed_if (keySetString (key, "mystring") == sizeof ("mystring"), "could not set string");
540 2 : succeed_if (keyValue (keyGetMeta (key, "binary")) == 0, "wrong type after setting string");
541 2 : succeed_if (keySetBinary (key, "mystring", sizeof ("mystring")) == sizeof ("mystring"), "could not set binary");
542 2 : succeed_if (keyValue (keyGetMeta (key, "binary")) != 0, "wrong type after setting string");
543 :
544 2 : keyDel (key);
545 2 : }
546 :
547 :
548 2 : int main (int argc, char ** argv)
549 : {
550 2 : printf ("KEY META ABI TESTS\n");
551 2 : printf ("==================\n\n");
552 :
553 2 : init (argc, argv);
554 2 : test_basic ();
555 2 : test_iterate ();
556 2 : test_size ();
557 2 : test_dup ();
558 2 : test_examples ();
559 2 : test_type ();
560 2 : test_copy ();
561 2 : test_new ();
562 2 : test_copyall ();
563 :
564 :
565 2 : printf ("\ntestabi_meta RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
566 :
567 2 : return nbError;
568 : }
|