static void test_mmap_ks_copy_with_meta (const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = metaTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
ksDel (ks);
KeySet * returned = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, returned, parentKey) == 1, "kdbGet was not successful");
KeySet * expected = metaTestKeySet ();
compare_keyset (expected, returned);
KeySet * copiedKs = ksNew (0, KS_END);
ksCopy (copiedKs, returned);
compare_keyset (expected, copiedKs);
ksDel (copiedKs);
ksDel (expected);
ksDel (returned);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_keyCopy_newKey (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = metaTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
Key * found = ksLookupByName (ks, "user/tests/storage/b", 0);
succeed_if (found, "did not find key");
Key * copy = keyNew (0, KEY_END);
succeed_if (keyCopy (copy, found) != -1, "keyCopy failed");
compare_key (found, copy);
// check that keyCopy has not changed KeySet
KeySet * expected = metaTestKeySet ();
compare_keyset (ks, expected);
// check that KeySet is intact after deleting Key copy
keyDel (copy);
compare_keyset (ks, expected);
ksDel (expected);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_ksCopy (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
KeySet * copyKs = ksNew (0, KS_END);
if (ksCopy (copyKs, ks) == 1)
{
compare_keyset (copyKs, ks);
compare_keyset (ks, copyKs);
}
else
{
yield_error ("ksCopy failed");
}
ksDel (copyKs);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_mmap_ksCopy (const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
succeed_if ((ks->flags & KS_FLAG_MMAP_ARRAY) == KS_FLAG_MMAP_ARRAY, "KeySet array not in mmap");
KeySet * copyKs = ksNew (0, KS_END);
if (ksCopy (copyKs, ks) == 1)
{
compare_keyset (copyKs, ks);
compare_keyset (ks, copyKs);
}
else
{
yield_error ("ksCopy failed");
}
ksDel (copyKs);
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
static void test_ksPop (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
KeySet * poppedKeys = ksNew (0, KS_END);
succeed_if (ksAppendKey (poppedKeys, ksPop (ks)) != -1, "ksAppendKey failed");
succeed_if (ksAppendKey (poppedKeys, ksPop (ks)) != -1, "ksAppendKey failed");
succeed_if (ksGetSize (ks) == 1, "ksGetSize after ksPop should be decremented");
succeed_if (ksAppendKey (poppedKeys, ksPop (ks)) != -1, "ksAppendKey failed");
succeed_if (ksGetSize (poppedKeys) == 3, "expecting three keys to be in ks");
succeed_if (ksPop (ks) == 0, "ks should be empty");
succeed_if (ksAppendKey (poppedKeys, ksPop (ks)) == -1, "ks should be empty, but is not");
KeySet * test = simpleTestKeySet ();
compare_keyset (poppedKeys, test);
ksDel (test);
ksDel (poppedKeys);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_ksPopAtCursor()
{
KeySet *ks = ksNew (
5,
keyNew ("user/valid/key1", KEY_END),
keyNew ("user/valid/key2", KEY_END),
keyNew ("system/valid/key1", KEY_END),
keyNew ("system/valid/key2", KEY_END),
KS_END);
KeySet *ks_c = ksNew (
5,
keyNew ("user/valid/key1", KEY_END),
keyNew ("user/valid/key2", KEY_END),
keyNew ("system/valid/key1", KEY_END),
KS_END);
ksRewind(ks);
ksNext(ks);
ksNext(ks);
cursor_t c = ksGetCursor(ks);
keyDel (ksPopAtCursor(ks, c));
succeed_if(ksCurrent(ks) == 0, "cursor position wrong");
compare_keyset(ks, ks_c);
ksDel(ks);
ksDel(ks_c);
}
static void test_keySetName (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = metaTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
Key * found = ksLookupByName (ks, "user/tests/storage/b", 0);
succeed_if (found, "did not find key");
Key * duplicate = keyDup (found);
keySetName (duplicate, "user/tests/storage/z");
keySetString (duplicate, "zzz");
KeySet * expected = metaTestKeySet ();
compare_keyset (ks, expected);
ksDel (expected);
keyDel (duplicate);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_default()
{
printf ("Test default " KDB_DEFAULT_STORAGE "\n");
KeySet *modules = ksNew(0, KS_END);
elektraModulesInit(modules, 0);
Plugin *plugin = elektraPluginOpen(KDB_DEFAULT_STORAGE, modules, set_pluginconf(), 0);
exit_if_fail (plugin, "KDB_DEFAULT_STORAGE: " KDB_DEFAULT_STORAGE " plugin could not be loaded");
KeySet *test_config = set_pluginconf();
KeySet *config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset(config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbGet != 0, "no get pointer");
succeed_if (plugin->kdbSet != 0, "no set pointer");
elektraPluginClose(plugin, 0);
Backend *backend = elektraBackendOpenDefault(modules, KDB_DB_FILE, 0);
Key *mp;
succeed_if ((mp = backend->mountpoint) != 0, "no mountpoint found");
succeed_if_same_string (keyName(mp), "");
succeed_if_same_string (keyString(mp), "default");
elektraBackendClose(backend, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
}
static void test_elektraRenameKeys()
{
printf ("test rename keys\n");
KeySet *ks= ksNew(20,
keyNew("system/some/common/prefix", KEY_END),
keyNew("system/some/common/prefix/dir", KEY_END),
keyNew("system/some/common/prefix/dir/keya", KEY_END),
keyNew("system/some/common/prefix/some", KEY_VALUE, "huhu", KEY_END),
keyNew("system/some/common/prefix/other", KEY_END),
KS_END);
KeySet *cmp= ksNew(20,
keyNew("user/x/dir", KEY_END),
keyNew("user/x/dir/keya", KEY_END),
keyNew("user/x/some", KEY_VALUE, "huhu", KEY_END),
keyNew("user/x/other", KEY_END),
KS_END);
KeySet *result = elektraRenameKeys(ks, "user/x");
compare_keyset(result, cmp);
// output_keyset(result);
ksDel(cmp);
ksDel(result);
ksDel(ks);
ks= ksNew(0, KS_END);
result = elektraRenameKeys(ks, "user");
output_keyset(result);
ksDel(result);
ksDel(ks);
}
static void test_mmap_metacopy (const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = metaTestKeySet ();
Key * shareMeta = keyNew (0);
keySetMeta (shareMeta, "sharedmeta", "shared meta key test");
Key * current;
ksRewind (ks);
while ((current = ksNext (ks)) != 0)
{
keyCopyMeta (current, shareMeta, "sharedmeta");
}
KeySet * expected = ksDeepDup (ks);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
KeySet * returned = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, returned, parentKey) == 1, "kdbGet was not successful");
compare_keyset (expected, returned);
ksDel (expected);
ksDel (returned);
keyDel (parentKey);
keyDel (shareMeta);
ksDel (ks);
PLUGIN_CLOSE ();
}
static void test_ksDupFun (const size_t storagePlugin, const char * tmpFile, KeySet * copyFunction (const KeySet * source))
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
KeySet * dupKs = copyFunction (ks);
compare_keyset (dupKs, ks);
compare_keyset (ks, dupKs);
ksDel (dupKs);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_mmap_ksDupFun (const char * tmpFile, KeySet * copyFunction (const KeySet * source))
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
succeed_if ((ks->flags & KS_FLAG_MMAP_ARRAY) == KS_FLAG_MMAP_ARRAY, "KeySet array not in mmap");
KeySet * dupKs = copyFunction (ks);
compare_keyset (dupKs, ks);
compare_keyset (ks, dupKs);
ksDel (dupKs);
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
void test_resolve ()
{
int pathLen = tempHomeLen + 1 + strlen (KDB_DB_USER) + 12 + 1;
char * path = elektraMalloc (pathLen);
exit_if_fail (path != 0, "elektraMalloc failed");
snprintf (path, pathLen, "%s/%s/elektra.ecf", tempHome, KDB_DB_USER);
printf ("Resolve Filename\n");
KeySet * modules = ksNew (0, KS_END);
elektraModulesInit (modules, 0);
Key * parentKey = keyNew ("system", KEY_END);
Plugin * plugin = elektraPluginOpen ("resolver", modules, set_pluginconf (), 0);
exit_if_fail (plugin, "could not load resolver plugin");
KeySet * test_config = set_pluginconf ();
KeySet * config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset (config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbOpen != 0, "no open pointer");
succeed_if (plugin->kdbClose != 0, "no open pointer");
succeed_if (plugin->kdbGet != 0, "no open pointer");
succeed_if (plugin->kdbSet != 0, "no open pointer");
succeed_if (plugin->kdbError != 0, "no open pointer");
succeed_if (!strncmp (plugin->name, "resolver", strlen ("resolver")), "got wrong name");
resolverHandles * h = elektraPluginGetData (plugin);
exit_if_fail (h != 0, "no plugin handle");
succeed_if (!strcmp (h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp (h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
succeed_if_same_string (h->user.path, "elektra.ecf");
succeed_if_same_string (h->user.filename, path);
plugin->kdbClose (plugin, parentKey);
// reinit with system path only
plugin->kdbOpen (plugin, parentKey);
h = elektraPluginGetData (plugin);
exit_if_fail (h != 0, "no plugin handle");
succeed_if (!strcmp (h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp (h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
succeed_if (h->user.filename == NULL, "user was initialized, but is not needed");
plugin->kdbClose (plugin, parentKey);
keyDel (parentKey);
elektraPluginClose (plugin, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
elektraFree (path);
}
static void test_double_get (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
KeySet * first = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, first, parentKey) == 1, "kdbGet was not successful");
KeySet * second = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, second, parentKey) == 1, "kdbGet was not successful");
succeed_if (first->array != second->array, "ks->array points to same thing");
compare_keyset (first, ks);
compare_keyset (ks, first);
compare_keyset (second, ks);
compare_keyset (ks, second);
ksDel (ks);
ks = metaTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
KeySet * simple = simpleTestKeySet ();
compare_keyset (first, simple);
compare_keyset (second, simple);
ksDel (first);
ksDel (second);
ksDel (simple);
ksDel (ks);
keyDel (parentKey);
closeStoragePlugin (storagePlugin);
}
static void test_backref()
{
printf ("Test back references\n");
KeySet *modules = ksNew(0, KS_END);
elektraModulesInit(modules, 0);
Backend *backend = elektraBackendOpen(set_backref(), modules, 0);
succeed_if (backend != 0, "there should be a backend");
succeed_if (backend->getplugins[0] == 0, "there should be no plugin");
exit_if_fail (backend->getplugins[1] != 0, "there should be a plugin");
succeed_if (backend->getplugins[2] == 0, "there should be no plugin");
succeed_if (backend->setplugins[0] == 0, "there should be no plugin");
exit_if_fail (backend->setplugins[1] != 0, "there should be a plugin");
succeed_if (backend->setplugins[2] == 0, "there should be no plugin");
Key *mp;
succeed_if ((mp = backend->mountpoint) != 0, "no mountpoint found");
succeed_if_same_string (keyName(mp), "user/tests/backend/backref");
succeed_if_same_string (keyString(mp), "backref");
Plugin *plugin1 = backend->getplugins[1];
Plugin *plugin2 = backend->setplugins[1];
Plugin *plugin3 = backend->errorplugins[1];
succeed_if (plugin1 != 0, "there should be a plugin");
succeed_if (plugin2 != 0, "there should be a plugin");
succeed_if (plugin3 != 0, "there should be a plugin");
succeed_if (plugin1 == plugin2, "it should be the same plugin");
succeed_if (plugin2 == plugin3, "it should be the same plugin");
succeed_if (plugin1 == plugin3, "it should be the same plugin");
succeed_if (plugin1->refcounter == 3, "ref counter should be 3");
KeySet *test_config = set_pluginconf();
KeySet *config = elektraPluginGetConfig (plugin1);
succeed_if (config != 0, "there should be a config");
compare_keyset(config, test_config);
ksDel (test_config);
succeed_if (plugin1->kdbGet != 0, "no get pointer");
succeed_if (plugin1->kdbSet != 0, "no set pointer");
succeed_if (plugin2->kdbGet != 0, "no get pointer");
succeed_if (plugin2->kdbSet != 0, "no set pointer");
elektraBackendClose (backend, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
}
static void test_mmap_get_set (const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
ksDel (ks);
ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
ksDel (ks);
ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
KeySet * expected = simpleTestKeySet ();
compare_keyset (expected, ks);
compare_keyset (ks, expected);
ksDel (expected);
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
static void test_ksCut (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
// create keyset with some folder 'other' that we will then cut
KeySet * ks = simpleTestKeySet ();
KeySet * other = ksNew (10, keyNew ("user/tests/storage/other", KEY_VALUE, "other key", KEY_END),
keyNew ("user/tests/storage/other/a", KEY_VALUE, "other a value", KEY_END),
keyNew ("user/tests/storage/other/b", KEY_VALUE, "other b value", KEY_END), KS_END);
if (ksAppend (ks, other) == -1)
{
yield_error ("ksAppend failed");
}
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
// now cut the 'other' folder
Key * cutKey = keyNew ("user/tests/storage/other", KEY_END);
KeySet * returned = ksCut (ks, cutKey);
succeed_if (returned, "keyset is empty (does not contain the cut keyset)");
KeySet * simple = simpleTestKeySet ();
compare_keyset (simple, ks);
compare_keyset (other, returned);
ksDel (other);
ksDel (returned);
ksDel (simple);
keyDel (cutKey);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
void test_json (const char * fileName, KeySet * compareKeySet, KeySet * conf)
{
printf ("Test json with %s\n", srcdir_file (fileName));
Plugin * plugin = elektraPluginOpen ("yajl", modules, conf, 0);
exit_if_fail (plugin != 0, "could not open plugin");
// printf ("Test with %s\n", srcdir_file(fileName));
Key * parentKey = keyNew ("user/tests/yajl", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * keys = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, keys, parentKey) == 1, "kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
/*
output_keyset(keys);
output_keyset(compareKeySet);
*/
compare_keyset (keys, compareKeySet);
keySetString (parentKey, elektraFilename ());
// printf("File name is: %s\n", keyString(parentKey));
succeed_if (plugin->kdbSet (plugin, keys, parentKey) == 1, "kdbSet was not successful");
succeed_if (output_error (parentKey), "error in kdbSet");
succeed_if (output_warnings (parentKey), "warnings in kdbSet");
succeed_if (compare_line_files (srcdir_file (fileName), keyString (parentKey)), "files do not match as expected");
elektraUnlink (keyString (parentKey));
/*
printf ("The keys we read out are:\n");
output_keyset(keys);
printf ("The keys we compared it with:\n");
output_keyset(compareKeySet);
*/
keyDel (parentKey);
ksDel (keys);
ksDel (compareKeySet);
elektraPluginClose (plugin, 0);
}
void test_tempname()
{
printf ("Resolve Tempname\n");
KeySet *modules = ksNew(0);
elektraModulesInit (modules, 0);
Plugin *plugin = elektraPluginOpen("resolver", modules, set_pluginconf(), 0);
exit_if_fail (plugin, "could not load resolver plugin");
KeySet *test_config = set_pluginconf();
KeySet *config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset(config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbOpen != 0, "no open pointer");
succeed_if (plugin->kdbClose != 0, "no open pointer");
succeed_if (plugin->kdbGet != 0, "no open pointer");
succeed_if (plugin->kdbSet != 0, "no open pointer");
succeed_if (plugin->kdbError!= 0, "no open pointer");
succeed_if (!strcmp(plugin->name, "resolver"), "got wrong name");
resolverHandles *h = elektraPluginGetData(plugin);
succeed_if (h != 0, "no plugin handle");
Key *parentKey= keyNew("system", KEY_END);
plugin->kdbGet(plugin, 0, parentKey);
succeed_if (!strncmp(h->system.tempfile, KDB_DB_SYSTEM "/elektra.ecf", sizeof(KDB_DB_SYSTEM)),
"resulting filename not correct");
keySetName(parentKey, "user");
plugin->kdbGet(plugin, 0, parentKey);
succeed_if (!strncmp(h->user.tempfile, KDB_DB_HOME "/" KDB_DB_USER "/elektra.ecf.tmp", sizeof(KDB_DB_HOME "/" KDB_DB_USER)),
"resulting filename not correct");
keyDel (parentKey);
elektraPluginClose(plugin, 0);
elektraModulesClose(modules, 0);
ksDel (modules);
}
static void test_simple ()
{
printf ("Test plugin\n");
KeySet * modules = ksNew (0, KS_END);
elektraModulesInit (modules, 0);
Plugin * plugin = elektraPluginOpen (KDB_DEFAULT_STORAGE, modules, set_pluginconf (), 0);
exit_if_fail (plugin, "KDB_DEFAULT_STORAGE: " KDB_DEFAULT_STORAGE " plugin could not be loaded");
KeySet * test_config = set_pluginconf ();
KeySet * config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset (config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbGet != 0, "no get pointer");
succeed_if (plugin->kdbSet != 0, "no set pointer");
elektraPluginClose (plugin, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
}
static void test_keyDel (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = metaTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
Key * found = ksLookupByName (ks, "user/tests/storage/b", 0);
succeed_if (found, "did not find key");
succeed_if (keyDel (found) > 0, "Key was NULL or free()'d unexpectedly");
// check that keyDel has not changed KeySet
KeySet * expected = metaTestKeySet ();
compare_keyset (ks, expected);
ksDel (expected);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
void test_name ()
{
printf ("Resolve Name\n");
KeySet * modules = ksNew (0, KS_END);
elektraModulesInit (modules, 0);
Plugin * plugin = elektraPluginOpen ("resolver", modules, set_pluginconf (), 0);
exit_if_fail (plugin, "could not load resolver plugin");
KeySet * test_config = set_pluginconf ();
KeySet * config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset (config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbOpen != 0, "no open pointer");
succeed_if (plugin->kdbClose != 0, "no open pointer");
succeed_if (plugin->kdbGet != 0, "no open pointer");
succeed_if (plugin->kdbSet != 0, "no open pointer");
succeed_if (plugin->kdbError != 0, "no open pointer");
succeed_if (!strncmp (plugin->name, "resolver", strlen ("resolver")), "got wrong name");
resolverHandles * h = elektraPluginGetData (plugin);
succeed_if (h != 0, "no plugin handle");
Key * parentKey = keyNew ("system", KEY_END);
plugin->kdbGet (plugin, 0, parentKey);
succeed_if_same_string (keyString (parentKey), KDB_DB_SYSTEM "/elektra.ecf");
keyDel (parentKey);
elektraPluginClose (plugin, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
}
static void test_revmoreiterate()
{
printf ("Test revmoreiterate trie\n");
for (int i=0; i<5; ++i)
{
Trie *trie = 0;
switch (i)
{
case 0:
trie = test_insert (trie, "user/tests", "tests");
trie = test_insert (trie, "user/tests/hosts", "hosts");
trie = test_insert (trie, "user/tests/hosts/below", "below");
trie = test_insert (trie, "system/tests", "systests");
trie = test_insert (trie, "system/tests/hosts", "syshosts");
trie = test_insert (trie, "system/tests/hosts/below", "sysbelow");
trie = test_insert (trie, "system", "system");
trie = test_insert (trie, "user", "user");
break;
case 1:
trie = test_insert (trie, "system/tests/hosts", "syshosts");
trie = test_insert (trie, "system", "system");
trie = test_insert (trie, "user/tests", "tests");
trie = test_insert (trie, "user/tests/hosts", "hosts");
trie = test_insert (trie, "user/tests/hosts/below", "below");
trie = test_insert (trie, "system/tests", "systests");
trie = test_insert (trie, "user", "user");
trie = test_insert (trie, "system/tests/hosts/below", "sysbelow");
break;
case 2:
trie = test_insert (trie, "system/tests/hosts/below", "sysbelow");
trie = test_insert (trie, "system/tests/hosts", "syshosts");
trie = test_insert (trie, "user/tests/hosts/below", "below");
trie = test_insert (trie, "user/tests/hosts", "hosts");
trie = test_insert (trie, "user/tests", "tests");
trie = test_insert (trie, "user", "user");
trie = test_insert (trie, "system/tests", "systests");
trie = test_insert (trie, "system", "system");
break;
case 3:
trie = test_insert (trie, "user/tests/hosts/below", "below");
trie = test_insert (trie, "user/tests/hosts", "hosts");
trie = test_insert (trie, "user/tests", "tests");
trie = test_insert (trie, "user", "user");
trie = test_insert (trie, "system/tests/hosts/below", "sysbelow");
trie = test_insert (trie, "system/tests/hosts", "syshosts");
trie = test_insert (trie, "system/tests", "systests");
trie = test_insert (trie, "system", "system");
break;
case 4:
trie = test_insert (trie, "system/tests/hosts/below", "sysbelow");
trie = test_insert (trie, "system/tests/hosts", "syshosts");
trie = test_insert (trie, "system/tests", "systests");
trie = test_insert (trie, "system", "system");
trie = test_insert (trie, "user/tests/hosts/below", "below");
trie = test_insert (trie, "user/tests/hosts", "hosts");
trie = test_insert (trie, "user/tests", "tests");
trie = test_insert (trie, "user", "user");
break;
}
KeySet *mps = set_mountpoints();
exit_if_fail (trie, "trie was not build up successfully");
Key *searchKey = keyNew(0);
keySetName(searchKey, "user");
Backend *backend = elektraTrieLookup(trie, searchKey);
succeed_if (backend, "there should be a backend");
compare_key(backend->mountpoint, ksLookupByName(mps, "user",0));
// printf ("backend: %p\n", (void*)backend);
keySetName(searchKey, "user/tests/hosts/other/below");
Backend *b2 = elektraTrieLookup(trie, searchKey);
succeed_if (b2, "there should be a backend");
compare_key(b2->mountpoint, ksLookupByName(mps, "user/tests/hosts",0));
// printf ("b2: %p\n", (void*)b2);
keySetName(searchKey, "user/tests/hosts/other/deep/below");
b2 = elektraTrieLookup(trie, searchKey);
succeed_if (b2, "there should be a backend");
compare_key(b2->mountpoint, ksLookupByName(mps, "user/tests/hosts",0));
keySetName(searchKey, "user/tests/hosts/below");
Backend *b3 = elektraTrieLookup(trie, searchKey);
succeed_if (b3, "there should be a backend");
compare_key(b3->mountpoint, ksLookupByName(mps, "user/tests/hosts/below",0));
backend = b3;
// printf ("b3: %p\n", (void*)b3);
keySetName(searchKey, "user/tests/hosts/below/other/deep/below");
b2 = elektraTrieLookup(trie, searchKey);
succeed_if (b3, "there should be a backend");
compare_key(b3->mountpoint, ksLookupByName(mps, "user/tests/hosts/below",0));
keySetName(searchKey, "system");
backend = elektraTrieLookup(trie, searchKey);
succeed_if (backend, "there should be a backend");
compare_key(backend->mountpoint, ksLookupByName(mps, "system",0));
// printf ("backend: %p\n", (void*)backend);
keySetName(searchKey, "system/tests/hosts/other/below");
b2 = elektraTrieLookup(trie, searchKey);
succeed_if (b2, "there should be a backend");
compare_key(b2->mountpoint, ksLookupByName(mps, "system/tests/hosts",0));
// printf ("b2: %p\n", (void*)b2);
keySetName(searchKey, "system/tests/hosts/other/deep/below");
b2 = elektraTrieLookup(trie, searchKey);
succeed_if (b2, "there should be a backend");
compare_key(b2->mountpoint, ksLookupByName(mps, "system/tests/hosts",0));
keySetName(searchKey, "system/tests/hosts/below");
b3 = elektraTrieLookup(trie, searchKey);
succeed_if (b3, "there should be a backend");
compare_key(b3->mountpoint, ksLookupByName(mps, "system/tests/hosts/below",0));
backend = b3;
// printf ("b3: %p\n", (void*)b3);
keySetName(searchKey, "system/tests/hosts/below/other/deep/below");
b2 = elektraTrieLookup(trie, searchKey);
succeed_if (b3, "there should be a backend");
compare_key(b3->mountpoint, ksLookupByName(mps, "system/tests/hosts/below",0));
/*
printf ("---------\n");
output_trie(trie);
*/
KeySet *mps_cmp = ksNew(0, KS_END);
collect_mountpoints(trie, mps_cmp);
succeed_if (ksGetSize(mps_cmp) == 8, "size should be 8");
compare_keyset(mps, mps_cmp);
ksDel (mps_cmp);
ksDel (mps);
elektraTrieClose(trie, 0);
keyDel (searchKey);
} // end for
}
static void test_simple()
{
printf ("Test simple building of backend\n");
KeySet *modules = ksNew(0, KS_END);
elektraModulesInit(modules, 0);
Key *errorKey = 0;
Backend *backend = elektraBackendOpen(set_simple(), modules, errorKey);
succeed_if (backend->errorplugins[0] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[2] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[3] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[4] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[5] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[6] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[7] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[8] == 0, "there should be no plugin");
succeed_if (backend->errorplugins[9] == 0, "there should be no plugin");
exit_if_fail (backend->errorplugins[1] != 0, "there should be a plugin");
succeed_if (backend->getplugins[0] == 0, "there should be no plugin");
succeed_if (backend->getplugins[2] == 0, "there should be no plugin");
succeed_if (backend->getplugins[3] == 0, "there should be no plugin");
succeed_if (backend->getplugins[4] == 0, "there should be no plugin");
succeed_if (backend->getplugins[5] == 0, "there should be no plugin");
succeed_if (backend->getplugins[6] == 0, "there should be no plugin");
succeed_if (backend->getplugins[7] == 0, "there should be no plugin");
succeed_if (backend->getplugins[8] == 0, "there should be no plugin");
succeed_if (backend->getplugins[9] == 0, "there should be no plugin");
exit_if_fail (backend->getplugins[1] != 0, "there should be a plugin");
succeed_if (backend->setplugins[0] == 0, "there should be no plugin");
succeed_if (backend->setplugins[2] == 0, "there should be no plugin");
succeed_if (backend->setplugins[3] == 0, "there should be no plugin");
succeed_if (backend->setplugins[4] == 0, "there should be no plugin");
succeed_if (backend->setplugins[5] == 0, "there should be no plugin");
succeed_if (backend->setplugins[6] == 0, "there should be no plugin");
succeed_if (backend->setplugins[7] == 0, "there should be no plugin");
succeed_if (backend->setplugins[8] == 0, "there should be no plugin");
succeed_if (backend->setplugins[9] == 0, "there should be no plugin");
exit_if_fail (backend->setplugins[1] != 0, "there should be a plugin");
Key *mp;
succeed_if ((mp = backend->mountpoint) != 0, "no mountpoint found");
succeed_if_same_string (keyName(mp), "user/tests/backend/simple");
succeed_if_same_string (keyString(mp), "simple");
Plugin *plugin = backend->getplugins[1];
KeySet *test_config = set_pluginconf();
KeySet *config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset(config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbGet != 0, "no get pointer");
succeed_if (plugin->kdbSet != 0, "no set pointer");
elektraBackendClose (backend, errorKey);
elektraModulesClose (modules, 0);
ksDel (modules);
}
static void test_ksResize ()
{
int i;
KeySet * ks = 0;
KeySet * copy = ksNew (0, KS_END);
char name[NAME_SIZE];
ks = ksNew (20, keyNew ("user/test01", KEY_END), keyNew ("user/test02", KEY_END), keyNew ("user/test03", KEY_END),
keyNew ("user/test04", KEY_END), keyNew ("user/test05", KEY_END), keyNew ("user/test11", KEY_END),
keyNew ("user/test12", KEY_END), keyNew ("user/test13", KEY_END), keyNew ("user/test14", KEY_END),
keyNew ("user/test15", KEY_END), keyNew ("user/test21", KEY_END), keyNew ("user/test22", KEY_END),
keyNew ("user/test23", KEY_END), keyNew ("user/test24", KEY_END), keyNew ("user/test25", KEY_END),
keyNew ("user/test31", KEY_END), keyNew ("user/test32", KEY_END), keyNew ("user/test33", KEY_END),
keyNew ("user/test34", KEY_END), keyNew ("user/test35", KEY_END), KS_END);
succeed_if (ksGetAlloc (ks) == 20, "20 keys with alloc 20 should work");
ksDel (ks);
printf ("Test resize of keyset\n");
exit_if_fail ((ks = ksNew (0, KS_END)) != 0, "could not create new keyset");
for (i = 0; i < 100; i++)
{
snprintf (name, NAME_SIZE, "user/test%d", i);
ksAppendKey (ks, keyNew (name, KEY_END));
if (i >= 63)
{
succeed_if (ksGetAlloc (ks) == 127, "allocation size wrong");
}
else if (i >= 31)
{
succeed_if (ksGetAlloc (ks) == 63, "allocation size wrong");
}
else if (i >= 15)
{
succeed_if (ksGetAlloc (ks) == 31, "allocation size wrong");
}
else if (i >= 0)
{
succeed_if (ksGetAlloc (ks) == 15, "allocation size wrong");
}
}
succeed_if (ksGetSize (ks) == 100, "could not append 100 keys");
succeed_if (ksGetAlloc (ks) == 127, "allocation size wrong");
for (i = 100; i >= 0; i--)
{
keyDel (ksPop (ks));
if (i >= 64)
{
succeed_if (ksGetAlloc (ks) == 127, "allocation size wrong");
}
else if (i >= 32)
{
succeed_if (ksGetAlloc (ks) == 63, "allocation size wrong");
}
else if (i >= 16)
{
succeed_if (ksGetAlloc (ks) == 31, "allocation size wrong");
}
else if (i >= 0)
{
succeed_if (ksGetAlloc (ks) == 15, "allocation size wrong");
}
}
succeed_if (ksGetSize (ks) == 0, "could not pop 100 keys");
succeed_if (ksGetAlloc (ks) == 15, "allocation size wrong");
ksDel (ks);
exit_if_fail ((ks = ksNew (0, KS_END)) != 0, "could not create new keyset");
ksResize (ks, 100);
succeed_if (ksGetAlloc (ks) == 100, "allocation size wrong");
for (i = 0; i < 100; i++)
{
snprintf (name, NAME_SIZE, "user/test%d", i);
ksAppendKey (ks, keyNew (name, KEY_END));
succeed_if (ksGetAlloc (ks) == 100, "allocation size wrong");
}
succeed_if (ksGetSize (ks) == 100, "could not append 100 keys");
succeed_if (ksGetAlloc (ks) == 100, "allocation size wrong");
ksDel (ks);
ks =
#include "data_keyset.c"
succeed_if (ksGetSize (ks) == 102, "Problem loading keyset with 102 keys");
succeed_if (ksGetAlloc (ks) == 102, "alloc size wrong");
ksCopy (copy, ks);
succeed_if (ksGetSize (copy) == 102, "Problem copy keyset with 102 keys");
succeed_if (ksGetAlloc (copy) == 127, "alloc of copy size wrong");
compare_keyset (copy, ks);
ksClear (copy); // useless, just test for double free
ksCopy (copy, ks);
succeed_if (ksGetSize (copy) == 102, "Problem copy keyset with 102 keys");
succeed_if (ksGetAlloc (copy) == 127, "alloc of copy size wrong");
compare_keyset (copy, ks);
ksDel (copy);
ksDel (ks);
}
static void test_mmap_unlink (const char * tmpFile)
{
// test file unlinking by overwriting config file while mapped
int parentPipe[2];
int childPipe[2];
if (pipe (parentPipe) != 0 || pipe (childPipe) != 0)
{
yield_error ("pipe() error");
}
pid_t pid;
char buf;
pid = fork ();
if (pid == -1)
{
yield_error ("fork() error");
return;
}
else if (pid == 0)
{
// child: open a config file and leave it mapped
int devnull = open ("/dev/null", O_RDWR);
if (devnull == -1) _Exit (EXIT_FAILURE);
// redirect any communication on standard file descriptors to /dev/null
close (STDIN_FILENO);
close (STDOUT_FILENO);
close (STDERR_FILENO);
if (dup (devnull) == -1) _Exit (EXIT_FAILURE);
if (dup (devnull) == -1) _Exit (EXIT_FAILURE);
if (dup (devnull) == -1) _Exit (EXIT_FAILURE);
close (childPipe[0]);
close (parentPipe[1]);
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = simpleTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
if (write (childPipe[1], "a", 1) != 1) _Exit (EXIT_FAILURE); // signal parent that we are ready
close (childPipe[1]);
if (read (parentPipe[0], &buf, 1) != 1) _Exit (EXIT_FAILURE); // wait for parent
close (parentPipe[0]);
KeySet * expected = simpleTestKeySet ();
compare_keyset (expected, ks);
compare_keyset (ks, expected);
ksDel (expected);
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
_Exit (EXIT_SUCCESS);
}
else
{
// parent: try and destroy the file that the child has mapped
close (childPipe[1]);
close (parentPipe[0]);
if (read (childPipe[0], &buf, 1) != 1) _Exit (EXIT_FAILURE); // wait for child
close (childPipe[0]);
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mmapstorage");
KeySet * ks = metaTestKeySet ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
if (write (parentPipe[1], "a", 1) != 1) _Exit (EXIT_FAILURE); // signal child that we are done
close (parentPipe[1]);
int status;
waitpid (pid, &status, 0);
if (status != 0) yield_error ("child process did not exit successfully.");
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
}
void test_resolve()
{
char *path;
int pathLen;
printf ("Resolve Filename\n");
KeySet *modules = ksNew(0);
elektraModulesInit (modules, 0);
Plugin *plugin = elektraPluginOpen("resolver", modules, set_pluginconf(), 0);
exit_if_fail (plugin, "could not load resolver plugin");
KeySet *test_config = set_pluginconf();
KeySet *config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset(config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbOpen != 0, "no open pointer");
succeed_if (plugin->kdbClose != 0, "no open pointer");
succeed_if (plugin->kdbGet != 0, "no open pointer");
succeed_if (plugin->kdbSet != 0, "no open pointer");
succeed_if (plugin->kdbError!= 0, "no open pointer");
succeed_if (!strcmp(plugin->name, "resolver"), "got wrong name");
resolverHandles *h = elektraPluginGetData(plugin);
succeed_if (h != 0, "no plugin handle");
resolverClose(&h->system);
resolverClose(&h->user);
Key *forKey = keyNew("system", KEY_END);
succeed_if (resolveFilename(forKey, &h->system, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
resolverClose(&h->system);
keySetName(forKey, "user");
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
pathLen = tempHomeLen + 1 + strlen (KDB_DB_USER) + 12 + 1;
path = malloc (pathLen);
succeed_if (path != 0, "malloc failed");
snprintf (path, pathLen, "%s/%s/elektra.ecf", tempHome, KDB_DB_USER);
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, path), "filename not set correctly");
resolverClose(&h->user);
#ifdef HAVE_SETENV
unsetenv("USER");
unsetenv("HOME");
keySetName(forKey, "system");
succeed_if (resolveFilename(forKey, &h->system, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
resolverClose(&h->system);
keySetName(forKey, "user");
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, KDB_DB_HOME "/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
setenv("USER","other",1);
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, KDB_DB_HOME "/other/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
setenv("HOME","/nfshome//max//",1);
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, "/nfshome/max/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
unsetenv("HOME");
unsetenv("USER");
#endif
keySetName(forKey, "user");
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, KDB_DB_HOME "/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
keyDel (forKey);
elektraPluginClose(plugin, 0);
elektraModulesClose(modules, 0);
ksDel (modules);
free (path);
}
