LCOV - code coverage report
Current view: top level - tests/ctest - test_splitset.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 906 908 99.8 %
Date: 2019-09-12 12:28:41 Functions: 17 18 94.4 %

          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             : }

Generated by: LCOV version 1.13