void testReadMultiLine (const char * fileName) { Key * parentKey = keyNew ("user/tests/file", KEY_VALUE, srcdir_file (fileName), KEY_END); KeySet * conf = ksNew (0, KS_END); PLUGIN_OPEN ("file"); KeySet * ks = ksNew (0, KS_END); succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful"); const Key * key = ksLookupByName (ks, "user/tests/file", KDB_O_NONE); exit_if_fail (key, "key not found"); succeed_if (!strcmp ("\nthis\n\n\tis a\n multi line test-\nfile\n\n", keyString (key)), "read multiline data doesn't match expected string"); ksDel (ks); keyDel (parentKey); PLUGIN_CLOSE (); }
void testRoundTrip (const char * fileName) { Key * parentKey = keyNew ("user/tests/file", KEY_VALUE, srcdir_file (fileName), KEY_END); KeySet * conf = ksNew (0, KS_END); PLUGIN_OPEN ("file"); KeySet * ks = ksNew (0, KS_END); succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful"); keySetString (parentKey, elektraFilename ()); succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "call to kdbSet was not successful"); 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_mmap_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"); 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); ksDel (expected); ksDel (returned); keyDel (parentKey); ksDel (ks); PLUGIN_CLOSE (); }
void test_simpleAppendModes() { Key *parentKey = keyNew ("user/tests/keytometa", KEY_END); KeySet *conf = ksNew (0); 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"); /* converted keys must be removed from the result */ succeed_if (!ksLookupByName(ks, "user/convertkey1", 0), "convertkey1 was not converted"); succeed_if (!ksLookupByName(ks, "user/convertkey2", 0), "convertkey2 was not converted"); /* normalkey2 must contain meta information generated from convertkey1 (via next) */ Key *key = ksLookupByName(ks, "user/normalkey2", 0); succeed_if (key, "normalkey2 was removed"); const Key *metaKey1 = keyGetMeta(key, "testmeta"); succeed_if (metaKey1, "normalkey1 contained no metakey"); succeed_if (!strcmp (keyString(metaKey1), "testvalue1"), "metakey of normalkey1 contained incorrect data"); /* normalkey3 must contain meta information generated from convertkey2 (via previous) */ key = ksLookupByName (ks, "user/normalkey3", 0); succeed_if (key, "normalkey3 was removed"); const Key *metaKey2 = keyGetMeta(key, "testmeta"); succeed_if (metaKey2, "normalkey1 contained no metakey"); succeed_if (!strcmp (keyString(metaKey2), "testvalue2"), "metakey of normalkey2 contained incorrect data"); keyDel (parentKey); ksDel(ks); PLUGIN_CLOSE () ; }
int main (void) { KeySet * myConfig = ksNew (0, KS_END); Key * key = keyNew ("/sw/MyApp", KEY_CASCADING_NAME, KEY_END); KDB * handle = kdbOpen (key); if (!handle) printError (key); printWarnings (key); if (kdbGet (handle, myConfig, key) < 0) printError (key); printWarnings (key); keyDel (key); // lookup Key * result = ksLookupByName (myConfig, "/sw/MyApp/Tests/TestKey1", 0); if (!result) printf ("Key not found in KeySet\n"); else { // do something with the key const char * key_name = keyName (result); const char * key_value = keyString (result); const char * key_comment = keyString (keyGetMeta (result, "comment")); printf ("key: %s value: %s comment: %s\n", key_name, key_value, key_comment); } ksDel (myConfig); // delete the in-memory configuration // maybe you want kdbSet() myConfig here kdbClose (handle, 0); // no more affairs with the key database. }
static void test_file_signature_operations (void) { Plugin * plugin = NULL; Key * parentKey = keyNew ("system", KEY_END); KeySet * modules = ksNew (0, KS_END); KeySet * config = newPluginConfiguration (); elektraModulesInit (modules, 0); plugin = elektraPluginOpen (PLUGIN_NAME, modules, config, 0); succeed_if (plugin, "failed to open plugin handle"); if (plugin) { KeySet * data = ksNew (0, KS_END); const char * tmpFile = elektraFilename (); if (tmpFile) { // prepare test file to be encrypted writeTestFile (tmpFile); keySetString (parentKey, tmpFile); // try to encrypt the file succeed_if (plugin->kdbSet (plugin, data, parentKey) == 1, "kdb set failed"); succeed_if (isTestFileCorrect (tmpFile) == -1, "file content did not change during encryption"); // try to decrypt/verify the file succeed_if (plugin->kdbGet (plugin, data, parentKey) == 1, "kdb get failed"); remove (tmpFile); } ksDel (data); elektraPluginClose (plugin, 0); } elektraModulesClose (modules, 0); ksDel (modules); keyDel (parentKey); }
int main() { KeySet *myConfig = ksNew(0, KS_END); Key *key = keyNew("system/test/myapp",KEY_END); KDB *handle = kdbOpen(key); kdbGet(handle, myConfig, key); keySetName(key, "user/test/myapp"); kdbGet(handle, myConfig, key); // check for errors in key keyDel(key); /* ksRewind(myConfig); while ((key = ksNext(myConfig))) { printf ("%s\n", keyName(key)); } */ key = ksLookupByName(myConfig,"/test/myapp/key", 0); // check if key is not 0 and work with it... if (key) { printf("%s\n", keyString(key)); } ksDel (myConfig); // delete the in-memory configuration // maybe you want kdbSet() myConfig here kdbClose(handle, 0); // no more affairs with the key database. return 0; }
static void test_callbackCalledWithKey (void) { printf ("test callback is called with changed key\n"); KeySet * conf = ksNew (0, KS_END); PLUGIN_OPEN ("internalnotification"); char * value = "foobaroo!"; Key * valueKey = keyNew ("user/test/internalnotification/value", KEY_VALUE, value, KEY_END); KeySet * ks = ksNew (1, valueKey, KS_END); succeed_if (internalnotificationRegisterCallback (plugin, valueKey, test_callback) == 1, "call to elektraInternalnotificationRegisterCallback was not successful"); elektraInternalnotificationUpdateRegisteredKeys (plugin, ks); succeed_if (callback_called, "registered value was not updated"); succeed_if_same_string (callback_keyName, keyName (valueKey)); succeed_if_same_string (callback_keyValue, value); ksDel (ks); PLUGIN_CLOSE (); }
void test_dup() { Key *key; Key *dup; key = keyNew ("user/orig", KEY_END); succeed_if (keySetMeta (key, "test", "some_meta_test") == sizeof("some_meta_test"), "could not set meta"); succeed_if (!strcmp(keyValue (keyGetMeta(key, "test")), "some_meta_test"), "could not set meta value"); dup = keyDup (key); succeed_if (!strcmp(keyValue (keyGetMeta(dup, "test")), "some_meta_test"), "in duplicated key meta value was not copied"); succeed_if (keySetMeta (dup, "test", "some_other_meta_test") == sizeof("some_other_meta_test"), "could not set meta"); succeed_if (!strcmp(keyValue (keyGetMeta(dup, "test")), "some_other_meta_test"), "in duplicated key meta value was not changed"); succeed_if (!strcmp(keyValue (keyGetMeta(key, "test")), "some_meta_test"), "in original key the value has changed"); keyDel (dup); keyDel (key); }
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 (!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 (!strcmp(keyString(parentKey), KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct"); keyDel (parentKey); elektraPluginClose(plugin, 0); elektraModulesClose(modules, 0); ksDel (modules); }
static void test_commentIniRead (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"); const Key * noSectionComment = keyGetMeta (key, "comment"); exit_if_fail (noSectionComment, "nosectionkey contained no comment"); succeed_if (!strcmp ("nosection comment1\nnosection comment2", keyString (noSectionComment)), "nosectionkey contained an invalid comment"); key = ksLookupByName (ks, "user/tests/ini-read/section1", KDB_O_NONE); exit_if_fail (key, "section1 not found"); const Key * sectionComment = keyGetMeta (key, "comment"); exit_if_fail (sectionComment, "nosectionkey contained no comment"); succeed_if (!strcmp ("section comment1\nsection comment2", keyString (sectionComment)), "section1 contained an invalid comment"); key = ksLookupByName (ks, "user/tests/ini-read/section1/key1", KDB_O_NONE); exit_if_fail (key, "key1 not found"); const Key * keyComment_ = keyGetMeta (key, "comment"); exit_if_fail (keyComment_, "key1 contained no comment"); succeed_if (!strcmp ("key comment1\nkey comment2", keyString (keyComment_)), "key1 contained an invalid comment"); ksDel (ks); keyDel (parentKey); PLUGIN_CLOSE (); }
void test_plainIniRead(char *fileName) { Key *parentKey = keyNew ("user/tests/ini-read", KEY_VALUE, srcdir_file(fileName), KEY_END); KeySet *conf = ksNew (0); PLUGIN_OPEN ("ini"); KeySet *ks = ksNew (0); 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 (keyIsDir(key), "section1 is not a directory key"); 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_basics () { printf ("test basics\n"); Key * parentKey = keyNew ("user/tests/template", KEY_END); KeySet * conf = ksNew (0, KS_END); PLUGIN_OPEN ("template"); KeySet * ks = ksNew (0, KS_END); succeed_if (plugin->kdbOpen (plugin, parentKey) == 1, "call to kdbOpen was not successful"); succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "call to kdbGet was not successful"); succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "call to kdbSet was not successful"); succeed_if (plugin->kdbError (plugin, ks, parentKey) == 1, "call to kdbError was not successful"); succeed_if (plugin->kdbClose (plugin, parentKey) == 1, "call to kdbClose was not successful"); keyDel (parentKey); ksDel (ks); PLUGIN_CLOSE (); }
static void test_intNoUpdateWithInvalidValue (void) { printf ("test no update with invalid value\n"); KeySet * conf = ksNew (0, KS_END); PLUGIN_OPEN ("internalnotification"); Key * valueKey = keyNew ("user/test/internalnotification/value", KEY_END); KeySet * ks = ksNew (1, valueKey, KS_END); int value = 123; succeed_if (internalnotificationRegisterInt (plugin, valueKey, &value) == 1, "call to elektraInternalnotificationRegisterInt was not successful"); keySetString (valueKey, "42abcd"); elektraInternalnotificationUpdateRegisteredKeys (plugin, ks); succeed_if (value == 123, "registered value was updated"); ksDel (ks); PLUGIN_CLOSE (); }
static int elektraResolveEnvUser (ElektraResolved * handle) { const char * user = getenv ("USER"); if (!user || !strcmp (user, "")) { return 0; } Key * canonify = keyNew ("user", KEY_END); keyAddName (canonify, user); size_t homeSize = sizeof (KDB_DB_HOME "/") + keyGetNameSize (canonify) + sizeof ("/" KDB_DB_USER); char * homeBuf = elektraMalloc (homeSize); strcpy (homeBuf, KDB_DB_HOME "/"); strcat (homeBuf, keyName (canonify) + 5); // cut user/ if (handle->relPath[0] != '/') { strcat (homeBuf, "/" KDB_DB_USER); } keyDel (canonify); handle->dirname = homeBuf; return 1; }
static void test_mmap_open_pipe (void) { // try writing to an invalid file, we simply use a pipe here int pipefd[2]; if (pipe (pipefd) != 0) { yield_error ("pipe() error"); } char pipeFile[1024]; sprintf (pipeFile, "/dev/fd/%d", pipefd[1]); pipeFile[1023] = '\0'; Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, pipeFile, KEY_END); KeySet * conf = ksNew (0, KS_END); PLUGIN_OPEN ("mmapstorage"); KeySet * ks = simpleTestKeySet (); // truncate inside mmap plugin should fail here, since the pipe cannot be truncated succeed_if (plugin->kdbSet (plugin, ks, parentKey) == ELEKTRA_PLUGIN_STATUS_ERROR, "kdbSet did not detect error with the file"); keyDel (parentKey); ksDel (ks); PLUGIN_CLOSE (); }
void test_comment() { Key *key; char ret[10]; succeed_if (key = keyNew(0), "could not create new key"); succeed_if (strcmp (keyComment(key), "") == 0, "Empty comment problem"); succeed_if (keyGetCommentSize(key) == 1, "Empty comment size problem"); succeed_if (keyValue(keyGetMeta(key, "comment")) == 0, "No comment up to now"); succeed_if (keySetComment (key,0) == 1, "could not remove comment"); succeed_if (keyValue(keyGetMeta(key, "comment")) == 0, "There should be an no comment"); succeed_if (!strcmp (keyComment(key), ""), "Empty comment problem"); succeed_if (keyGetCommentSize(key) == 1, "Empty comment size problem"); succeed_if (keyGetComment(key, ret, 0) == -1, "Could not get empty comment"); succeed_if (keyGetComment(key, ret, 1) == 1, "Could not get empty comment"); succeed_if (ret[0] == 0, "keyGetComment did not return empty comment"); succeed_if (keySetComment (key,"") == 1, "could not remove comment"); succeed_if (keyValue(keyGetMeta(key, "comment")) == 0, "There should be an no comment"); succeed_if (!strcmp (keyComment(key), ""), "Empty comment problem"); succeed_if (keyGetCommentSize(key) == 1, "Empty comment size problem"); succeed_if (keyGetComment(key, ret, 0) == -1, "Could not get empty comment"); succeed_if (keyGetComment(key, ret, 1) == 1, "Could not get empty comment"); succeed_if (ret[0] == 0, "keyGetComment did not return empty comment"); succeed_if (keySetComment (key,"mycom") == sizeof("mycom"), "could not set comment"); succeed_if (!strcmp(keyValue(keyGetMeta(key, "comment")), "mycom"), "There should be my comment"); succeed_if (!strcmp (keyComment(key), "mycom"), "My comment problem"); succeed_if (keyGetCommentSize(key) == sizeof("mycom"), "My comment size problem"); succeed_if (keyGetComment(key, ret, 0) == -1, "Could not get my comment"); succeed_if (keyGetComment(key, ret, 1) == -1, "Could not get my comment"); succeed_if (keyGetComment(key, ret, sizeof("mycom")) == sizeof("mycom"), "Could not get my comment"); succeed_if (!strcmp (ret, "mycom"), "keyGetComment did not return my comment"); succeed_if (keyDel (key) == 0, "could not delete key"); }
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 (); }
void test_encode (void) { printf ("test encode\n"); CHexData * hd = calloc (1, sizeof (CHexData)); hd->hd['\0'] = 1; hd->hd['\n'] = 1; hd->hd['\\'] = 1; hd->hd[' '] = 1; hd->hd['='] = 1; hd->hd[';'] = 1; hd->hd['#'] = 1; hd->escape = '\\'; char buf[1000]; hd->buf = buf; Key * test = keyNew ("user/test", KEY_VALUE, decoded_string, KEY_END); elektraHexcodeEncode (test, hd); succeed_if (!memcmp (keyValue (test), encoded_string, sizeof (encoded_string) - 1), "string not correctly encoded"); elektraFree (hd); keyDel (test); }
static int elektraResolveEnvUser (resolverHandle * p) { const char * owner = getenv ("USER"); if (!owner || !strcmp (owner, "")) { return 0; } Key * canonify = keyNew ("user", KEY_END); keyAddName (canonify, owner); size_t dirnameSize = sizeof (KDB_DB_HOME "/") + keyGetNameSize (canonify) + sizeof ("/" KDB_DB_USER); p->dirname = elektraMalloc (dirnameSize); strcpy (p->dirname, KDB_DB_HOME "/"); strcat (p->dirname, keyName (canonify) + 5); // cut user/ if (p->path[0] != '/') { strcat (p->dirname, "/" KDB_DB_USER); } keyDel (canonify); return 1; }
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 int openStoragePlugin (const size_t storagePlugin) { modules[storagePlugin] = ksNew (0, KS_END); elektraModulesInit (modules[storagePlugin], 0); KeySet * conf = ksNew (0, KS_END); Key * errorKey = keyNew ("", KEY_END); Plugin * plugin = elektraPluginOpen (pluginNames[storagePlugin], modules[storagePlugin], conf, errorKey); const Key * metaWarnings = keyGetMeta (errorKey, "warnings"); if (metaWarnings) printf ("There are warnings for plugin: %s\n", pluginNames[storagePlugin]); const Key * metaError = keyGetMeta (errorKey, "error"); if (metaError) printf ("There are errors for plugin: %s\n", pluginNames[storagePlugin]); if (plugin == 0) { printf ("Could not open plugin: %s\n", pluginNames[storagePlugin]); return -1; } plugins[storagePlugin] = plugin; keyDel (errorKey); return 0; }
static void test_lookupDoubleIndirect () { printf ("Test lookup by double indirect spec\n"); Key * s; Key * p; Key * d; Key * u; Key * y; Key * se; Key * pe; KeySet * ks = ksNew (20, se = keyNew ("spec/first", KEY_END), pe = keyNew ("proc/first", KEY_END), s = keyNew ("spec/abc", KEY_END), p = keyNew ("proc/abc", KEY_END), d = keyNew ("dir/abc", KEY_END), u = keyNew ("user/abc", KEY_END), y = keyNew ("system/abc", KEY_END), KS_END); succeed_if (ksGetSize (ks) == 7, "wrong size"); Key * k = ksLookupByName (ks, "/first", 0); succeed_if (k == pe, "did not find proc key"); keySetMeta (se, "override/#0", "/abc"); k = ksLookupByName (ks, "/first", 0); succeed_if (k == p, "did not find proc/abc"); keySetMeta (s, "namespace/#0", "system"); k = ksLookupByName (ks, "/first", 0); succeed_if (k == y, "did not find system key"); keySetMeta (s, "namespace/#0", "system"); keySetMeta (s, "namespace/#1", "user"); k = ksLookupByName (ks, "/first", 0); succeed_if (k == y, "did not find system key"); keySetMeta (s, "namespace/#0", "proc"); keySetMeta (s, "namespace/#1", "user"); k = ksLookupByName (ks, "/first", 0); succeed_if (k == p, "did not find proc key"); keySetMeta (s, "override/#0", "proc/first"); k = ksLookupByName (ks, "/first", 0); succeed_if (k == pe, "did not find override key (double indirect)"); ksDel (ks); }
static KeySet * elektraNoresolverModules() { return ksNew (50, keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "", KEY_VALUE, "" ELEKTRA_PLUGIN_NAME " plugin waits for your orders", KEY_END), keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "/exports", KEY_END), keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "/exports/get", KEY_FUNC, elektraNoresolverGet, KEY_END), keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "/exports/set", KEY_FUNC, elektraNoresolverSet, KEY_END), keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "/exports/error", KEY_FUNC, elektraNoresolverError, KEY_END), keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "/exports/checkfile", KEY_FUNC, elektraNoresolverCheckFile, KEY_END), #include ELEKTRA_README(noresolver) keyNew ("system/elektra/modules/" ELEKTRA_PLUGIN_NAME "/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END); }
void test_config (void) { KeySet * config = ksNew (20, keyNew ("user/chars", KEY_END), keyNew ("user/chars/20", KEY_END), keyNew ("user/chars/23", KEY_END), keyNew ("user/chars/5C", KEY_END), keyNew ("user/chars/3D", KEY_END), keyNew ("user/chars/3B", KEY_END), KS_END); KeySet * returned = ksNew (20, keyNew ("user/something", KEY_VALUE, decoded_string, KEY_END), KS_END); Plugin * p = calloc (1, sizeof (Plugin)); p->config = config; elektraHexcodeOpen (p, 0); elektraHexcodeSet (p, returned, 0); Key * test = ksLookupByName (returned, "user/something", 0); succeed_if (!memcmp (keyValue (test), encoded_string, sizeof (encoded_string) - 1), "string not correctly encoded"); elektraHexcodeClose (p, 0); ksDel (returned); ksDel (p->config); elektraFree (p); }
static void testSetColnames (const char * file) { Key * parentKey = keyNew ("user/tests/csvstorage", KEY_VALUE, srcdir_file (file), KEY_END); KeySet * conf = ksNew (20, keyNew ("system/delimiter", KEY_VALUE, ";", KEY_END), keyNew ("system/header", KEY_VALUE, "colname", KEY_END), keyNew ("system/columns", KEY_VALUE, "2", KEY_END), keyNew ("system/columns/names", KEY_VALUE, "", KEY_END), keyNew ("system/columns/names/#0", KEY_VALUE, "col0Name", KEY_END), keyNew ("system/columns/names/#1", KEY_VALUE, "col1Name", KEY_END), KS_END); PLUGIN_OPEN ("csvstorage"); KeySet * ks = ksNew (0, KS_END); succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful"); Key * key; key = ksLookupByName (ks, "user/tests/csvstorage/#1/col0Name", 0); exit_if_fail (key, "key not found"); succeed_if (strcmp (keyString (key), "l1c1") == 0, "wrong key"); key = ksLookupByName (ks, "user/tests/csvstorage/#2/col1Name", 0); exit_if_fail (key, "key not found"); succeed_if (strcmp (keyString (key), "l2c2") == 0, "wrong key"); ksDel (ks); keyDel (parentKey); PLUGIN_CLOSE (); }
static void test_lookupNamespace () { printf ("Test lookup namespace\n"); Key * specKey = keyNew ("/abc", KEY_CASCADING_NAME, KEY_META, "namespace/#0", "system", KEY_END); Key * k = 0; KeySet * ks = ksNew (20, k = keyNew ("user/abc", KEY_END), KS_END); succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key of other namespace"); keySetMeta (specKey, "namespace/#0", "user"); succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key in correct namespace"); ksDel (ks); ks = ksNew (20, k = keyNew ("system/abc", KEY_END), KS_END); keySetMeta (specKey, "namespace/#0", "user"); succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == 0, "found wrong key of other namespace"); keySetMeta (specKey, "namespace/#0", "system"); succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "did not find key in correct namespace"); ksDel (ks); ks = ksNew (20, keyNew ("system/abc", KEY_END), k = keyNew ("user/abc", KEY_END), KS_END); keySetMeta (specKey, "namespace/#0", "user"); keySetMeta (specKey, "namespace/#1", "system"); succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "found wrong key of other namespace"); ksDel (ks); ks = ksNew (20, k = keyNew ("system/abc", KEY_END), keyNew ("user/abc", KEY_END), KS_END); keySetMeta (specKey, "namespace/#0", "system"); keySetMeta (specKey, "namespace/#1", "user"); succeed_if (ksLookup (ks, specKey, KDB_O_SPEC) == k, "found wrong key of other namespace"); ksDel (ks); keyDel (specKey); }
static void test_arrayInsert (char * source, char * compare) { Key * parentKey = keyNew ("user/tests/ini-write", KEY_VALUE, srcdir_file (source), KEY_END); Key * writeParentKey = keyNew ("user/tests/ini-write", KEY_VALUE, elektraFilename (), KEY_END); KeySet * conf = ksNew (10, keyNew ("system/array", KEY_VALUE, "1", KEY_END), KS_END); KeySet * ks = ksNew (30, KS_END); KeySet * appendKS = ksNew (10, keyNew ("user/tests/ini-write/a/section/array/#0", KEY_VALUE, "0", KEY_END), keyNew ("user/tests/ini-write/a/section/array/#1", KEY_VALUE, "1", KEY_END), keyNew ("user/tests/ini-write/a/section/array/#2", KEY_VALUE, "2", KEY_END), keyNew ("user/tests/ini-write/a/section/array/#3", KEY_VALUE, "3", KEY_END), KS_END); PLUGIN_OPEN ("ini"); succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 0, "call to kdbGet was not successful"); keyDel (ksLookup (ks, parentKey, KDB_O_POP)); keyDel (parentKey); ksAppend (ks, appendKS); succeed_if (plugin->kdbSet (plugin, ks, writeParentKey) >= 1, "call to kdbSet was not successful"); succeed_if (compare_line_files (srcdir_file (compare), keyString (writeParentKey)), "files do not match as expected"); keyDel (ksLookup (ks, writeParentKey, KDB_O_POP)); keyDel (writeParentKey); ksDel (appendKS); ksDel (ks); PLUGIN_CLOSE (); }
static void test_relative_generic () { printf ("Get relative name of key with generic mountpoint\n"); Key * parent = keyNew ("system/", KEY_END); Key * child = keyNew ("system/key/🔑/🗝", KEY_END); test_relative ("key/🔑/🗝", child, parent); keyDel (child); child = keyNew ("system/Käfer/K", KEY_END); test_relative ("Käfer/K", child, parent); keyDel (child); keyDel (parent); parent = keyNew ("user", KEY_END); child = keyNew ("user/K", KEY_END); test_relative ("K", child, parent); keyDel (child); child = keyNew ("user/KK\\/Kitchens/What/Were/You/Thinking?", KEY_END); test_relative ("KK\\/Kitchens/What/Were/You/Thinking?", child, parent); keyDel (child); keyDel (parent); }
static void test_relative_cascading () { printf ("Get relative name of key with cascading mountpoint\n"); Key * parent = keyNew ("/cascading", KEY_END); Key * child = keyNew ("/cascading/k", KEY_END); test_relative ("k", child, parent); keyDel (child); child = keyNew ("system/cascading/deep/deeper/deepest", KEY_END); test_relative ("deep/deeper/deepest", child, parent); keyDel (parent); keyDel (child); parent = keyNew ("/cascading\\/mountpoint/", KEY_END); child = keyNew ("user/cascading\\/mountpoint/\\/dot", KEY_END); test_relative ("\\/dot", child, parent); keyDel (child); child = keyNew ("user/second_level/cascading\\/mountpoint/\\/dot", KEY_END); test_relative ("\\/dot", child, parent); keyDel (child); keyDel (parent); }