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 <../../src/libs/elektra/backend.c>
10 : #include <../../src/libs/elektra/mount.c>
11 : #include <../../src/libs/elektra/split.c>
12 : #include <../../src/libs/elektra/trie.c>
13 : #include <tests_internal.h>
14 :
15 4 : KeySet * set_us (void)
16 : {
17 4 : return ksNew (50, keyNew ("system/elektra/mountpoints", KEY_END), keyNew ("system/elektra/mountpoints/user", KEY_END),
18 : keyNew ("system/elektra/mountpoints/user/mountpoint", KEY_VALUE, "user", KEY_END),
19 : keyNew ("system/elektra/mountpoints/system", KEY_END),
20 : keyNew ("system/elektra/mountpoints/system/mountpoint", KEY_VALUE, "system", KEY_END), KS_END);
21 : }
22 :
23 :
24 2 : KeySet * set_three (void)
25 : {
26 2 : return ksNew (50, keyNew ("system/elektra/mountpoints", KEY_END), keyNew ("system/elektra/mountpoints/system", KEY_END),
27 : keyNew ("system/elektra/mountpoints/system/mountpoint", KEY_VALUE, "system", KEY_END),
28 : keyNew ("system/elektra/mountpoints/userin", KEY_END),
29 : keyNew ("system/elektra/mountpoints/userin/mountpoint", KEY_VALUE, "user/invalid", KEY_END),
30 : keyNew ("system/elektra/mountpoints/userva", KEY_END),
31 : keyNew ("system/elektra/mountpoints/userva/mountpoint", KEY_VALUE, "user/valid", KEY_END), KS_END);
32 : }
33 :
34 :
35 2 : KeySet * set_realworld (void)
36 : {
37 2 : return ksNew (50, keyNew ("system/elektra/mountpoints", KEY_END), keyNew ("system/elektra/mountpoints/root", KEY_END),
38 : keyNew ("system/elektra/mountpoints/root/mountpoint", KEY_VALUE, "/", KEY_END),
39 : keyNew ("system/elektra/mountpoints/default", KEY_END),
40 : keyNew ("system/elektra/mountpoints/default/mountpoint", KEY_VALUE, "system/elektra", KEY_END),
41 : keyNew ("system/elektra/mountpoints/users", KEY_END),
42 : keyNew ("system/elektra/mountpoints/users/mountpoint", KEY_VALUE, "system/users", KEY_END),
43 : keyNew ("system/elektra/mountpoints/groups", KEY_END),
44 : keyNew ("system/elektra/mountpoints/groups/mountpoint", KEY_VALUE, "system/groups", KEY_END),
45 : keyNew ("system/elektra/mountpoints/hosts", KEY_END),
46 : keyNew ("system/elektra/mountpoints/hosts/mountpoint", KEY_VALUE, "system/hosts", KEY_END),
47 : keyNew ("system/elektra/mountpoints/kde", KEY_END),
48 : keyNew ("system/elektra/mountpoints/kde/mountpoint", KEY_VALUE, "user/sw/kde/default", KEY_END),
49 : keyNew ("system/elektra/mountpoints/app1", KEY_END),
50 : keyNew ("system/elektra/mountpoints/app1/mountpoint", KEY_VALUE, "user/sw/apps/app1/default", KEY_END),
51 : keyNew ("system/elektra/mountpoints/app2", KEY_END),
52 : keyNew ("system/elektra/mountpoints/app2/mountpoint", KEY_VALUE, "user/sw/apps/app2", KEY_END), KS_END);
53 : }
54 :
55 24 : KDB * kdb_open (void)
56 : {
57 24 : KDB * handle = elektraCalloc (sizeof (struct _KDB));
58 24 : handle->split = splitNew ();
59 24 : handle->modules = ksNew (0, KS_END);
60 24 : elektraModulesInit (handle->modules, 0);
61 24 : return handle;
62 : }
63 :
64 : static void kdb_close (KDB * kdb)
65 : {
66 24 : kdbClose (kdb, 0);
67 : }
68 :
69 0 : void simulateGet (Split * split)
70 : {
71 52 : for (size_t i = 0; i < split->size; ++i)
72 : {
73 52 : split->handles[i]->specsize = 0;
74 52 : split->handles[i]->dirsize = 0;
75 52 : split->handles[i]->usersize = 0;
76 52 : split->handles[i]->systemsize = 0;
77 : }
78 0 : }
79 :
80 :
81 2 : static void test_needsync (void)
82 : {
83 2 : printf ("Test needs sync\n");
84 :
85 2 : KDB * handle = kdb_open ();
86 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not mount default backends");
87 :
88 2 : KeySet * ks = ksNew (5, keyNew ("user/abc", KEY_END), KS_END);
89 2 : Split * split = splitNew ();
90 :
91 2 : Key * parent = keyNew ("user", KEY_VALUE, "parent", KEY_END);
92 :
93 2 : succeed_if (split->size == 0, "size should be zero");
94 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "initial size not correct");
95 :
96 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "buildup failure");
97 2 : succeed_if (splitDivide (split, handle, ks) == 1, "there should be a need sync");
98 :
99 2 : succeed_if (split->handles[0] == handle->defaultBackend, "handle not correct");
100 2 : compare_keyset (split->keysets[0], ks);
101 2 : succeed_if (split->syncbits[0] & 1, "sync bit should be set");
102 :
103 2 : succeed_if (split->size == 1, "size should be one");
104 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "should stay same");
105 :
106 2 : splitDel (split);
107 :
108 :
109 2 : split = splitNew ();
110 :
111 2 : succeed_if (split->size == 0, "size should be zero");
112 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "initial size not correct");
113 :
114 2 : clear_sync (ks);
115 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "buildup failure");
116 2 : succeed_if (splitDivide (split, handle, ks) == 0, "there should not be a need sync");
117 2 : succeed_if (split->handles[0] == handle->defaultBackend, "handle not correct");
118 2 : compare_keyset (split->keysets[0], ks);
119 2 : succeed_if ((split->syncbits[0] & 1) == 0, "sync bit should be set");
120 :
121 2 : succeed_if (split->size == 1, "size should be one");
122 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "should stay same");
123 :
124 2 : splitDel (split);
125 :
126 :
127 2 : split = splitNew ();
128 :
129 2 : ksAppendKey (ks, keyNew ("user/key1", KEY_END));
130 2 : ksAppendKey (ks, keyNew ("user/key2", KEY_END));
131 2 : ksAppendKey (ks, keyNew ("user/key3", KEY_END));
132 2 : ksAppendKey (ks, keyNew ("user/key4", KEY_END));
133 2 : ksAppendKey (ks, keyNew ("user/key5", KEY_END));
134 :
135 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "buildup failure");
136 2 : succeed_if (splitDivide (split, handle, ks) == 1, "there should be a need sync");
137 2 : succeed_if (split->handles[0] == handle->defaultBackend, "handle not correct");
138 2 : compare_keyset (split->keysets[0], ks);
139 2 : succeed_if (split->syncbits[0] & 1, "sync bit should be set");
140 2 : splitDel (split);
141 :
142 :
143 2 : keyDel (parent);
144 2 : ksDel (ks);
145 2 : kdb_close (handle);
146 2 : }
147 :
148 :
149 2 : static void test_mount (void)
150 : {
151 2 : printf ("Test mount split\n");
152 :
153 2 : KDB * handle = kdb_open ();
154 :
155 2 : succeed_if (mountOpen (handle, set_us (), handle->modules, 0) == 0, "could not open mountpoints");
156 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
157 :
158 2 : KeySet * ks = ksNew (5, keyNew ("user/valid/key1", KEY_END), keyNew ("user/valid/key2", KEY_END),
159 : keyNew ("system/valid/key1", KEY_END), keyNew ("system/valid/key2", KEY_END), KS_END);
160 2 : KeySet * split1 = ksNew (3, keyNew ("user/valid/key1", KEY_END), keyNew ("user/valid/key2", KEY_END), KS_END);
161 2 : KeySet * split2 = ksNew (3, keyNew ("system/valid/key1", KEY_END), keyNew ("system/valid/key2", KEY_END), KS_END);
162 :
163 :
164 2 : Split * split = splitNew ();
165 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
166 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
167 2 : succeed_if (split->size == 5, "not split according user, system");
168 2 : succeed_if (split->keysets, "did not alloc keysets array");
169 2 : succeed_if (split->handles, "did not alloc handles array");
170 2 : succeed_if (split->syncbits[0] == 1, "mounted system part need to by synced");
171 2 : succeed_if (split->syncbits[1] == 1, "mounted user part need to by synced");
172 2 : succeed_if (split->syncbits[2] == 2, "spec part need to by synced");
173 2 : succeed_if (split->syncbits[3] == 2, "dir part need to by synced");
174 2 : succeed_if (split->syncbits[4] == 2, "system/elektra part need to by synced");
175 2 : if (split->keysets)
176 : {
177 2 : succeed_if (ksGetSize (split->keysets[0]) == 2, "size of keyset not correct");
178 2 : succeed_if (ksGetSize (split->keysets[1]) == 2, "size of keyset not correct");
179 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "size of keyset not correct");
180 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "size of keyset not correct");
181 2 : compare_keyset (split->keysets[1], split1);
182 2 : compare_keyset (split->keysets[0], split2);
183 : }
184 2 : splitDel (split);
185 :
186 :
187 2 : split = splitNew ();
188 2 : clear_sync (ks);
189 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
190 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
191 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "should stay same");
192 2 : succeed_if (split->keysets, "did not alloc keysets array");
193 2 : succeed_if (split->handles, "did not alloc handles array");
194 2 : succeed_if (split->syncbits[0] == 0, "system part does not need to by synced");
195 2 : succeed_if (split->syncbits[1] == 0, "user part does not need to by synced");
196 2 : succeed_if (split->syncbits[2] == 2, "spec part does not need to by synced");
197 2 : succeed_if (split->syncbits[3] == 2, "dir part does not need to by synced");
198 2 : succeed_if (split->syncbits[4] == 2, "user part does not need to by synced");
199 2 : if (split->keysets)
200 : {
201 2 : succeed_if (ksGetSize (split->keysets[0]) == 2, "size of keyset not correct");
202 2 : succeed_if (ksGetSize (split->keysets[1]) == 2, "size of keyset not correct");
203 : }
204 2 : succeed_if (split->size == 5, "not split according user, system");
205 2 : splitDel (split);
206 :
207 2 : split = splitNew ();
208 2 : keySetString (ksLookupByName (ks, "user/valid/key2", 0), "value");
209 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
210 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
211 2 : succeed_if (split->keysets, "did not alloc keysets array");
212 2 : succeed_if (split->handles, "did not alloc handles array");
213 2 : succeed_if (split->syncbits[0] == 0, "system part does not need to by synced");
214 2 : succeed_if (split->syncbits[1] == 1, "user part need to by synced");
215 2 : succeed_if (split->syncbits[2] == 2, "spec part does not need to by synced");
216 2 : succeed_if (split->syncbits[3] == 2, "dir part does not need to by synced");
217 2 : succeed_if (split->syncbits[4] == 2, "user part does not need to by synced");
218 2 : if (split->keysets)
219 : {
220 2 : succeed_if (ksGetSize (split->keysets[0]) == 2, "size of keyset not correct");
221 2 : succeed_if (ksGetSize (split->keysets[1]) == 2, "size of keyset not correct");
222 : }
223 2 : succeed_if (split->size == 5, "not split according user, system");
224 2 : splitDel (split);
225 :
226 2 : split = splitNew ();
227 2 : keySetString (ksLookupByName (ks, "system/valid/key2", 0), "value");
228 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
229 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
230 2 : succeed_if (split->keysets, "did not alloc keysets array");
231 2 : succeed_if (split->handles, "did not alloc handles array");
232 2 : succeed_if (split->syncbits[0] == 1, "system part need to by synced");
233 2 : succeed_if (split->syncbits[1] == 1, "user part need to by synced");
234 2 : succeed_if (split->syncbits[2] == 2, "spec part does not need to by synced");
235 2 : succeed_if (split->syncbits[3] == 2, "dir part does not need to by synced");
236 2 : succeed_if (split->syncbits[4] == 2, "user part does not need to by synced");
237 2 : if (split->keysets)
238 : {
239 2 : succeed_if (ksGetSize (split->keysets[0]) == 2, "size of keyset not correct");
240 2 : succeed_if (ksGetSize (split->keysets[1]) == 2, "size of keyset not correct");
241 : }
242 2 : succeed_if (split->size == 5, "not split according user, system");
243 2 : splitDel (split);
244 :
245 :
246 2 : ksDel (ks);
247 2 : ksDel (split1);
248 2 : ksDel (split2);
249 2 : kdb_close (handle);
250 2 : }
251 :
252 2 : static void test_easyparent (void)
253 : {
254 2 : printf ("Test parent separation of user and system (default Backend)\n");
255 :
256 2 : KDB * handle = kdb_open ();
257 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
258 2 : KeySet * ks = ksNew (8, keyNew ("user/valid", KEY_END), keyNew ("user/valid/key1", KEY_END), keyNew ("user/valid/key2", KEY_END),
259 : keyNew ("system/valid", KEY_END), keyNew ("system/valid/key1", KEY_END), keyNew ("system/valid/key2", KEY_END),
260 : KS_END);
261 2 : KeySet * split1 = ksNew (5, keyNew ("system/valid", KEY_END), keyNew ("system/valid/key1", KEY_END),
262 : keyNew ("system/valid/key2", KEY_END), KS_END);
263 2 : KeySet * split2 =
264 2 : ksNew (5, keyNew ("user/valid", KEY_END), keyNew ("user/valid/key1", KEY_END), keyNew ("user/valid/key2", KEY_END), KS_END);
265 : Key * parentKey;
266 : Split * split;
267 :
268 :
269 2 : parentKey = keyNew ("user", KEY_END);
270 2 : split = splitNew ();
271 2 : succeed_if (splitBuildup (split, handle, parentKey) == 1, "should need sync");
272 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
273 :
274 2 : succeed_if (split->keysets, "did not alloc keysets array");
275 2 : succeed_if (split->handles, "did not alloc handles array");
276 2 : succeed_if (split->size == 1, "not split by parent");
277 2 : succeed_if (split->syncbits[0] == 3, "user part need not to by synced");
278 2 : succeed_if_same_string (keyName (split->parents[0]), "user");
279 2 : if (split->keysets)
280 : {
281 2 : compare_keyset (split->keysets[0], split2);
282 : }
283 :
284 2 : splitDel (split);
285 2 : keyDel (parentKey);
286 :
287 2 : parentKey = keyNew ("system", KEY_END);
288 2 : split = splitNew ();
289 2 : succeed_if (splitBuildup (split, handle, parentKey) == 1, "should need sync");
290 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
291 :
292 2 : succeed_if (split->keysets, "did not alloc keysets array");
293 2 : succeed_if (split->handles, "did not alloc handles array");
294 2 : succeed_if (split->size == 1, "not split by parent");
295 2 : succeed_if (split->syncbits[0] == 3, "system part need to by synced");
296 2 : succeed_if_same_string (keyName (split->parents[0]), "system");
297 2 : if (split->keysets)
298 : {
299 2 : compare_keyset (split->keysets[0], split1);
300 : }
301 :
302 2 : splitDel (split);
303 2 : keyDel (parentKey);
304 :
305 2 : ksDel (ks);
306 2 : ksDel (split1);
307 2 : ksDel (split2);
308 2 : kdb_close (handle);
309 2 : }
310 :
311 2 : static void test_optimize (void)
312 : {
313 2 : printf ("Test optimization split (user, system in trie)\n");
314 :
315 2 : KDB * handle = kdb_open ();
316 :
317 2 : succeed_if (mountOpen (handle, set_us (), handle->modules, 0) == 0, "could not open mountpoints");
318 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
319 :
320 2 : KeySet * ks = ksNew (5, keyNew ("system/valid/key1", KEY_END), keyNew ("system/valid/key2", KEY_END),
321 : keyNew ("user/valid/key1", KEY_END), keyNew ("user/valid/key2", KEY_END), KS_END);
322 2 : KeySet * split1 = ksNew (3, keyNew ("system/valid/key1", KEY_END), keyNew ("system/valid/key2", KEY_END), KS_END);
323 2 : KeySet * split2 = ksNew (3, keyNew ("user/valid/key1", KEY_END), keyNew ("user/valid/key2", KEY_END), KS_END);
324 2 : Split * split = splitNew ();
325 : Key * key;
326 :
327 :
328 2 : ksRewind (ks);
329 12 : while ((key = ksNext (ks)) != 0)
330 : {
331 8 : if (keyIsUser (key) == 1) keyClearSync (key);
332 : }
333 :
334 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
335 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
336 :
337 2 : succeed_if (split->keysets, "did not alloc keysets array");
338 2 : succeed_if (split->handles, "did not alloc handles array");
339 2 : succeed_if (split->size == 5, "not split according user, system");
340 2 : succeed_if (split->syncbits[0] == 1, "system part not optimized");
341 2 : succeed_if (split->syncbits[1] == 0, "user part need to by synced");
342 2 : succeed_if (split->syncbits[2] == 2, "spec part need to by synced");
343 2 : succeed_if (split->syncbits[3] == 2, "dir part need to by synced");
344 2 : succeed_if (split->syncbits[4] == 2, "system/elektra part need to by synced");
345 2 : compare_keyset (split->keysets[0], split1);
346 2 : compare_keyset (split->keysets[1], split2);
347 2 : if (split->keysets)
348 : {
349 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "size of keyset not correct");
350 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "size of keyset not correct");
351 2 : succeed_if (ksGetSize (split->keysets[4]) == 0, "size of keyset not correct");
352 : }
353 2 : splitDel (split);
354 :
355 :
356 2 : split = splitNew ();
357 2 : clear_sync (ks);
358 :
359 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
360 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
361 :
362 2 : succeed_if (split->keysets, "did not alloc keysets array");
363 2 : succeed_if (split->handles, "did not alloc handles array");
364 2 : succeed_if (split->size == 5, "not split according user, system");
365 2 : succeed_if (split->syncbits[0] == 0, "system part not optimized");
366 2 : succeed_if (split->syncbits[1] == 0, "user part need to by synced");
367 2 : succeed_if (split->syncbits[2] == 2, "spec part need to by synced");
368 2 : succeed_if (split->syncbits[3] == 2, "dir part need to by synced");
369 2 : succeed_if (split->syncbits[4] == 2, "system/elektra part need to by synced");
370 2 : if (split->keysets)
371 : {
372 2 : compare_keyset (split->keysets[0], split1);
373 2 : compare_keyset (split->keysets[1], split2);
374 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "size of keyset not correct");
375 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "size of keyset not correct");
376 2 : succeed_if (ksGetSize (split->keysets[4]) == 0, "size of keyset not correct");
377 : }
378 2 : splitDel (split);
379 :
380 :
381 2 : ksRewind (ks);
382 12 : while ((key = ksNext (ks)) != 0)
383 : {
384 8 : key->flags = KEY_FLAG_SYNC;
385 : }
386 :
387 :
388 2 : split = splitNew ();
389 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
390 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
391 :
392 2 : succeed_if (split->keysets, "did not alloc keysets array");
393 2 : succeed_if (split->handles, "did not alloc handles array");
394 2 : succeed_if (split->size == 5, "not split according user, system");
395 2 : succeed_if (split->syncbits[0] == 1, "system part not optimized");
396 2 : succeed_if (split->syncbits[1] == 1, "user part need to by synced");
397 2 : succeed_if (split->syncbits[2] == 2, "spec part need to by synced");
398 2 : succeed_if (split->syncbits[3] == 2, "dir part need to by synced");
399 2 : succeed_if (split->syncbits[4] == 2, "system/elektra part need to by synced");
400 2 : if (split->keysets)
401 : {
402 2 : compare_keyset (split->keysets[0], split1);
403 2 : compare_keyset (split->keysets[1], split2);
404 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "size of keyset not correct");
405 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "size of keyset not correct");
406 2 : succeed_if (ksGetSize (split->keysets[4]) == 0, "size of keyset not correct");
407 : }
408 2 : splitDel (split);
409 :
410 :
411 2 : ksDel (ks);
412 2 : ksDel (split1);
413 2 : ksDel (split2);
414 :
415 2 : kdb_close (handle);
416 2 : }
417 :
418 2 : static void test_three (void)
419 : {
420 2 : printf ("Test three mountpoints\n");
421 :
422 2 : KDB * handle = kdb_open ();
423 :
424 2 : succeed_if (mountOpen (handle, set_three (), handle->modules, 0) == 0, "could not open mountpoints");
425 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
426 :
427 2 : KeySet * ks = ksNew (18, keyNew ("system/valid", KEY_END), keyNew ("system/valid/key1", KEY_END),
428 : keyNew ("system/valid/key2", KEY_END), keyNew ("system/valid/key3", KEY_END), keyNew ("user/invalid", KEY_END),
429 : keyNew ("user/invalid/key1", KEY_END), keyNew ("user/invalid/key2", KEY_END), keyNew ("user/valid", KEY_END),
430 : keyNew ("user/valid/key1", KEY_END), keyNew ("user/outside", KEY_END), KS_END);
431 2 : KeySet * split0 = ksNew (9, keyNew ("system/valid", KEY_END), keyNew ("system/valid/key1", KEY_END),
432 : keyNew ("system/valid/key2", KEY_END), keyNew ("system/valid/key3", KEY_END), KS_END);
433 2 : KeySet * split1 = ksNew (9, keyNew ("user/invalid", KEY_END), keyNew ("user/invalid/key1", KEY_END),
434 : keyNew ("user/invalid/key2", KEY_END), KS_END);
435 2 : KeySet * split2 = ksNew (9, keyNew ("user/valid", KEY_END), keyNew ("user/valid/key1", KEY_END), KS_END);
436 2 : KeySet * split5 = ksNew (9, keyNew ("user/outside", KEY_END), KS_END);
437 :
438 :
439 2 : Split * split = splitNew ();
440 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
441 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
442 :
443 2 : succeed_if (split->keysets, "did not alloc keysets array");
444 2 : succeed_if (split->handles, "did not alloc handles array");
445 2 : succeed_if (split->size == 7, "not split according three");
446 2 : succeed_if (split->syncbits[0] == 1, "system part need to by synced");
447 2 : succeed_if (split->syncbits[1] == 1, "user invalid part need to by synced");
448 2 : succeed_if (split->syncbits[2] == 1, "user valid part need to by synced");
449 2 : succeed_if (split->syncbits[3] == 2, "spec part need to by synced");
450 2 : succeed_if (split->syncbits[4] == 2, "dirpart need to by synced");
451 2 : succeed_if (split->syncbits[5] == 3, "user default part need to by synced");
452 2 : succeed_if (split->syncbits[6] == 2, "system/elektra default part need to by synced");
453 2 : if (split->keysets)
454 : {
455 2 : succeed_if (ksGetSize (split->keysets[0]) == 4, "size of keyset not correct");
456 2 : succeed_if (ksGetSize (split->keysets[1]) == 3, "size of keyset not correct");
457 2 : succeed_if (ksGetSize (split->keysets[2]) == 2, "size of keyset not correct");
458 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "size of keyset not correct");
459 2 : succeed_if (ksGetSize (split->keysets[4]) == 0, "size of keyset not correct");
460 2 : succeed_if (ksGetSize (split->keysets[5]) == 1, "size of keyset not correct");
461 2 : succeed_if (ksGetSize (split->keysets[6]) == 0, "size of keyset not correct");
462 2 : compare_keyset (split->keysets[0], split0);
463 2 : compare_keyset (split->keysets[1], split1);
464 2 : compare_keyset (split->keysets[2], split2);
465 2 : compare_keyset (split->keysets[5], split5);
466 : }
467 :
468 2 : splitPrepare (split);
469 :
470 : /* Prepare should not change anything here, except discarding
471 : * not needed backends (spec, dir) */
472 2 : succeed_if (split->keysets, "did not alloc keysets array");
473 2 : succeed_if (split->handles, "did not alloc handles array");
474 2 : succeed_if (split->size == 4, "not split according three (with one default)");
475 2 : succeed_if (split->syncbits[0] == 1, "system part need to by synced");
476 2 : succeed_if (split->syncbits[1] == 1, "user part need to by synced");
477 2 : succeed_if (split->syncbits[2] == 1, "user part need to by synced");
478 2 : succeed_if (split->syncbits[3] == 3, "user default part need to by synced");
479 2 : succeed_if (ksGetSize (split->keysets[0]) == 4, "size of keyset not correct");
480 2 : succeed_if (ksGetSize (split->keysets[1]) == 3, "size of keyset not correct");
481 2 : succeed_if (ksGetSize (split->keysets[2]) == 2, "size of keyset not correct");
482 2 : succeed_if (ksGetSize (split->keysets[3]) == 1, "size of keyset not correct");
483 2 : compare_keyset (split->keysets[0], split0);
484 2 : compare_keyset (split->keysets[1], split1);
485 2 : compare_keyset (split->keysets[2], split2);
486 2 : compare_keyset (split->keysets[3], split5); // 3 with 5 because of prepare
487 :
488 2 : splitDel (split);
489 :
490 :
491 2 : ksDel (ks);
492 2 : ksDel (split0);
493 2 : ksDel (split1);
494 2 : ksDel (split2);
495 2 : ksDel (split5);
496 2 : kdb_close (handle);
497 2 : }
498 :
499 2 : static void test_userremove (void)
500 : {
501 2 : printf ("Test user removing\n");
502 2 : Key * parent = 0;
503 2 : KDB * handle = kdb_open ();
504 :
505 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
506 : /* So we had 2 keys before in the keyset */
507 :
508 2 : KeySet * ks = ksNew (3, keyNew ("user/valid/key", KEY_END), KS_END);
509 :
510 :
511 2 : Split * split = splitNew ();
512 :
513 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
514 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
515 2 : succeed_if (splitSync (split) == -2, "should be out of sync");
516 2 : simulateGet (split);
517 2 : handle->defaultBackend->usersize = 2;
518 2 : succeed_if (splitSync (split) == 1, "should need sync");
519 :
520 2 : succeed_if (split->keysets, "did not alloc keysets array");
521 2 : succeed_if (split->handles, "did not alloc handles array");
522 2 : succeed_if (split->size == 4, "split size wrong");
523 2 : if (split->keysets)
524 : {
525 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
526 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
527 2 : succeed_if (ksGetSize (split->keysets[2]) == 1, "wrong size");
528 2 : compare_keyset (split->keysets[2], ks);
529 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
530 : }
531 2 : splitDel (split);
532 :
533 :
534 2 : split = splitNew ();
535 :
536 2 : parent = keyNew ("user/valid", KEY_END);
537 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
538 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
539 2 : succeed_if (splitSync (split) == 1, "should need sync");
540 :
541 2 : succeed_if (split->keysets, "did not alloc keysets array");
542 2 : succeed_if (split->handles, "did not alloc handles array");
543 2 : succeed_if (split->size == 1, "everything is in two keyset");
544 : // output_split(split);
545 2 : if (split->keysets)
546 : {
547 2 : succeed_if (ksGetSize (split->keysets[0]) == 1, "wrong size");
548 2 : compare_keyset (split->keysets[0], ks);
549 : }
550 2 : keyDel (parent);
551 :
552 2 : splitDel (split);
553 :
554 :
555 2 : split = splitNew ();
556 :
557 2 : parent = keyNew ("system/valid", KEY_END);
558 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
559 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should need sync");
560 2 : succeed_if (splitSync (split) == 0, "should need sync");
561 :
562 2 : succeed_if (split->keysets, "did not alloc keysets array");
563 2 : succeed_if (split->handles, "did not alloc handles array");
564 2 : succeed_if (split->size == 1, "everything is in two keyset");
565 : // output_split(split);
566 2 : if (split->keysets)
567 : {
568 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "should be dropped");
569 : }
570 2 : keyDel (parent);
571 :
572 2 : splitDel (split);
573 :
574 :
575 : /* But it should even need sync when we don't have any unsynced keys! */
576 2 : clear_sync (ks);
577 2 : split = splitNew ();
578 :
579 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
580 2 : succeed_if (splitDivide (split, handle, ks) == 0, "no key inside needs sync");
581 2 : succeed_if (splitSync (split) == 1, "but we need sync because of the size mismatch");
582 :
583 2 : succeed_if (split->keysets, "did not alloc keysets array");
584 2 : succeed_if (split->handles, "did not alloc handles array");
585 2 : succeed_if (split->size == 4, "wrong size of split");
586 2 : if (split->keysets)
587 : {
588 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
589 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
590 2 : succeed_if (ksGetSize (split->keysets[2]) == 1, "wrong size");
591 2 : compare_keyset (split->keysets[2], ks);
592 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
593 : }
594 :
595 2 : splitDel (split);
596 :
597 :
598 2 : split = splitNew ();
599 :
600 2 : parent = keyNew ("user/valid", KEY_END);
601 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
602 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should need sync");
603 2 : succeed_if (splitSync (split) == 1, "should need sync");
604 :
605 2 : succeed_if (split->keysets, "did not alloc keysets array");
606 2 : succeed_if (split->handles, "did not alloc handles array");
607 2 : succeed_if (split->size == 1, "everything is in two keyset");
608 : // output_split(split);
609 2 : if (split->keysets)
610 : {
611 2 : succeed_if (ksGetSize (split->keysets[0]) == 1, "wrong size");
612 2 : compare_keyset (split->keysets[0], ks);
613 : }
614 2 : keyDel (parent);
615 :
616 2 : splitDel (split);
617 :
618 :
619 2 : split = splitNew ();
620 :
621 2 : parent = keyNew ("system/valid", KEY_END);
622 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
623 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
624 2 : succeed_if (splitSync (split) == 0, "should not need sync");
625 :
626 2 : succeed_if (split->keysets, "did not alloc keysets array");
627 2 : succeed_if (split->handles, "did not alloc handles array");
628 2 : succeed_if (split->size == 1, "everything is in two keyset");
629 : // output_split(split);
630 2 : if (split->keysets)
631 : {
632 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "should be dropped");
633 : }
634 2 : keyDel (parent);
635 :
636 2 : splitPrepare (split);
637 2 : succeed_if (split->size == 0, "split not empty");
638 :
639 2 : splitDel (split);
640 :
641 :
642 2 : ksDel (ks);
643 2 : kdb_close (handle);
644 2 : }
645 :
646 :
647 2 : static void test_systemremove (void)
648 : {
649 2 : printf ("Test system removing\n");
650 2 : Key * parent = 0;
651 2 : KDB * handle = kdb_open ();
652 :
653 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
654 :
655 2 : KeySet * ks = ksNew (3, keyNew ("system/valid/key", KEY_END), KS_END);
656 :
657 :
658 2 : Split * split = splitNew ();
659 :
660 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
661 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
662 2 : simulateGet (split);
663 2 : handle->defaultBackend->systemsize = 2;
664 : /* So we had 2 keys before in the keyset */
665 2 : succeed_if (splitSync (split) == 1, "should need sync");
666 :
667 2 : succeed_if (split->keysets, "did not alloc keysets array");
668 2 : succeed_if (split->handles, "did not alloc handles array");
669 2 : succeed_if (split->size == 4, "everything is in two keyset");
670 2 : if (split->keysets)
671 : {
672 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
673 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
674 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
675 2 : succeed_if (ksGetSize (split->keysets[3]) == 1, "wrong size");
676 2 : compare_keyset (split->keysets[3], ks);
677 : }
678 :
679 2 : splitDel (split);
680 :
681 :
682 2 : split = splitNew ();
683 :
684 2 : parent = keyNew ("system/valid", KEY_END);
685 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
686 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
687 2 : succeed_if (splitSync (split) == 1, "should need sync");
688 :
689 2 : succeed_if (split->keysets, "did not alloc keysets array");
690 2 : succeed_if (split->handles, "did not alloc handles array");
691 2 : succeed_if (split->size == 1, "everything is in one keyset");
692 : // output_split(split);
693 2 : if (split->keysets)
694 : {
695 2 : succeed_if (ksGetSize (split->keysets[0]) == 1, "wrong size");
696 2 : compare_keyset (split->keysets[0], ks);
697 : }
698 2 : keyDel (parent);
699 :
700 2 : splitDel (split);
701 :
702 :
703 2 : split = splitNew ();
704 :
705 2 : parent = keyNew ("user/valid", KEY_END);
706 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
707 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
708 2 : simulateGet (split);
709 2 : succeed_if (splitSync (split) == 0, "should not need sync");
710 :
711 2 : succeed_if (split->keysets, "did not alloc keysets array");
712 2 : succeed_if (split->handles, "did not alloc handles array");
713 2 : succeed_if (split->size == 1, "everything is in one keyset");
714 : // output_split(split);
715 2 : if (split->keysets)
716 : {
717 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "should be dropped");
718 : }
719 2 : keyDel (parent);
720 :
721 2 : splitDel (split);
722 :
723 :
724 : /* But it should even need sync when we don't have any unsynced keys! */
725 2 : clear_sync (ks);
726 2 : split = splitNew ();
727 :
728 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "should need sync");
729 2 : succeed_if (splitDivide (split, handle, ks) == 0, "no key inside needs sync");
730 2 : succeed_if (splitSync (split) == 1, "but we need sync because of the size mismatch");
731 :
732 2 : succeed_if (split->keysets, "did not alloc keysets array");
733 2 : succeed_if (split->handles, "did not alloc handles array");
734 2 : succeed_if (split->size == 4, "everything is in two keyset");
735 2 : if (split->keysets)
736 : {
737 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
738 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
739 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
740 2 : succeed_if (ksGetSize (split->keysets[3]) == 1, "wrong size");
741 2 : compare_keyset (split->keysets[3], ks);
742 : }
743 :
744 2 : splitDel (split);
745 :
746 :
747 2 : split = splitNew ();
748 :
749 2 : parent = keyNew ("system/valid", KEY_END);
750 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
751 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
752 2 : succeed_if (splitSync (split) == 1, "should need sync");
753 :
754 2 : succeed_if (split->keysets, "did not alloc keysets array");
755 2 : succeed_if (split->handles, "did not alloc handles array");
756 2 : succeed_if (split->size == 1, "everything is in two keyset");
757 : // output_split(split);
758 2 : if (split->keysets)
759 : {
760 2 : succeed_if (ksGetSize (split->keysets[0]) == 1, "wrong size");
761 2 : compare_keyset (split->keysets[0], ks);
762 : }
763 2 : keyDel (parent);
764 :
765 2 : splitDel (split);
766 :
767 :
768 2 : split = splitNew ();
769 :
770 2 : parent = keyNew ("user/valid", KEY_END);
771 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
772 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
773 2 : succeed_if (splitSync (split) == 0, "should not need sync");
774 :
775 2 : succeed_if (split->keysets, "did not alloc keysets array");
776 2 : succeed_if (split->handles, "did not alloc handles array");
777 2 : succeed_if (split->size == 1, "everything is in two keyset");
778 : // output_split(split);
779 2 : if (split->keysets)
780 : {
781 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "should be dropped");
782 : }
783 2 : keyDel (parent);
784 :
785 2 : splitPrepare (split);
786 2 : succeed_if (split->size == 0, "no remaining keyset");
787 :
788 2 : splitDel (split);
789 :
790 :
791 2 : ksDel (ks);
792 2 : kdb_close (handle);
793 2 : }
794 :
795 :
796 2 : static void test_emptyremove (void)
797 : {
798 2 : printf ("Test empty removing\n");
799 :
800 2 : KDB * handle = kdb_open ();
801 :
802 2 : Key * parent = 0;
803 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
804 :
805 2 : KeySet * ks = ksNew (3, KS_END);
806 :
807 :
808 2 : Split * split = splitNew ();
809 :
810 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
811 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
812 2 : simulateGet (split);
813 2 : succeed_if (splitSync (split) == 0, "should not need sync");
814 :
815 2 : succeed_if (split->keysets, "did not alloc keysets array");
816 2 : succeed_if (split->handles, "did not alloc handles array");
817 2 : succeed_if (split->size == 4, "there is an empty keset");
818 2 : if (split->keysets)
819 : {
820 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
821 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
822 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
823 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
824 : }
825 :
826 2 : splitDel (split);
827 :
828 :
829 2 : handle->defaultBackend->usersize = 2;
830 2 : handle->defaultBackend->systemsize = 0;
831 2 : split = splitNew ();
832 :
833 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
834 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
835 2 : succeed_if (splitSync (split) == 1, "should not need sync");
836 :
837 2 : succeed_if (split->keysets, "did not alloc keysets array");
838 2 : succeed_if (split->handles, "did not alloc handles array");
839 2 : succeed_if (split->size == 4, "there is an empty keset");
840 2 : if (split->keysets)
841 : {
842 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
843 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
844 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
845 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
846 : }
847 :
848 2 : splitDel (split);
849 :
850 :
851 2 : handle->defaultBackend->usersize = 2;
852 2 : handle->defaultBackend->systemsize = 0;
853 2 : split = splitNew ();
854 :
855 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
856 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
857 2 : succeed_if (splitSync (split) == 1, "should not need sync");
858 :
859 2 : succeed_if (split->keysets, "did not alloc keysets array");
860 2 : succeed_if (split->handles, "did not alloc handles array");
861 2 : succeed_if (split->size == 4, "there is an empty keset");
862 2 : if (split->keysets)
863 : {
864 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
865 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
866 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
867 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
868 : }
869 2 : splitPrepare (split);
870 2 : succeed_if (split->size == 1, "there is an empty keset");
871 2 : succeed_if_same_string (keyName (split->parents[0]), "user");
872 2 : succeed_if_same_string (keyValue (split->parents[0]), "default");
873 :
874 2 : splitDel (split);
875 :
876 :
877 2 : ksDel (ks);
878 2 : kdb_close (handle);
879 2 : keyDel (parent);
880 2 : }
881 :
882 2 : static void test_realworld (void)
883 : {
884 2 : printf ("Test real world example\n");
885 :
886 2 : Key * parent = 0;
887 2 : KDB * handle = kdb_open ();
888 :
889 2 : succeed_if (mountOpen (handle, set_realworld (), handle->modules, 0) == 0, "could not open mountpoints");
890 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
891 :
892 2 : KeySet * split0 = ksNew (9, keyNew ("system/elektra/mountpoints", KEY_END), keyNew ("system/elektra/mountpoints/new", KEY_END),
893 : keyNew ("system/elektra/mountpoints/new/mountpoint", KEY_VALUE, "something", KEY_END), KS_END);
894 2 : KeySet * split2 = ksNew (9, keyNew ("system/hosts", KEY_END), keyNew ("system/hosts/markusbyte", KEY_VALUE, "127.0.0.1", KEY_END),
895 : keyNew ("system/hosts/mobilebyte", KEY_END), keyNew ("system/hosts/n900", KEY_END), KS_END);
896 2 : KeySet * split3 = ksNew (9, keyNew ("system/users", KEY_END), keyNew ("system/users/markus", KEY_END),
897 : keyNew ("system/users/harald", KEY_END), keyNew ("system/users/n", KEY_END),
898 : keyNew ("system/users/albert", KEY_END), KS_END);
899 2 : KeySet * split4 = ksNew (9, keyNew ("user/sw/apps/app1/default", KEY_END),
900 : keyNew ("user/sw/apps/app1/default/maximize", KEY_VALUE, "1", KEY_END),
901 : keyNew ("user/sw/apps/app1/default/download", KEY_VALUE, "0", KEY_END),
902 : keyNew ("user/sw/apps/app1/default/keys/a", KEY_VALUE, "a", KEY_END),
903 : keyNew ("user/sw/apps/app1/default/keys/b", KEY_VALUE, "b", KEY_END),
904 : keyNew ("user/sw/apps/app1/default/keys/c", KEY_VALUE, "c", KEY_END), KS_END);
905 2 : KeySet * split7 = ksNew (3, keyNew ("user/outside", KEY_VALUE, "test", KEY_END), KS_END);
906 2 : KeySet * splitX = ksNew (3, keyNew ("spec/testS", KEY_VALUE, "testS", KEY_END), KS_END);
907 2 : KeySet * splitY = ksNew (3, keyNew ("dir/testD", KEY_VALUE, "testD", KEY_END), KS_END);
908 2 : KeySet * tmp = ksNew (30, KS_END);
909 2 : ksAppend (tmp, split0);
910 2 : ksAppend (tmp, split2);
911 2 : ksAppend (tmp, split3);
912 2 : ksAppend (tmp, split4);
913 2 : ksAppend (tmp, split7);
914 2 : ksAppend (tmp, splitX);
915 2 : ksAppend (tmp, splitY);
916 2 : KeySet * ks = ksDeepDup (tmp);
917 2 : ksDel (tmp);
918 :
919 :
920 2 : Split * split = splitNew ();
921 :
922 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
923 2 : succeed_if (split->size == 12, "size of split not correct");
924 2 : succeed_if (split->syncbits[0] == 0, "size of split not correct");
925 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
926 2 : succeed_if (split->syncbits[1] == 0, "size of split not correct");
927 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
928 2 : succeed_if (split->syncbits[2] == 0, "size of split not correct");
929 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
930 2 : succeed_if (split->syncbits[3] == 0, "size of split not correct");
931 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
932 2 : succeed_if (split->syncbits[4] == 0, "size of split not correct");
933 2 : succeed_if (ksGetSize (split->keysets[4]) == 0, "wrong size");
934 2 : succeed_if (split->syncbits[5] == 0, "size of split not correct");
935 2 : succeed_if (ksGetSize (split->keysets[5]) == 0, "wrong size");
936 2 : succeed_if (split->syncbits[6] == 2, "size of split not correct");
937 2 : succeed_if (ksGetSize (split->keysets[6]) == 0, "wrong size");
938 2 : succeed_if (split->syncbits[7] == 2, "size of split not correct");
939 2 : succeed_if (ksGetSize (split->keysets[7]) == 0, "wrong size");
940 2 : succeed_if (split->syncbits[8] == 2, "size of split not correct");
941 2 : succeed_if (ksGetSize (split->keysets[8]) == 0, "wrong size");
942 2 : succeed_if (split->syncbits[9] == 2, "size of split not correct");
943 2 : succeed_if (ksGetSize (split->keysets[9]) == 0, "wrong size");
944 2 : succeed_if (split->syncbits[10] == 0, "size of split not correct");
945 2 : succeed_if (ksGetSize (split->keysets[10]) == 0, "wrong size");
946 2 : succeed_if (split->syncbits[11] == 2, "size of split not correct");
947 2 : succeed_if (ksGetSize (split->keysets[11]) == 0, "wrong size");
948 :
949 2 : succeed_if (splitDivide (split, handle, ks) == 1, "should need sync");
950 2 : succeed_if (split->size == 12, "size of split not correct");
951 2 : succeed_if (split->syncbits[0] == 1, "size of split not correct");
952 2 : succeed_if (ksGetSize (split->keysets[0]) == 6, "wrong size");
953 2 : succeed_if (split->syncbits[1] == 0, "size of split not correct");
954 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
955 2 : succeed_if (split->syncbits[2] == 0, "size of split not correct");
956 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
957 2 : succeed_if (split->syncbits[3] == 0, "size of split not correct");
958 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
959 2 : succeed_if (split->syncbits[4] == 1, "size of split not correct");
960 2 : succeed_if (ksGetSize (split->keysets[4]) == 4, "wrong size");
961 2 : succeed_if (split->syncbits[5] == 0, "size of split not correct");
962 2 : succeed_if (ksGetSize (split->keysets[5]) == 0, "wrong size");
963 2 : succeed_if (split->syncbits[6] == 3, "size of split not correct");
964 2 : succeed_if (ksGetSize (split->keysets[6]) == 1, "wrong size");
965 2 : succeed_if (split->syncbits[7] == 3, "size of split not correct");
966 2 : succeed_if (ksGetSize (split->keysets[7]) == 1, "wrong size");
967 2 : succeed_if (split->syncbits[8] == 3, "size of split not correct");
968 2 : succeed_if (ksGetSize (split->keysets[8]) == 1, "wrong size");
969 2 : succeed_if (split->syncbits[9] == 2, "size of split not correct");
970 2 : succeed_if (ksGetSize (split->keysets[9]) == 0, "wrong size");
971 2 : succeed_if (split->syncbits[10] == 1, "size of split not correct");
972 2 : succeed_if (ksGetSize (split->keysets[10]) == 5, "wrong size");
973 2 : succeed_if (split->syncbits[11] == 3, "size of split not correct");
974 2 : succeed_if (ksGetSize (split->keysets[11]) == 3, "wrong size");
975 :
976 2 : simulateGet (split);
977 2 : split->handles[5]->usersize = 5;
978 2 : split->handles[8]->systemsize = 12;
979 2 : succeed_if (splitSync (split) == 1, "should need sync");
980 2 : succeed_if (split->size == 12, "size of split not correct");
981 2 : succeed_if (split->syncbits[0] == 1, "size of split not correct");
982 2 : succeed_if (ksGetSize (split->keysets[0]) == 6, "wrong size");
983 2 : succeed_if (split->syncbits[1] == 0, "size of split not correct");
984 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
985 2 : succeed_if (split->syncbits[2] == 0, "size of split not correct");
986 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
987 2 : succeed_if (split->syncbits[3] == 0, "size of split not correct");
988 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
989 2 : succeed_if (split->syncbits[4] == 1, "size of split not correct");
990 2 : succeed_if (ksGetSize (split->keysets[4]) == 4, "wrong size");
991 2 : succeed_if (split->syncbits[5] == 1, "size of split not correct");
992 2 : succeed_if (ksGetSize (split->keysets[5]) == 0, "wrong size");
993 2 : succeed_if (split->syncbits[6] == 3, "size of split not correct");
994 2 : succeed_if (ksGetSize (split->keysets[6]) == 1, "wrong size");
995 2 : succeed_if (split->syncbits[7] == 3, "size of split not correct");
996 2 : succeed_if (ksGetSize (split->keysets[7]) == 1, "wrong size");
997 2 : succeed_if (split->syncbits[8] == 3, "size of split not correct");
998 2 : succeed_if (ksGetSize (split->keysets[8]) == 1, "wrong size");
999 2 : succeed_if (split->syncbits[9] == 3, "size of split not correct");
1000 2 : succeed_if (ksGetSize (split->keysets[9]) == 0, "wrong size");
1001 2 : succeed_if (split->syncbits[10] == 1, "size of split not correct");
1002 2 : succeed_if (ksGetSize (split->keysets[10]) == 5, "wrong size");
1003 2 : succeed_if (split->syncbits[11] == 3, "size of split not correct");
1004 2 : succeed_if (ksGetSize (split->keysets[11]) == 3, "wrong size");
1005 :
1006 :
1007 2 : split->handles[5]->usersize = 0;
1008 2 : split->handles[8]->systemsize = 0;
1009 2 : splitDel (split);
1010 :
1011 :
1012 2 : clear_sync (ks);
1013 2 : split = splitNew ();
1014 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
1015 2 : succeed_if (split->size == 12, "size of split not correct");
1016 2 : succeed_if (split->syncbits[0] == 0, "size of split not correct");
1017 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
1018 2 : succeed_if (split->syncbits[1] == 0, "size of split not correct");
1019 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
1020 2 : succeed_if (split->syncbits[2] == 0, "size of split not correct");
1021 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
1022 2 : succeed_if (split->syncbits[3] == 0, "size of split not correct");
1023 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
1024 2 : succeed_if (split->syncbits[4] == 0, "size of split not correct");
1025 2 : succeed_if (ksGetSize (split->keysets[4]) == 0, "wrong size");
1026 2 : succeed_if (split->syncbits[5] == 0, "size of split not correct");
1027 2 : succeed_if (ksGetSize (split->keysets[5]) == 0, "wrong size");
1028 2 : succeed_if (split->syncbits[6] == 2, "size of split not correct");
1029 2 : succeed_if (ksGetSize (split->keysets[6]) == 0, "wrong size");
1030 2 : succeed_if (split->syncbits[7] == 2, "size of split not correct");
1031 2 : succeed_if (ksGetSize (split->keysets[7]) == 0, "wrong size");
1032 2 : succeed_if (split->syncbits[8] == 2, "size of split not correct");
1033 2 : succeed_if (ksGetSize (split->keysets[8]) == 0, "wrong size");
1034 2 : succeed_if (split->syncbits[9] == 2, "size of split not correct");
1035 2 : succeed_if (ksGetSize (split->keysets[9]) == 0, "wrong size");
1036 2 : succeed_if (split->syncbits[10] == 0, "size of split not correct");
1037 2 : succeed_if (ksGetSize (split->keysets[10]) == 0, "wrong size");
1038 2 : succeed_if (split->syncbits[11] == 2, "size of split not correct");
1039 2 : succeed_if (ksGetSize (split->keysets[11]) == 0, "wrong size");
1040 :
1041 2 : succeed_if (splitDivide (split, handle, ks) == 0, "does not need sync anymore");
1042 2 : succeed_if (split->size == 12, "size of split not correct");
1043 2 : succeed_if (split->syncbits[0] == 0, "size of split not correct");
1044 2 : succeed_if (ksGetSize (split->keysets[0]) == 6, "wrong size");
1045 2 : succeed_if (split->syncbits[1] == 0, "size of split not correct");
1046 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
1047 2 : succeed_if (split->syncbits[2] == 0, "size of split not correct");
1048 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
1049 2 : succeed_if (split->syncbits[3] == 0, "size of split not correct");
1050 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
1051 2 : succeed_if (split->syncbits[4] == 0, "size of split not correct");
1052 2 : succeed_if (ksGetSize (split->keysets[4]) == 4, "wrong size");
1053 2 : succeed_if (split->syncbits[5] == 0, "size of split not correct");
1054 2 : succeed_if (ksGetSize (split->keysets[5]) == 0, "wrong size");
1055 2 : succeed_if (split->syncbits[6] == 2, "size of split not correct");
1056 2 : succeed_if (ksGetSize (split->keysets[6]) == 1, "wrong size");
1057 2 : succeed_if (split->syncbits[7] == 2, "size of split not correct");
1058 2 : succeed_if (ksGetSize (split->keysets[7]) == 1, "wrong size");
1059 2 : succeed_if (split->syncbits[8] == 2, "size of split not correct");
1060 2 : succeed_if (ksGetSize (split->keysets[8]) == 1, "wrong size");
1061 2 : succeed_if (split->syncbits[9] == 2, "size of split not correct");
1062 2 : succeed_if (ksGetSize (split->keysets[9]) == 0, "wrong size");
1063 2 : succeed_if (split->syncbits[10] == 0, "size of split not correct");
1064 2 : succeed_if (ksGetSize (split->keysets[10]) == 5, "wrong size");
1065 2 : succeed_if (split->syncbits[11] == 2, "size of split not correct");
1066 2 : succeed_if (ksGetSize (split->keysets[11]) == 3, "wrong size");
1067 :
1068 2 : succeed_if (splitSync (split) == 1, "should need sync, because of removes");
1069 2 : succeed_if (split->size == 12, "size of split not correct");
1070 2 : succeed_if (split->syncbits[0] == 1, "size of split not correct");
1071 2 : succeed_if (ksGetSize (split->keysets[0]) == 6, "wrong size");
1072 2 : succeed_if (split->syncbits[1] == 0, "size of split not correct");
1073 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
1074 2 : succeed_if (split->syncbits[2] == 0, "size of split not correct");
1075 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
1076 2 : succeed_if (split->syncbits[3] == 0, "size of split not correct");
1077 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
1078 2 : succeed_if (split->syncbits[4] == 1, "size of split not correct");
1079 2 : succeed_if (ksGetSize (split->keysets[4]) == 4, "wrong size");
1080 2 : succeed_if (split->syncbits[5] == 0, "size of split not correct");
1081 2 : succeed_if (ksGetSize (split->keysets[5]) == 0, "wrong size");
1082 2 : succeed_if (split->syncbits[6] == 3, "size of split not correct");
1083 2 : succeed_if (ksGetSize (split->keysets[6]) == 1, "wrong size");
1084 2 : succeed_if (split->syncbits[7] == 3, "size of split not correct");
1085 2 : succeed_if (ksGetSize (split->keysets[7]) == 1, "wrong size");
1086 2 : succeed_if (split->syncbits[8] == 3, "size of split not correct");
1087 2 : succeed_if (ksGetSize (split->keysets[8]) == 1, "wrong size");
1088 2 : succeed_if (split->syncbits[9] == 2, "size of split not correct");
1089 2 : succeed_if (ksGetSize (split->keysets[9]) == 0, "wrong size");
1090 2 : succeed_if (split->syncbits[10] == 1, "size of split not correct");
1091 2 : succeed_if (ksGetSize (split->keysets[10]) == 5, "wrong size");
1092 2 : succeed_if (split->syncbits[11] == 3, "size of split not correct");
1093 2 : succeed_if (ksGetSize (split->keysets[11]) == 3, "wrong size");
1094 :
1095 2 : splitDel (split);
1096 :
1097 :
1098 2 : split = splitNew ();
1099 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
1100 2 : succeed_if (split->size == 12, "size not correct");
1101 2 : succeed_if (splitDivide (split, handle, ks) == 0, "does not need sync anymore");
1102 2 : split->handles[0]->usersize = 6;
1103 2 : split->handles[4]->systemsize = 4;
1104 2 : split->handles[6]->specsize = 1;
1105 2 : split->handles[7]->dirsize = 1;
1106 2 : split->handles[9]->usersize = 1;
1107 2 : split->handles[10]->systemsize = 5;
1108 2 : split->handles[11]->systemsize = 3;
1109 2 : succeed_if (splitSync (split) == 0, "no sync needed");
1110 2 : splitDel (split);
1111 :
1112 :
1113 2 : split = splitNew ();
1114 2 : succeed_if (splitBuildup (split, handle, parent) == 1, "should need sync");
1115 2 : succeed_if (split->size == 12, "size not correct");
1116 2 : succeed_if (splitDivide (split, handle, ks) == 0, "does not need sync anymore");
1117 2 : split->handles[0]->usersize = 6;
1118 2 : split->handles[4]->systemsize = 2; /* Changed */
1119 2 : split->handles[6]->specsize = 1;
1120 2 : split->handles[7]->dirsize = 1;
1121 2 : split->handles[9]->usersize = 1;
1122 2 : split->handles[10]->systemsize = 5;
1123 2 : split->handles[11]->systemsize = 3;
1124 2 : succeed_if (splitSync (split) == 1, "sync needed because one size not correct");
1125 :
1126 2 : splitPrepare (split);
1127 2 : succeed_if (split->size == 1, "should be 1, only system/hosts to sync");
1128 2 : succeed_if_same_string (keyName (split->parents[0]), "system/hosts");
1129 2 : succeed_if_same_string (keyValue (split->parents[0]), "hosts");
1130 :
1131 2 : splitDel (split);
1132 :
1133 :
1134 2 : ksDel (ks);
1135 2 : ksDel (split0);
1136 2 : ksDel (split2);
1137 2 : ksDel (split3);
1138 2 : ksDel (split4);
1139 2 : ksDel (split7);
1140 2 : ksDel (splitX);
1141 2 : ksDel (splitY);
1142 2 : keyDel (parent);
1143 2 : kdb_close (handle);
1144 2 : }
1145 :
1146 :
1147 2 : static void test_emptysplit (void)
1148 : {
1149 2 : printf ("Test empty split\n");
1150 :
1151 2 : KDB * handle = kdb_open ();
1152 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
1153 :
1154 2 : KeySet * ks = ksNew (0, KS_END);
1155 2 : Split * split = splitNew ();
1156 : Key * parentKey;
1157 :
1158 2 : succeed_if (split->size == 0, "size should be zero");
1159 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "initial size not correct");
1160 :
1161 2 : succeed_if (splitBuildup (split, handle, 0) == 1, "default backend should be added");
1162 2 : succeed_if (split->size == 4, "size of split not correct");
1163 2 : succeed_if (split->syncbits[0] == 2, "size of split not correct");
1164 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
1165 2 : succeed_if (split->syncbits[1] == 2, "size of split not correct");
1166 2 : succeed_if (ksGetSize (split->keysets[1]) == 0, "wrong size");
1167 2 : succeed_if (split->syncbits[2] == 2, "size of split not correct");
1168 2 : succeed_if (ksGetSize (split->keysets[2]) == 0, "wrong size");
1169 2 : succeed_if (split->syncbits[3] == 2, "size of split not correct");
1170 2 : succeed_if (ksGetSize (split->keysets[3]) == 0, "wrong size");
1171 :
1172 2 : parentKey = keyNew ("spec", KEY_VALUE, "default", KEY_END);
1173 2 : compare_key (split->parents[0], parentKey);
1174 2 : keyDel (parentKey);
1175 :
1176 2 : parentKey = keyNew ("dir", KEY_VALUE, "default", KEY_END);
1177 2 : compare_key (split->parents[1], parentKey);
1178 2 : keyDel (parentKey);
1179 :
1180 2 : parentKey = keyNew ("user", KEY_VALUE, "default", KEY_END);
1181 2 : compare_key (split->parents[2], parentKey);
1182 2 : keyDel (parentKey);
1183 :
1184 2 : parentKey = keyNew ("system", KEY_VALUE, "default", KEY_END);
1185 2 : compare_key (split->parents[3], parentKey);
1186 2 : keyDel (parentKey);
1187 :
1188 2 : succeed_if (split->handles[0] == handle->defaultBackend, "not correct backend");
1189 2 : succeed_if (split->handles[1] == handle->defaultBackend, "not correct backend");
1190 2 : succeed_if (split->handles[2] == handle->defaultBackend, "not correct backend");
1191 2 : succeed_if (split->handles[3] == handle->defaultBackend, "not correct backend");
1192 :
1193 2 : succeed_if (split->syncbits[0] == 2, "should be marked as default");
1194 2 : succeed_if (split->syncbits[1] == 2, "should be marked as default");
1195 2 : succeed_if (split->syncbits[2] == 2, "should be marked as default");
1196 2 : succeed_if (split->syncbits[3] == 2, "should be marked as default");
1197 :
1198 2 : succeed_if (splitDivide (split, handle, ks) == 0, "there should be no added key");
1199 :
1200 2 : succeed_if (split->size == 4, "divide should never changes size");
1201 2 : succeed_if (split->alloc == APPROXIMATE_NR_OF_BACKENDS, "initial size not correct");
1202 :
1203 2 : splitDel (split);
1204 2 : ksDel (ks);
1205 2 : kdb_close (handle);
1206 2 : }
1207 :
1208 2 : static void test_nothingsync (void)
1209 : {
1210 2 : printf ("Test buildup with nothing to sync\n");
1211 2 : KDB * handle = kdb_open ();
1212 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
1213 :
1214 2 : KeySet * ks = ksNew (0, KS_END);
1215 :
1216 2 : Split * split = splitNew ();
1217 2 : Key * parentKey = keyNew ("user", KEY_VALUE, "default", KEY_END);
1218 :
1219 2 : succeed_if (splitBuildup (split, handle, parentKey) == 1, "we add the default backend for user");
1220 :
1221 2 : succeed_if (split->size == 1, "there is an empty keset");
1222 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong size");
1223 2 : compare_key (split->parents[0], parentKey);
1224 2 : succeed_if (split->handles[0] == handle->defaultBackend, "not correct backend");
1225 2 : succeed_if (split->syncbits[0] == 2, "should be marked as root");
1226 :
1227 2 : succeed_if (splitDivide (split, handle, ks) == 0, "does not need sync anymore");
1228 2 : simulateGet (split);
1229 2 : succeed_if (splitSync (split) == 0, "nothing to sync");
1230 2 : splitPrepare (split);
1231 2 : succeed_if (split->size == 0, "there should be nothing to sync");
1232 :
1233 2 : splitDel (split);
1234 2 : keyDel (parentKey);
1235 :
1236 2 : ksDel (ks);
1237 2 : kdb_close (handle);
1238 2 : }
1239 :
1240 2 : static void test_state (void)
1241 : {
1242 2 : printf ("Test state conflicts\n");
1243 2 : KDB * handle = kdb_open ();
1244 2 : succeed_if (mountDefault (handle, handle->modules, 1, 0) == 0, "could not open default backend");
1245 :
1246 : Key * k;
1247 2 : KeySet * ks = ksNew (2, k = keyNew ("user/abc", KEY_END), KS_END);
1248 :
1249 2 : Split * split = splitNew ();
1250 2 : Key * parentKey = keyNew ("user", KEY_VALUE, "default", KEY_END);
1251 :
1252 2 : succeed_if (splitBuildup (split, handle, parentKey) == 1, "we add the default backend for user");
1253 :
1254 2 : succeed_if (split->size == 1, "there is an empty keset");
1255 2 : succeed_if (ksGetSize (split->keysets[0]) == 0, "wrong init size");
1256 2 : compare_key (split->parents[0], parentKey);
1257 2 : succeed_if (split->handles[0] == handle->defaultBackend, "not correct backend");
1258 2 : succeed_if (split->syncbits[0] == 2, "should be marked as root");
1259 :
1260 2 : succeed_if (splitDivide (split, handle, ks) == 1, "does not need sync anymore");
1261 2 : clear_bit (k->flags, KEY_FLAG_SYNC);
1262 2 : succeed_if (splitDivide (split, handle, ks) == 0, "should not need sync");
1263 :
1264 2 : succeed_if (ksGetSize (split->keysets[0]) == 1, "wrong size");
1265 2 : succeed_if (splitSync (split) == -2, "state error: should fail");
1266 :
1267 2 : split->handles[0]->usersize = 1;
1268 2 : succeed_if (ksGetSize (split->keysets[0]) == 1, "wrong size");
1269 : // output_split (split);
1270 2 : succeed_if (splitSync (split) == 0, "state nothing to do: same size");
1271 :
1272 2 : split->handles[0]->usersize = 3;
1273 2 : succeed_if (splitSync (split) == 1, "state should sync: other size");
1274 2 : splitPrepare (split);
1275 2 : succeed_if (split->size == 1, "there should be nothing to sync");
1276 :
1277 2 : splitDel (split);
1278 2 : keyDel (parentKey);
1279 :
1280 2 : ksDel (ks);
1281 2 : kdb_close (handle);
1282 2 : }
1283 :
1284 :
1285 2 : int main (int argc, char ** argv)
1286 : {
1287 2 : printf ("SPLIT SET TESTS\n");
1288 2 : printf ("==================\n\n");
1289 :
1290 2 : init (argc, argv);
1291 :
1292 2 : test_needsync ();
1293 2 : test_mount ();
1294 2 : test_easyparent ();
1295 2 : test_optimize ();
1296 2 : test_three ();
1297 2 : test_userremove ();
1298 2 : test_systemremove ();
1299 2 : test_emptyremove ();
1300 2 : test_realworld ();
1301 2 : test_emptysplit ();
1302 2 : test_nothingsync ();
1303 2 : test_state ();
1304 :
1305 2 : printf ("\ntest_splitset RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
1306 :
1307 2 : return nbError;
1308 : }
|