void test_readWrite (const char * fileName, KeySet * conf)
{
printf ("Test read write 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);
keySetString (parentKey, elektraFilename ());
// keySetString(parentKey, "/proc/self/fd/1");
// 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));
keyDel (parentKey);
ksDel (keys);
elektraPluginClose (plugin, 0);
}
// test loading lua twice
static void test_two_scripts (void)
{
printf ("Testing loading of two active lua plugins...\n");
KeySet * modules = ksNew (0, KS_END);
elektraModulesInit (modules, 0);
KeySet * conf = ksNew (2, keyNew ("user/script", KEY_VALUE, srcdir_file ("lua/lua_plugin.lua"), KEY_END),
keyNew ("user/print", KEY_END), KS_END);
KeySet * conf2 = ksNew (2, keyNew ("user/script", KEY_VALUE, srcdir_file ("lua/lua_plugin2.lua"), KEY_END),
keyNew ("user/print", KEY_END), KS_END);
Key * errorKey = keyNew ("", KEY_END);
Plugin * plugin = elektraPluginOpen ("lua", modules, conf, errorKey);
succeed_if (output_warnings (errorKey), "warnings in kdbOpen");
succeed_if (output_error (errorKey), "errors in kdbOpen");
exit_if_fail (plugin != NULL, "unable to load lua plugin");
keyDel (errorKey);
Key * errorKey2 = keyNew ("", KEY_END);
Plugin * plugin2 = elektraPluginOpen ("lua", modules, conf2, errorKey2);
succeed_if (output_warnings (errorKey2), "warnings in kdbOpen");
succeed_if (output_error (errorKey2), "errors in kdbOpen");
exit_if_fail (plugin2 != NULL, "unable to load lua plugin again");
keyDel (errorKey2);
elektraPluginClose (plugin2, 0);
elektraPluginClose (plugin, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
}
void test_hostLensFormatting(char *fileName)
{
Key *parentKey = keyNew ("user/tests/augeas-hosts", KEY_VALUE,
srcdir_file (fileName), KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/lens", KEY_VALUE, "Hosts.lns", KEY_END), KS_END);
PLUGIN_OPEN("augeas");
KeySet *ks = ksNew(0, KS_END);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
keySetString (parentKey, elektraFilename());
succeed_if(plugin->kdbSet (plugin, ks, 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));
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ()
;
}
void test_hostLensDelete(char *sourceFile, char *compFile)
{
Key *parentKey = keyNew ("user/tests/augeas-hosts", KEY_VALUE,
srcdir_file (sourceFile), KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/lens", KEY_VALUE, "Hosts.lns", KEY_END), KS_END);
PLUGIN_OPEN("augeas");
KeySet *ks = ksNew(0, KS_END);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
Key *key = ksLookupByName (ks, "user/tests/augeas-hosts/1", 0);
exit_if_fail(key, "localhost not found");
ksPopAtCursor(ks, ksGetCursor(ks));
keyDel (key);
key = ksLookupByName (ks, "user/tests/augeas-hosts/1/ipaddr", 0);
exit_if_fail(key, "ip address of localhost not found");
ksPopAtCursor(ks, ksGetCursor(ks));
keyDel (key);
key = ksLookupByName (ks, "user/tests/augeas-hosts/1/canonical", 0);
exit_if_fail(key, "canonical of localhost not found");
ksPopAtCursor(ks, ksGetCursor(ks));
keyDel (key);
key = ksLookupByName (ks, "user/tests/augeas-hosts/1/#comment", 0);
exit_if_fail(key, "comment of localhost not found");
ksPopAtCursor(ks, ksGetCursor(ks));
keyDel (key);
keySetString (parentKey, elektraFilename());
succeed_if(plugin->kdbSet (plugin, ks, 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 (compFile), keyString (parentKey)),
"files do not match as expected");
ksDel (ks);
elektraUnlink(keyString (parentKey));
keyDel (parentKey);
PLUGIN_CLOSE ()
;
}
void test_metaMerging ()
{
Key *parentKey = keyNew ("user/tests/keytometa", KEY_END);
KeySet *conf = ksNew(0, KS_END);
PLUGIN_OPEN("keytometa");
KeySet* ks = createMergeTestkeys ();
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
Key *key = ksLookupByName(ks, "user/normalkey1", 0);
succeed_if (key, "normalkey1 was removed");
const Key *metaKey1 = keyGetMeta(key, "testmeta");
succeed_if (metaKey1, "normalkey1 contained no metakey");
const char *expected1 = "meta line 1\nmeta line 2\nmeta line 3";
succeed_if (!strcmp (keyString(metaKey1), expected1), "metakey of normalkey1 contained incorrect data");
key = ksLookupByName(ks, "user/normalkey2", 0);
succeed_if (key, "normalkey2 was removed");
const Key *metaKey2 = keyGetMeta(key, "testmeta");
succeed_if (metaKey2, "normalkey2 contained no metakey");
const char *expected2 = "meta line 30\nmeta line 31\nmeta line 32";
succeed_if (!strcmp (keyString(metaKey2), expected2), "metakey of normalkey2 contained incorrect data");
/* change the value of the middle key */
keySetMeta(key, "testmeta", "meta line 30\nchanged meta line\nmeta line 32");
succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1,
"call to kdbSet was not successful");
succeed_if(output_error (parentKey), "error in kdbSet");
succeed_if(output_warnings (parentKey), "warnings in kdbSet");
key = ksLookupByName(ks, "user/convertkey30", 0);
succeed_if (key, "convertkey30 was not restored");
succeed_if (!strcmp (keyString(key), "meta line 30"), "value of convertkey30 was modified");
key = ksLookupByName (ks, "user/convertkey31", 0);
succeed_if (key, "convertkey31 was not restored");
succeed_if (!strcmp (keyString(key), "changed meta line"), "meta information was not written back to convertkey31");
key = ksLookupByName (ks, "user/convertkey32", 0);
succeed_if (key, "convertkey32 was not restored");
succeed_if (!strcmp (keyString(key), "meta line 32"), "value of convertkey32 was modified");
keyDel (parentKey);
ksDel(ks);
PLUGIN_CLOSE ();
}
void test_setGlobalMatch (void)
{
Key * parentKey = keyNew ("user/tests/glob", KEY_END);
// clang-format off
KeySet *conf = ksNew (20,
keyNew ("user/glob/#1", KEY_VALUE, "/*",
KEY_META, "testmetakey1", "testvalue1",
KEY_META, "testmetakey2", "testvalue2",
KEY_END),
KS_END);
// clang-format on
PLUGIN_OPEN ("glob");
KeySet * ks = createKeys ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
succeed_if (output_error (parentKey), "error in kdbSet");
succeed_if (output_warnings (parentKey), "warnings in kdbSet");
testKeys (ks);
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_simpleCutOnGet ()
{
Key *parentKey = keyNew ("user/tests/rename", KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/cut", KEY_VALUE, "will/be/stripped", KEY_END), KS_END);
PLUGIN_OPEN("rename");
KeySet *ks = createSimpleTestKeys();
ksAppendKey(ks, parentKey);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
checkSimpleTestKeys (ks);
ksDel(ks);
/*
* this has to be done because the parentKey is not
* part of ks anymore due to renaming
*/
keyDel(parentKey);
PLUGIN_CLOSE ();
}
static void test_addNewBaseToParentKey()
{
Key *parentKey = keyNew ("user/tests/rename", KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/cut", KEY_VALUE, "new/base", KEY_END), KS_END);
PLUGIN_OPEN("rename");
KeySet *ks = ksNew(0, KS_END);
keyIncRef(parentKey);
ksAppendKey (ks, parentKey);
succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1,
"call to kdbSet was not successful");
succeed_if(output_error (parentKey), "error in kdbSet");
succeed_if(output_warnings (parentKey), "warnings in kdbSet");
Key *key = ksLookupByName (ks, "user/tests/rename/new/base", 0);
succeed_if (key, "new base was not correctly appended to parent key");
ksDel(ks);
keyDecRef(parentKey);
keyDel(parentKey);
PLUGIN_CLOSE ();
}
static void test_rebaseOfNewKeys()
{
Key *parentKey = keyNew ("user/tests/rename", KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/cut", KEY_VALUE, "new/base", KEY_END), KS_END);
PLUGIN_OPEN("rename");
KeySet *ks = ksNew(20,
/* this key was seen by rename before and wont be changed */
keyNew("user/tests/rename/key1",
KEY_VALUE, "value1",
KEY_META, ELEKTRA_ORIGINAL_NAME_META, "user/tests/rename/key1",
KEY_END),
/* this key was not seen by rename before and will be renamed */
keyNew("user/tests/rename/key2",
KEY_VALUE, "value2",
KEY_END),
KS_END);
succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1,
"call to kdbSet was not successful");
succeed_if(output_error (parentKey), "error in kdbSet");
succeed_if(output_warnings (parentKey), "warnings in kdbSet");
Key* key = ksLookupByName (ks, "user/tests/rename/key1", KDB_O_NONE);
succeed_if(key, "key1 was not found anymore, but it should not have been renamed");
key = ksLookupByName (ks, "user/tests/rename/new/base/key2", KDB_O_NONE);
succeed_if(key, "key2 was not correctly renamed");
keyDel (parentKey);
ksDel(ks);
PLUGIN_CLOSE ();
}
static void test_metaConfigTakesPrecedence()
{
Key *parentKey = keyNew ("user/tests/rename", KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/cut", KEY_VALUE, "will/be", KEY_END), KS_END);
PLUGIN_OPEN("rename");
KeySet *ks = createSimpleMetaTestKeys();
ksAppendKey(ks, parentKey);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
/* the first two keys should have been renamed by their metadata */
Key* key = ksLookupByName (ks, "user/tests/rename/key1", KDB_O_NONE);
succeed_if(key, "key1 was not correctly renamed");
key = ksLookupByName (ks, "user/tests/rename/key2", KDB_O_NONE);
succeed_if(key, "key2 was not correctly renamed");
/* the third key should have been renamed by the global config */
key = ksLookupByName (ks, "user/tests/rename/stripped", KDB_O_NONE);
succeed_if(key, "key3 was renamed but would replace the parent key");
/* the fourth key was not renamed because the prefix did not match */
key = ksLookupByName (ks, "user/tests/rename/will/not/be/stripped/key4", KDB_O_NONE);
succeed_if(key, "key4 was renamed although its prefix did not match");
keyDel (parentKey);
ksDel(ks);
PLUGIN_CLOSE ();
}
void test_zeroMatchFlags (void)
{
Key * parentKey = keyNew ("user/tests/glob", KEY_END);
KeySet * conf = ksNew (20, keyNew ("user/glob/#1", KEY_VALUE, "*test1", KEY_META, "testmetakey1", "testvalue1", KEY_END),
/* disable default pathname globbing behaviour */
keyNew ("user/glob/#1/flags", KEY_VALUE, "", KEY_END), KS_END);
PLUGIN_OPEN ("glob");
KeySet * ks = createKeys ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
succeed_if (output_error (parentKey), "error in kdbSet");
succeed_if (output_warnings (parentKey), "warnings in kdbSet");
Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
exit_if_fail (key, "key user/tests/glob/test1 not found");
const Key * metaKey1 = keyGetMeta (key, "testmetakey1");
exit_if_fail (metaKey1, "testmetakey1 not found");
succeed_if (strcmp ("testvalue1", keyValue (metaKey1)) == 0, "value of metakey testmetakey1 not correct");
key = ksLookupByName (ks, "user/tests/glob/test3", 0);
exit_if_fail (key, "user/tests/glob/test3 not found");
succeed_if (!keyGetMeta (key, "testmetakey1"), "testmetakey1 copied to wrong key");
key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
exit_if_fail (key, "user/tests/glob/test2/subtest1 not found");
const Key * metaKey2 = keyGetMeta (key, "testmetakey1");
exit_if_fail (metaKey2, "testmetakey1 not found");
succeed_if (strcmp ("testvalue1", keyValue (metaKey2)) == 0, "value of metakey testmetakey1 not correct");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
void test_differentMetaNames (void)
{
Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("keytometa");
KeySet * ks = createDifferentMetaNameTestKeys ();
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
Key * key = ksLookupByName (ks, "user/normalkey1", 0);
succeed_if (key, "normalkey1 was removed");
const Key * metaKey1 = keyGetMeta (key, "testmeta1");
succeed_if (metaKey1, "normalkey1 contained no meta testmeta1");
const char * expected1 = "meta line1";
succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey testmeta1 of normalkey1 contained incorrect data");
const Key * metaKey2 = keyGetMeta (key, "testmeta2");
succeed_if (metaKey2, "normalkey1 contained no meta testmeta1");
const char * expected2 = "meta line2";
succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey testmeta1 of normalkey1 contained incorrect data");
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
static void test_plainIniWrite (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (30, keyNew ("user/tests/ini-write/nosectionkey", KEY_VALUE, "nosectionvalue", KEY_END),
keyNew ("user/tests/ini-write/section1", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-write/section1/key1", KEY_VALUE, "value1", KEY_END),
keyNew ("user/tests/ini-write/section1/key2", KEY_VALUE, "value2", KEY_END),
keyNew ("user/tests/ini-write/section2", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-write/section2/key3", KEY_VALUE, "value3", KEY_END),
keyNew ("user/tests/ini-write/section2/emptykey", KEY_END), KS_END);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to 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");
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
void test_appendSameLevel (void)
{
Key * parentKey = keyNew ("user/tests/keytometa", KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("keytometa");
KeySet * ks = createSameLevelTestKeys ();
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
/* convertkey1 should be converted to childkey1 as childkey1 is on the same level as requested */
Key * childKey = ksLookupByName (ks, "user/levelkey1/childkey1", 0);
succeed_if (childKey, "childkey1 was removed");
const Key * metaKey1 = keyGetMeta (childKey, "testmeta");
succeed_if (metaKey1, "childkey1 contained no meta testmeta");
const char * expected1 = "convertkey1value";
succeed_if (!strcmp (keyString (metaKey1), expected1), "metakey testmeta of childkey1 contained incorrect data");
/* convertkey2 should be converted to levelkey as the next key in order is not on the same level */
Key * levelkey1 = ksLookupByName (ks, "user/levelkey1", 0);
succeed_if (levelkey1, "levelkey1 was removed");
const Key * metaKey2 = keyGetMeta (levelkey1, "testmeta");
succeed_if (metaKey2, "levelkey1 contained no meta testmeta");
const char * expected2 = "convertkey2value";
succeed_if (!strcmp (keyString (metaKey2), expected2), "metakey testmeta of levelkey1 contained incorrect data");
keyDel (parentKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
static void test_multilineIniWrite (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-multiline-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (30, keyNew ("system/multiline", KEY_VALUE, "1", KEY_END),
keyNew ("system/linecont", KEY_VALUE, "\t", KEY_END), KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (
30, keyNew ("user/tests/ini-multiline-write/multilinesection", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-multiline-write/multilinesection/key1", KEY_VALUE, "value1\nwith continuation\nlines", KEY_END),
keyNew ("user/tests/ini-multiline-write/singlelinesection", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-multiline-write/singlelinesection/key2", KEY_VALUE, "", KEY_END),
keyNew ("user/tests/ini-multiline-write/singlelinesection/key3", KEY_VALUE, "value3", KEY_END), KS_END);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to 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");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_plainIniRead (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-read", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
Key * key = ksLookupByName (ks, "user/tests/ini-read/nosectionkey", KDB_O_NONE);
exit_if_fail (key, "nosectionkey not found");
succeed_if (!strcmp ("nosectionvalue", keyString (key)), "nosectionkey contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-read/section1", KDB_O_NONE);
exit_if_fail (key, "section1 not found");
succeed_if (!keyValue (key), "section value was not empty");
key = ksLookupByName (ks, "user/tests/ini-read/section1/key1", KDB_O_NONE);
exit_if_fail (key, "key1 not found");
succeed_if (!strcmp ("value1", keyString (key)), "key1 contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-read/section2/emptykey", KDB_O_NONE);
exit_if_fail (key, "emptykey not found");
succeed_if (!strcmp ("", keyString (key)), "emptykey contained invalid data");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_withoutConfig()
{
Key *parentKey = keyNew ("user/tests/rename", KEY_END);
Key *parentKeyCopy = keyDup(parentKey);
KeySet *conf = ksNew (0, KS_END);
PLUGIN_OPEN("rename");
KeySet *ks = createSimpleTestKeys();
ksAppendKey(ks, parentKey);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
KeySet *expected = createSimpleTestKeys();
ksAppendKey(expected, parentKeyCopy);
compareKeySets(ks, expected);
keyDel (parentKey);
keyDel (parentKeyCopy);
ksDel(expected);
ksDel(ks);
PLUGIN_CLOSE ();
}
static void test_multilineIniRead (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-multiline-read", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (30, keyNew ("system/multiline", KEY_VALUE, "1", KEY_END),
keyNew ("system/linecont", KEY_VALUE, "\t", KEY_END), KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
Key * key = ksLookupByName (ks, "user/tests/ini-multiline-read/multilinesection/key1", KDB_O_NONE);
exit_if_fail (key, "key1 not found");
succeed_if (!strcmp ("value1\nwith continuation\nlines", keyString (key)), "key1 contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-multiline-read/singlelinesection/key2", KDB_O_NONE);
exit_if_fail (key, "key2 not found");
succeed_if (!strcmp ("", keyString (key)), "key2 contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-multiline-read/singlelinesection/key3", KDB_O_NONE);
exit_if_fail (key, "key3 not found");
succeed_if (!strcmp ("value3", keyString (key)), "key3 contained invalid data");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_plainIniEmptyWrite (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (30, keyNew ("user/tests/ini-write/nosectionkey", KEY_VALUE, "nosectionvalue", KEY_END),
keyNew ("user/tests/ini-write/section1", KEY_BINARY,
KEY_END),
keyNew ("user/tests/ini-write/section1/key1", KEY_VALUE, "value1", KEY_END),
keyNew ("user/tests/ini-write/section1/key2", KEY_VALUE, "value2", KEY_END),
keyNew ("user/tests/ini-write/section2", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-write/section2/key3", KEY_VALUE, "value3", KEY_END),
keyNew ("user/tests/ini-write/section2/emptykey", KEY_META, "ini/empty", "", KEY_END), KS_END);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to 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");
KeySet * readKS = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, readKS, parentKey) >= 0, "kdbGet failed");
const Key * meta;
Key * searchKey = keyNew ("user/tests/ini-write/section2/emptykey", KEY_META, "ini/empty", "", KEY_END);
Key * key = ksLookup (readKS, searchKey, KDB_O_NONE);
meta = keyGetMeta (key, "ini/empty");
succeed_if (meta != NULL, "reading empty key again failed");
ksDel (readKS);
keyDel (parentKey);
keyDel (searchKey);
ksDel (ks);
PLUGIN_CLOSE ();
}
void test_namedMatchFlags (void)
{
Key * parentKey = keyNew ("user/tests/glob", KEY_END);
KeySet * conf = ksNew (20, keyNew ("user/glob/#1", KEY_VALUE, "user/tests/glob/*", KEY_META, "testmetakey1", "testvalue1", KEY_END),
/* explicitly request pathname matching */
keyNew ("user/glob/#1/flags", KEY_VALUE, "pathname", KEY_END), KS_END);
PLUGIN_OPEN ("glob");
KeySet * ks = createKeys ();
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
succeed_if (output_error (parentKey), "error in kdbSet");
succeed_if (output_warnings (parentKey), "warnings in kdbSet");
Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
exit_if_fail (key, "key user/tests/glob/test1 not found");
const Key * metaKey1 = keyGetMeta (key, "testmetakey1");
exit_if_fail (metaKey1, "testmetakey1 not found");
key = ksLookupByName (ks, "user/tests/glob/test3", 0);
exit_if_fail (key, "user/tests/glob/test3 not found");
const Key * metaKey2 = keyGetMeta (key, "testmetakey1");
exit_if_fail (metaKey2, "testmetakey1 not found");
key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
exit_if_fail (key, "user/tests/glob/test2/subtest1 not found");
const Key * metaKey3 = keyGetMeta (key, "testmetakey1");
exit_if_fail (!metaKey3, "testmetakey1 was copied to subtest1, but subtest1 should not be matched with pathname flag");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_sectionWrite (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-section-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (10, keyNew ("system/section", KEY_VALUE, "NULL", KEY_END), KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (30, keyNew ("user/tests/ini-section-write/akey/looking/like/sections", KEY_VALUE, "value", KEY_END),
keyNew ("user/tests/ini-section-write/emptysection", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-section-write/section1", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-section-write/section1/key1", KEY_VALUE, "value1", KEY_END),
keyNew ("user/tests/ini-section-write/section1/key/with/subkey", KEY_VALUE, "value2", KEY_END),
keyNew ("user/tests/ini-section-write/section2/with/subkey", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-section-write/section2/with/subkey/key2", KEY_VALUE, "value2", KEY_END), KS_END);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to 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");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
void test_restoreOnSet () {
Key *parentKey = keyNew ("user/tests/keytometa", KEY_END);
KeySet *conf = ksNew(0, KS_END);
PLUGIN_OPEN("keytometa");
KeySet *ks = createSimpleTestKeys ();
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
Key *key = ksLookupByName(ks, "user/normalkey2", 0);
succeed_if (key, "normalkey2 was removed");
/* change the meta information stored in normalkey2
* (was generated from convertkey1)
*/
keySetMeta(key, "testmeta", "changedtestvalue");
/* do not touch the meta information of normalkey3
* (was generated from convertkey2)
*/
succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1,
"call to kdbSet was not successful");
succeed_if(output_error (parentKey), "error in kdbSet");
succeed_if(output_warnings (parentKey), "warnings in kdbSet");
key = ksLookupByName(ks, "user/convertkey1", 0);
succeed_if (key, "convertkey1 was not restored");
succeed_if (!strcmp (keyString(key), "changedtestvalue"), "meta information was not written back to convertkey1");
key = ksLookupByName (ks, "user/convertkey2", 0);
succeed_if (key, "convertkey2 was not restored");
succeed_if (!strcmp (keyString(key), "testvalue2"), " value of convertkey2 was modified");
key = ksLookupByName (ks, "user/normalkey1/subkey", 0);
succeed_if (key, "subkey was not restored");
succeed_if (!strcmp (keyString(key), "testvalue3"), " value of subkey was modified");
keyDel (parentKey);
ksDel(ks);
PLUGIN_CLOSE ()
;
}
static void test_defaultonly()
{
printf ("Test mounting with default only\n");
KDB *kdb = kdb_new();
Key *errorKey = keyNew(0);
KeySet *modules = modules_config();
succeed_if (elektraMountOpen(kdb, minimal_config(), modules, errorKey) == 0, "could not buildup mount");
succeed_if (elektraMountDefault(kdb, modules, errorKey) == 0, "could not mount default backend");
// output_split (kdb->split);
succeed_if (kdb->split->size == 4, "size of split not correct");
Key *mp = keyNew("spec", KEY_VALUE, "default", KEY_END);
compare_key(mp, kdb->split->parents[0]);
keySetName(mp, "dir"); keySetString (mp, "default");
compare_key(mp, kdb->split->parents[1]);
keySetName(mp, "user"); keySetString (mp, "default");
compare_key(mp, kdb->split->parents[2]);
keySetName(mp, "system"); keySetString (mp, "default");
compare_key(mp, kdb->split->parents[3]);
succeed_if(output_warnings (errorKey), "warnings found");
succeed_if(output_error (errorKey), "error found");
succeed_if (!kdb->trie, "trie should be empty");
Key *searchKey = keyNew("", KEY_END);
Backend *b2 = 0;
keySetName (searchKey, "user");
b2 = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (b2 == 0, "should be default backend");
keySetName(searchKey, "user/tests/simple");
b2 = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (b2 == 0, "should be default backend");
keySetName(searchKey, "user/tests/simple/below");
b2 = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (b2 == 0, "should be default backend");
keySetName(searchKey, "user/tests/simple/deep/below");
b2 = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (b2 == 0, "should be default backend");
keyDel (mp);
keyDel (searchKey);
kdb_del (kdb);
keyDel (errorKey);
ksDel (modules);
}
static void test_simpleCutRestoreOnSet () {
Key *parentKey = keyNew ("user/tests/rename", KEY_END);
Key *parentKeyCopy = keyDup(parentKey);
KeySet *conf = ksNew (20,
keyNew ("system/cut", KEY_VALUE, "will/be/stripped", KEY_END), KS_END);
PLUGIN_OPEN("rename");
KeySet *ks = createSimpleTestKeys();
ksAppendKey(ks, parentKey);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1,
"call to kdbSet was not successful");
succeed_if(output_error (parentKey), "error in kdbSet");
succeed_if(output_warnings (parentKey), "warnings in kdbSet");
/* test that the keys have been correctly restored */
KeySet *expected = createSimpleTestKeys();
/* the parent key is restored from user/tests/rename/will/be/stripped
* and therefore will have its key value
*/
keySetString (parentKeyCopy, "value3");
ksAppendKey (expected, parentKeyCopy);
compareKeySets (ks, expected);
ksDel(expected);
ksDel(ks);
/*
* this has to be done because the parentKey is not
* part of ks anymore due to renaming
*/
keyDel(parentKey);
PLUGIN_CLOSE ();
}
void test_hostLensWrite(char *fileName)
{
Key *parentKey = keyNew ("user/tests/augeas-hosts", KEY_VALUE,
elektraFilename(), KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/lens", KEY_VALUE, "Hosts.lns", KEY_END), KS_END);
PLUGIN_OPEN("augeas");
KeySet *ks = ksNew (30, keyNew ("user/tests/augeas-hosts/1", KEY_END),
keyNew ("user/tests/augeas-hosts/1/ipaddr", KEY_VALUE, "127.0.0.1",
KEY_META, "order", "10", KEY_END),
keyNew ("user/tests/augeas-hosts/1/canonical", KEY_VALUE,
"localhost", KEY_META, "order", "20", KEY_END),
keyNew ("user/tests/augeas-hosts/1/#comment", KEY_VALUE,
"hostcomment", KEY_META, "order", "21", KEY_END),
keyNew ("user/tests/augeas-hosts/#comment", KEY_VALUE,
"linecomment", KEY_META, "order", "22", KEY_END),
keyNew ("user/tests/augeas-hosts/2/ipaddr", KEY_VALUE,
"192.168.0.1", KEY_META, "order", "30", KEY_END),
keyNew ("user/tests/augeas-hosts/2/canonical", KEY_VALUE, "host1",
KEY_META, "order", "40", KEY_END),
keyNew ("user/tests/augeas-hosts/2/alias[1]", KEY_VALUE,
"host1alias1", KEY_META, "order", "50", KEY_END),
keyNew ("user/tests/augeas-hosts/2/alias[2]", KEY_VALUE,
"host1alias2", KEY_META, "order", "60", KEY_END),
keyNew ("user/tests/augeas-hosts/3/ipaddr", KEY_VALUE,
"fd00::4711:4712:2::1", KEY_META, "order", "70", KEY_END),
keyNew ("user/tests/augeas-hosts/3/canonical", KEY_VALUE, "host2",
KEY_META, "order", "80", KEY_END),
keyNew ("user/tests/augeas-hosts/3/alias[1]", KEY_VALUE,
"host2alias1", KEY_META, "order", "90", KEY_END),
keyNew ("user/tests/augeas-hosts/3/alias[2]", KEY_VALUE,
"host2alias2", KEY_META, "order", "100", KEY_END), KS_END);
ksAppendKey (ks, parentKey);
succeed_if(plugin->kdbSet (plugin, ks, 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));
ksDel (ks);
PLUGIN_CLOSE ();
}
static void testreadwriteinvalid (const char * file)
{
Key * parentKey = keyNew ("user/tests/csvstorage", KEY_VALUE, srcdir_file (file), KEY_END);
KeySet * conf = ksNew (10, keyNew ("system/delimiter", KEY_VALUE, ";", KEY_END), KS_END);
KeySet * ks = ksNew (0, KS_END);
PLUGIN_OPEN ("csvstorage");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) > 0, "call to kdbGet was not successful");
succeed_if (!output_warnings (parentKey), "no warnings in kdbGet");
keySetString (parentKey, elektraFilename ());
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == (-1), "error: wrote invalid data");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
void test_hostLensRead(char *fileName)
{
Key *parentKey = keyNew ("user/tests/augeas-hosts", KEY_VALUE,
srcdir_file (fileName), KEY_END);
KeySet *conf = ksNew (20,
keyNew ("system/lens", KEY_VALUE, "Hosts.lns", KEY_END), KS_END);
PLUGIN_OPEN("augeas");
KeySet *ks = ksNew(0, KS_END);
succeed_if(plugin->kdbGet (plugin, ks, parentKey) >= 1,
"call to kdbGet was not successful");
succeed_if(output_error (parentKey), "error in kdbGet");
succeed_if(output_warnings (parentKey), "warnings in kdbGet");
Key *key = ksLookupByName (ks, "user/tests/augeas-hosts/1/ipaddr", 0);
exit_if_fail(key, "ip address of localhost not found");
succeed_if(strcmp ("127.0.0.1", keyValue (key)) == 0,
"address of localhost not correct");
key = ksLookupByName (ks, "user/tests/augeas-hosts/1/canonical", 0);
exit_if_fail(key, "name of localhost not found");
succeed_if(strcmp ("localhost", keyValue (key)) == 0,
"name of localhost not correct");
key = ksLookupByName (ks, "user/tests/augeas-hosts/2/ipaddr", 0);
exit_if_fail(key, "ip address of host1 not found");
succeed_if(strcmp ("192.168.0.1", keyValue (key)) == 0,
"address of host1 not correct");
key = ksLookupByName (ks, "user/tests/augeas-hosts/2/canonical", 0);
exit_if_fail(key, "name of host1 not found");
succeed_if(strcmp ("host1", keyValue (key)) == 0,
"name of host1 not correct");
key = ksLookupByName (ks, "user/tests/augeas-hosts/2/alias[1]", 0);
exit_if_fail(key, "alias1 of host1 not found");
succeed_if(strcmp ("alias1", keyValue (key)) == 0,
"name of alias1 of host1 not correct");
key = ksLookupByName (ks, "user/tests/augeas-hosts/2/alias[2]", 0);
exit_if_fail(key, "alias2 of host1 not found");
succeed_if(strcmp ("alias2", keyValue (key)) == 0,
"name of alias2 of host1 not correct");
PLUGIN_CLOSE();
ksDel (ks);
keyDel(parentKey);
}
void test_onlyFirstMatchIsApplied (void)
{
Key * parentKey = keyNew ("user/tests/glob", KEY_END);
// clang-format off
KeySet * conf = ksNew (20,
keyNew ("user/glob/#1",
KEY_VALUE, "user/tests/glob/test1*",
KEY_META, "testmetakey1", "testvalue1",
KEY_END),
keyNew ("user/glob/#2",
KEY_VALUE, "user/tests/glob/*",
KEY_META, "testmetakey2", "testvalue2",
KEY_END),
/* disable all flags */
keyNew ("user/glob/#1/flags",
KEY_VALUE, "",
KEY_END),
keyNew ("user/glob/#2/flags",
KEY_VALUE, "",
KEY_END),
KS_END);
// clang-format on
PLUGIN_OPEN ("glob");
KeySet * ks = createKeys ();
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
succeed_if (output_error (parentKey), "error in kdbSet");
succeed_if (output_warnings (parentKey), "warnings in kdbSet");
Key * key = ksLookupByName (ks, "user/tests/glob/test1", 0);
exit_if_fail (key, "key user/tests/glob/test1 not found");
const Key * firstMatchKey = keyGetMeta (key, "testmetakey1");
exit_if_fail (firstMatchKey, "testmetakey1 not found");
const Key * secondMatchKey = keyGetMeta (key, "testmetakey2");
exit_if_fail (!secondMatchKey, "testmetakey2 was applied to testmetakey1 although another match was already applied")
key = ksLookupByName (ks, "user/tests/glob/test2/subtest1", 0);
exit_if_fail (key, "user/tests/glob/test2/subtest1 not found");
exit_if_fail (keyGetMeta (key, "testmetakey2"), "testmetakey2 not found");
key = ksLookupByName (ks, "user/tests/glob/test3", 0);
exit_if_fail (key, "user/tests/glob/test3 not found");
exit_if_fail (keyGetMeta (key, "testmetakey2"), "testmetakey2 not found");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_simple()
{
printf ("Test simple mount\n");
KDB *kdb = kdb_new();
Key *errorKey = keyNew(0);
KeySet *modules = modules_config();
Key *mp = keyNew("user/tests/simple", KEY_VALUE, "simple", KEY_END);
succeed_if (elektraMountOpen(kdb, simple_config(), modules, errorKey) == 0, "could not open trie");
succeed_if (kdb->split->size == 1, "size of split not correct");
compare_key(mp, kdb->split->parents[0]);
succeed_if(output_warnings (errorKey), "warnings found");
succeed_if(output_error (errorKey), "error found");
exit_if_fail (kdb->trie, "kdb->trie was not build up successfully");
Key *searchKey = keyNew("user", KEY_END);
Backend *backend = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (!backend, "there should be no backend");
keySetName(searchKey, "user/tests/simple");
backend = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (backend, "there should be a backend");
compare_key(backend->mountpoint, mp);
keySetName(searchKey, "user/tests/simple/below");
Backend *b2 = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (b2, "there should be a backend");
succeed_if (backend == b2, "should be same backend");
compare_key(b2->mountpoint, mp);
keySetName(searchKey, "user/tests/simple/deep/below");
b2 = elektraTrieLookup(kdb->trie, searchKey);
succeed_if (b2, "there should be a backend");
succeed_if (backend == b2, "should be same backend");
compare_key(b2->mountpoint, mp);
keyDel (errorKey);
ksDel (modules);
keyDel (mp);
keyDel (searchKey);
kdb_del (kdb);
}
static void test_sectionRead (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-section-read", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
Key * key = ksLookupByName (ks, "user/tests/ini-section-read/akey/looking/like/sections", KDB_O_NONE);
exit_if_fail (key, "section like key not found not found");
succeed_if (!strcmp ("value", keyString (key)), "section like key contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-section-read/emptysection", KDB_O_NONE);
exit_if_fail (key, "empty section key not found");
succeed_if (keyIsBinary (key), "empty section key is not a binary key");
succeed_if (!keyValue (key), "section key contains non null data");
key = ksLookupByName (ks, "user/tests/ini-section-read/section1", KDB_O_NONE);
exit_if_fail (key, "section1 key not found");
succeed_if (keyIsBinary (key), "section1 key is not a binary key");
succeed_if (!keyValue (key), "section1 contains non null data");
key = ksLookupByName (ks, "user/tests/ini-section-read/section1/key1", KDB_O_NONE);
exit_if_fail (key, "key1 not found not found");
succeed_if (!strcmp ("value1", keyString (key)), "key1 contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-section-read/section1/key/with/subkey", KDB_O_NONE);
exit_if_fail (key, "key with subkey not found not found");
succeed_if (!strcmp ("value2", keyString (key)), "key with subkey contained invalid data");
key = ksLookupByName (ks, "user/tests/ini-section-read/section2/with/subkey", KDB_O_NONE);
exit_if_fail (key, "section2 key not found");
succeed_if (keyIsBinary (key), "section2 key is not a binary key");
succeed_if (!keyValue (key), "section2 contains non null data");
key = ksLookupByName (ks, "user/tests/ini-section-read/section2/with/subkey/key2", KDB_O_NONE);
exit_if_fail (key, "key2 not found not found");
succeed_if (!strcmp ("value2", keyString (key)), "key2 contained invalid data");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
