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_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_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_keyGetString (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 ();
const char * name = "user/tests/storage/specialkey";
const char * value = "special value";
size_t realValueSize = elektraStrLen (value);
Key * key = keyNew (name, KEY_VALUE, value, KEY_END);
ksAppendKey (ks, key);
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, name, 0);
succeed_if (found, "did not find key");
ssize_t apiValueSize = keyGetValueSize (found);
char * apiString = elektraMalloc (apiValueSize);
succeed_if (keyGetString (found, apiString, apiValueSize) == (ssize_t) realValueSize, "Key string has wrong size");
succeed_if (elektraStrNCmp (value, apiString, realValueSize) == 0, "Key string value is wrong");
elektraFree (apiString);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_keyValue (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 ();
const char * name = "user/tests/storage/specialkey";
size_t valueSize = 42;
void * value = elektraMalloc (valueSize);
memset (value, 42, valueSize);
Key * key = keyNew (name, KEY_END);
keySetBinary (key, value, valueSize);
ksAppendKey (ks, keyDup (key));
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, name, 0);
succeed_if (found, "did not find key");
compare_key (key, found);
elektraFree (value);
keyDel (parentKey);
ksDel (ks);
keyDel (key);
closeStoragePlugin (storagePlugin);
}
static void test_keyGetBaseName (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");
const char * name = "user/tests/storage/a";
Key * found = ksLookupByName (ks, name, 0);
succeed_if (found, "did not find key");
const char * constBaseName = "a";
size_t constBaseNameSize = elektraStrLen (constBaseName);
ssize_t baseNameSize = keyGetFullNameSize (found);
char * baseName = elektraMalloc (baseNameSize);
ssize_t ret = keyGetBaseName (found, baseName, baseNameSize);
if (ret < 1)
{
yield_error ("Key base name NULL or size error");
}
else
{
succeed_if ((size_t) ret == elektraStrLen (constBaseName), "Key base name has wrong size");
}
succeed_if (elektraStrNCmp (constBaseName, baseName, constBaseNameSize) == 0, "Key base name is wrong");
elektraFree (baseName);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_keyClear (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/a", 0);
succeed_if (found, "did not find key");
succeed_if (keyClear (found) == 0, "Key was NULL, keyClear failed");
keySetName (found, "user/tests/storage/foo");
keySetString (found, "new key value");
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
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_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_keySetBinary (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 ();
const char * name = "user/tests/storage/specialkey";
size_t realValueSize = 42;
void * value = elektraMalloc (realValueSize);
memset (value, 42, realValueSize);
Key * key = keyNew (name, KEY_END);
keySetBinary (key, value, realValueSize);
ksAppendKey (ks, key);
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, name, KDB_O_POP);
succeed_if (found, "did not find key");
// now set a new key value to the Key _after_ kdbGet
size_t newValueSize = 4096;
void * newValue = elektraMalloc (newValueSize);
memset (newValue, 253, newValueSize);
succeed_if (keySetBinary (found, newValue, newValueSize) == (ssize_t) newValueSize, "Key binary could not be set");
ksAppendKey (ks, found);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
found = ksLookupByName (ks, name, 0);
succeed_if (found, "did not find key");
ssize_t apiValueSize = keyGetValueSize (found);
char * apiValue = elektraMalloc (apiValueSize);
succeed_if (keyGetBinary (found, apiValue, apiValueSize) == (ssize_t) newValueSize, "Key binary has wrong size");
succeed_if (elektraStrNCmp (value, apiValue, realValueSize) != 0, "Key binary value is wrong");
succeed_if (elektraStrNCmp (newValue, apiValue, newValueSize) == 0, "Key binary value is wrong");
elektraFree (newValue);
elektraFree (apiValue);
elektraFree (value);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
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);
}
static void test_mmap_meta_get_after_reopen (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");
KeySet * expected = metaTestKeySet ();
compare_keyset (expected, ks);
ksDel (expected);
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
static void test_keyCopy_clearOverwriteKey (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 * toCopy = keyNew ("user/tests/storage/newnewkey", KEY_VALUE, "new key", KEY_END);
Key * found = ksLookupByName (ks, "user/tests/storage/b", KDB_O_POP);
succeed_if (found, "did not find key");
// currently, KDB_O_POP doest not clear the readonly name flag
if (test_bit (found->flags, KEY_FLAG_RO_NAME))
{
clear_bit (found->flags, KEY_FLAG_RO_NAME);
}
// overwrite Key
succeed_if (keyCopy (found, 0) == 0, "keyCopy: clear destination failed");
succeed_if (keyCopy (found, toCopy) == 1, "keyCopy failed");
compare_key (found, toCopy);
keyDel (toCopy);
// put key back into place
ksAppendKey (ks, found);
// write KeySet back to storage
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
found = ksLookupByName (ks, "user/tests/storage/newnewkey", 0);
succeed_if (found, "did not find key");
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
static void test_keyName (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");
const char * name = "user/tests/storage/a";
Key * found = ksLookupByName (ks, name, 0);
succeed_if (found, "did not find key");
ssize_t nameSize = keyGetNameSize (found);
succeed_if (elektraStrNCmp (name, keyName (found), nameSize) == 0, "wrong Key name");
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
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 ();
}
}
