http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/bundle_context.c ---------------------------------------------------------------------- diff --git a/framework/private/src/bundle_context.c b/framework/private/src/bundle_context.c index 8a52790..35d27ce 100644 --- a/framework/private/src/bundle_context.c +++ b/framework/private/src/bundle_context.c @@ -45,7 +45,6 @@ celix_status_t bundleContext_create(framework_pt framework, framework_logger_pt } else { context->framework = framework; context->bundle = bundle; - context->logger = logger; *bundle_context = context; }
http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/bundle_revision.c ---------------------------------------------------------------------- diff --git a/framework/private/src/bundle_revision.c b/framework/private/src/bundle_revision.c index c91976c..6c538f9 100644 --- a/framework/private/src/bundle_revision.c +++ b/framework/private/src/bundle_revision.c @@ -34,7 +34,7 @@ #include "archive.h" #include "celix_log.h" -celix_status_t bundleRevision_create(framework_logger_pt loggera, char *root, char *location, long revisionNr, char *inputFile, bundle_revision_pt *bundle_revision) { +celix_status_t bundleRevision_create(char *root, char *location, long revisionNr, char *inputFile, bundle_revision_pt *bundle_revision) { celix_status_t status = CELIX_SUCCESS; bundle_revision_pt revision = NULL; @@ -61,7 +61,6 @@ celix_status_t bundleRevision_create(framework_logger_pt loggera, char *root, ch revision->revisionNr = revisionNr; revision->root = strdup(root); revision->location = strdup(location); - revision->logger = loggera; *bundle_revision = revision; http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/celix_errorcodes.c ---------------------------------------------------------------------- diff --git a/framework/private/src/celix_errorcodes.c b/framework/private/src/celix_errorcodes.c index ac24c10..ec25cff 100644 --- a/framework/private/src/celix_errorcodes.c +++ b/framework/private/src/celix_errorcodes.c @@ -48,7 +48,7 @@ static char *celix_error_string(celix_status_t statcode) { case CELIX_SERVICE_EXCEPTION: return "Service exception"; } - return "Unkown code"; + return "Unknown code"; } char *celix_strerror(celix_status_t errorcode, char *buffer, size_t bufferSize) { http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/framework.c ---------------------------------------------------------------------- diff --git a/framework/private/src/framework.c b/framework/private/src/framework.c index 5ca35a5..47aabb3 100644 --- a/framework/private/src/framework.c +++ b/framework/private/src/framework.c @@ -234,7 +234,7 @@ celix_status_t framework_create(framework_pt *framework, properties_pt config) { (*framework)->logger = logger; - status = CELIX_DO_IF(status, bundle_create(&(*framework)->bundle, (*framework)->logger)); + status = CELIX_DO_IF(status, bundle_create(&(*framework)->bundle)); status = CELIX_DO_IF(status, arrayList_create(&(*framework)->globalLockWaitersList)); status = CELIX_DO_IF(status, bundle_setFramework((*framework)->bundle, (*framework))); if (status == CELIX_SUCCESS) { @@ -372,7 +372,7 @@ celix_status_t fw_init(framework_pt framework) { if (status == CELIX_SUCCESS) { if ((state == OSGI_FRAMEWORK_BUNDLE_INSTALLED) || (state == OSGI_FRAMEWORK_BUNDLE_RESOLVED)) { bundle_state_e state; - status = CELIX_DO_IF(status, bundleCache_create(framework->configurationMap, framework->logger, &framework->cache)); + status = CELIX_DO_IF(status, bundleCache_create(framework->configurationMap,&framework->cache)); status = CELIX_DO_IF(status, bundle_getState(framework->bundle, &state)); if (status == CELIX_SUCCESS) { if (state == OSGI_FRAMEWORK_BUNDLE_INSTALLED) { http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/module.c ---------------------------------------------------------------------- diff --git a/framework/private/src/module.c b/framework/private/src/module.c index 15d5c0e..17fea5c 100644 --- a/framework/private/src/module.c +++ b/framework/private/src/module.c @@ -258,6 +258,19 @@ void module_removeDependentImporter(module_pt module, module_pt importer) { arrayList_removeElement(module->dependentImporters, importer); } +//---------------------------------------------------- +//TODO add implementation (functions not implemented but already exported) +array_list_pt module_getDependentRequirers(module_pt module) { + return NULL; +} + +void module_addDependentRequirer(module_pt module, module_pt requirer) { +} + +void module_removeDependentRequirer(module_pt module, module_pt requirer) { +} +//---------------------------------------------------- + array_list_pt module_getDependents(module_pt module) { array_list_pt dependents = NULL; arrayList_create(&dependents); http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/service_tracker.c ---------------------------------------------------------------------- diff --git a/framework/private/src/service_tracker.c b/framework/private/src/service_tracker.c index 1221e0c..b81b4d0 100644 --- a/framework/private/src/service_tracker.c +++ b/framework/private/src/service_tracker.c @@ -200,7 +200,7 @@ void *serviceTracker_getServiceByReference(service_tracker_pt tracker, service_r tracked_pt tracked; unsigned int i; for (i = 0; i < arrayList_size(tracker->tracked); i++) { - bool equals; + bool equals = false; tracked = (tracked_pt) arrayList_get(tracker->tracked, i); serviceReference_equals(reference, tracked->reference, &equals); if (equals) { @@ -232,7 +232,7 @@ static celix_status_t serviceTracker_track(service_tracker_pt tracker, service_r int found = -1; unsigned int i; for (i = 0; i < arrayList_size(tracker->tracked); i++) { - bool equals; + bool equals = false; tracked = (tracked_pt) arrayList_get(tracker->tracked, i); serviceReference_equals(reference, tracked->reference, &equals); if (equals) { http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/src/version_range.c ---------------------------------------------------------------------- diff --git a/framework/private/src/version_range.c b/framework/private/src/version_range.c index 6f4b598..cc53691 100644 --- a/framework/private/src/version_range.c +++ b/framework/private/src/version_range.c @@ -135,7 +135,7 @@ celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range) { celix_status_t status; if (strchr(rangeStr, ',') != NULL) { int vlowL = strcspn(rangeStr+1, ","); - char * vlow = (char *) malloc(sizeof(*vlow * (vlowL + 1))); + char * vlow = (char *) malloc(sizeof(char) * (vlowL + 1)); if (!vlow) { status = CELIX_ENOMEM; } else { @@ -144,7 +144,7 @@ celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range) { vlow = strncpy(vlow, rangeStr+1, vlowL); vlow[vlowL] = '\0'; vhighL = strlen(rangeStr+1) - vlowL - 2; - vhigh = (char *) malloc(sizeof(*vhigh * (vhighL+1))); + vhigh = (char *) malloc(sizeof(char) * (vhighL+1)); if (!vhigh) { status = CELIX_ENOMEM; } else { @@ -169,7 +169,10 @@ celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range) { ); } } + free(vhigh); } + free(vlow); + } } else { version_pt version = NULL; http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/attribute_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/attribute_test.cpp b/framework/private/test/attribute_test.cpp index 5847c02..c378b3a 100644 --- a/framework/private/test/attribute_test.cpp +++ b/framework/private/test/attribute_test.cpp @@ -25,6 +25,7 @@ */ #include <stdlib.h> #include <stdio.h> +#include <string.h> #include "CppUTest/TestHarness.h" #include "CppUTest/TestHarness_c.h" @@ -35,17 +36,32 @@ extern "C" { #include "attribute_private.h" #include "celix_log.h" -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x42; } int main(int argc, char** argv) { return RUN_ALL_TESTS(argc, argv); } +static char* my_strdup(const char* s){ + if(s==NULL){ + return NULL; + } + + size_t len = strlen(s); + + char *d = (char*) calloc (len + 1,sizeof(char)); + + if (d == NULL){ + return NULL; + } + + strncpy (d,s,len); + return d; +} + TEST_GROUP(attribute) { void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; } void teardown() { @@ -55,13 +71,22 @@ TEST_GROUP(attribute) { }; TEST(attribute, create) { - char key[] = "key"; - char value[] = "value"; + char * key = (char*) my_strdup("key"); + char * value = (char*) my_strdup("value"); attribute_pt attribute = NULL; celix_status_t status = attribute_create(key, value, &attribute); STRCMP_EQUAL(key, attribute->key); STRCMP_EQUAL(value, attribute->value); + LONGS_EQUAL(CELIX_SUCCESS, status); + + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + status = attribute_create(NULL, NULL, NULL); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + + attribute_destroy(attribute); } TEST(attribute, getKey) { @@ -75,6 +100,8 @@ TEST(attribute, getKey) { char *actual = NULL; celix_status_t status = attribute_getKey(attribute, &actual); STRCMP_EQUAL(key, actual); + + free(attribute); } TEST(attribute, getValue) { @@ -88,4 +115,6 @@ TEST(attribute, getValue) { char *actual = NULL; celix_status_t status = attribute_getValue(attribute, &actual); STRCMP_EQUAL(value, actual); + + free(attribute); } http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/bundle_archive_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/bundle_archive_test.cpp b/framework/private/test/bundle_archive_test.cpp index e8f5f60..f5baa2d 100644 --- a/framework/private/test/bundle_archive_test.cpp +++ b/framework/private/test/bundle_archive_test.cpp @@ -25,6 +25,10 @@ */ #include <stdlib.h> #include <stdio.h> +#include <sys/stat.h> +#include <dirent.h> +#include <unistd.h> +#include <string.h> #include "CppUTest/TestHarness.h" #include "CppUTest/TestHarness_c.h" @@ -33,18 +37,100 @@ extern "C" { #include "bundle_archive.h" - -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x42; } int main(int argc, char** argv) { return RUN_ALL_TESTS(argc, argv); } +static char* my_strdup(const char* s) { + if (s == NULL) { + return NULL; + } + + size_t len = strlen(s); + + char *d = (char*) calloc(len + 1, sizeof(char)); + + if (d == NULL) { + return NULL; + } + + strncpy(d, s, len); + return d; +} + +static int remove_directory_recursive(const char *path) { + DIR *d = opendir(path); + size_t path_len = strlen(path); + int r = -1; + + if (d) { + struct dirent *p; + + r = 0; + + while (!r && (p = readdir(d))) { + int r2 = -1; + char *buf; + size_t len; + + /* Skip the names "." and ".." as we don't want to recurse on them. */ + if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, "..")) { + continue; + } + + len = path_len + strlen(p->d_name) + 2; + buf = (char*) malloc(len); + + if (buf) { + struct stat statbuf; + snprintf(buf, len, "%s/%s", path, p->d_name); + + if (!stat(buf, &statbuf)) { + if (S_ISDIR(statbuf.st_mode)) { + r2 = remove_directory_recursive(buf); + } else { + r2 = unlink(buf); + } + } + + free(buf); + } + r = r2; + } + closedir(d); + } + if (!r) { + r = rmdir(path); + } + return r; +} + +//----------------------TESTGROUP DEFINES---------------------- + TEST_GROUP(bundle_archive) { + bundle_archive_pt bundle_archive; + char * bundle_path; //uses the default build shell bundle + char * alternate_bundle_path;//alternative bundle, if shell bundle not found + char cache_path[512]; //a local cache folder + void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; + char cwd[512]; + bundle_archive = NULL; + bundle_path = (char*) "../shell/shell.zip"; //uses the default build shell bundle + alternate_bundle_path = (char*) "../log_service/log_service.zip"; //alternative bundle, if shell bundle not found + snprintf(cache_path, sizeof(cache_path), "%s/.cache", getcwd(cwd, sizeof(cwd))); //a local cache folder + struct stat file_stat; + + if (stat(bundle_path, &file_stat) < 0) { + if (stat(alternate_bundle_path, &file_stat) < 0) { + FAIL("failed to find needed test bundle"); + } else { + bundle_path = alternate_bundle_path; + } + } } void teardown() { @@ -53,6 +139,238 @@ TEST_GROUP(bundle_archive) { } }; +//----------------------TEST DEFINES---------------------- +//WARNING: if one test fails, it does not clean up properly, +//causing most if not all of the subsequent tests to also fail + +TEST(bundle_archive, create) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + bundle_archive = (bundle_archive_pt) 0x42; + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleArchive_create(cache_path, 5, bundle_path, NULL, &bundle_archive)); + + bundle_archive = NULL; + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 5, bundle_path, NULL, &bundle_archive)); + CHECK(bundle_archive != NULL); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, createSystemBundleArchive) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + bundle_archive = (bundle_archive_pt) 0x42; + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleArchive_createSystemBundleArchive(&bundle_archive )); + + bundle_archive = NULL; + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_createSystemBundleArchive(&bundle_archive)); + CHECK(bundle_archive != NULL); + + //LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, recreate) { + char * get_root; + char * get_location; + bundle_archive_pt recr_archive = NULL; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 5, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_recreate(cache_path, &recr_archive)); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getArchiveRoot(recr_archive, &get_root)); + STRCMP_EQUAL(cache_path, get_root); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getLocation(recr_archive, &get_location)); + STRCMP_EQUAL(bundle_path, get_location); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(recr_archive)); +} + +TEST(bundle_archive, getId) { + long get_id; + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, -42, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getId(bundle_archive, &get_id)); + LONGS_EQUAL(-42, get_id); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); + bundle_archive = NULL; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 666, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getId(bundle_archive, &get_id)); + LONGS_EQUAL(666, get_id); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, getLocation) { + char * get_loc; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getLocation(bundle_archive, &get_loc)); + STRCMP_EQUAL(bundle_path, get_loc); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} +TEST(bundle_archive, getArchiveRoot) { + char * get_root; + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getArchiveRoot(bundle_archive, &get_root)); + STRCMP_EQUAL(cache_path, get_root); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, getCurrentRevisionNumber) { + long get_rev_num; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getCurrentRevisionNumber(bundle_archive, &get_rev_num)); + LONGS_EQUAL(0, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_revise(bundle_archive, bundle_path, NULL)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getCurrentRevisionNumber(bundle_archive, + &get_rev_num)); + LONGS_EQUAL(1, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_revise(bundle_archive, bundle_path, NULL)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getCurrentRevisionNumber(bundle_archive, &get_rev_num)); + LONGS_EQUAL(2, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, getCurrentRevision) { + long get_rev_num; + bundle_revision_pt get_rev; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getCurrentRevision(bundle_archive, &get_rev)); + bundleRevision_getNumber(get_rev, &get_rev_num); + LONGS_EQUAL(0, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_revise(bundle_archive, bundle_path, NULL)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getCurrentRevision(bundle_archive, &get_rev)); + bundleRevision_getNumber(get_rev, &get_rev_num); + LONGS_EQUAL(1, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, getRevision) { + long get_rev_num; + bundle_revision_pt get_rev; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_revise(bundle_archive, bundle_path, NULL)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_revise(bundle_archive, bundle_path, NULL)); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getRevision(bundle_archive, 0, &get_rev)); + bundleRevision_getNumber(get_rev, &get_rev_num); + LONGS_EQUAL(0, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getRevision(bundle_archive, 2, &get_rev)); + bundleRevision_getNumber(get_rev, &get_rev_num); + LONGS_EQUAL(2, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getRevision(bundle_archive, 1, &get_rev)); + bundleRevision_getNumber(get_rev, &get_rev_num); + LONGS_EQUAL(1, get_rev_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, set_getPersistentState) { + bundle_state_e get; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setPersistentState(bundle_archive, OSGI_FRAMEWORK_BUNDLE_UNKNOWN)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getPersistentState(bundle_archive, &get)); + LONGS_EQUAL(OSGI_FRAMEWORK_BUNDLE_INSTALLED, get); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setPersistentState(bundle_archive, OSGI_FRAMEWORK_BUNDLE_ACTIVE)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getPersistentState(bundle_archive, &get)); + LONGS_EQUAL(OSGI_FRAMEWORK_BUNDLE_ACTIVE, get); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setPersistentState(bundle_archive, OSGI_FRAMEWORK_BUNDLE_STARTING)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getPersistentState(bundle_archive, &get)); + LONGS_EQUAL(OSGI_FRAMEWORK_BUNDLE_STARTING, get); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setPersistentState(bundle_archive, OSGI_FRAMEWORK_BUNDLE_UNINSTALLED)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getPersistentState(bundle_archive, &get)); + LONGS_EQUAL(OSGI_FRAMEWORK_BUNDLE_UNINSTALLED, get); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, set_getRefreshCount) { + long get_refresh_num; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getRefreshCount(bundle_archive, &get_refresh_num)); + LONGS_EQUAL(0, get_refresh_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setRefreshCount(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getRefreshCount(bundle_archive, &get_refresh_num)); + LONGS_EQUAL(0, get_refresh_num); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +TEST(bundle_archive, get_setLastModified) { + time_t set_time; + time_t get_time; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + + time(&set_time); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setLastModified(bundle_archive, set_time)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getLastModified(bundle_archive, &get_time)); + CHECK(set_time == get_time); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +} + +//CANT seem to find a way to test this static function +/*TEST(bundle_archive, readLastModified) { + mock().expectOneCall("framework_logCode"); + + time_t set_time; + time_t get_time; + bundle_archive_pt recr_archive = NULL; + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_create(cache_path, 1, bundle_path, NULL, &bundle_archive)); + + time(&set_time); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_setLastModified(bundle_archive, set_time)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_recreate(cache_path, &recr_archive)); + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_getLastModified(recr_archive, &get_time)); + LONGS_EQUAL(set_time, get_time); + + LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_closeAndDelete(bundle_archive)); + //LONGS_EQUAL(CELIX_SUCCESS, bundleArchive_destroy(bundle_archive)); +}*/ + +TEST(bundle_archive, rollbackRevise) { + bool get; + bundleArchive_rollbackRevise(NULL, &get); + + LONGS_EQUAL(true, get); + +} http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/bundle_cache_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/bundle_cache_test.cpp b/framework/private/test/bundle_cache_test.cpp index 9043727..71174fe 100644 --- a/framework/private/test/bundle_cache_test.cpp +++ b/framework/private/test/bundle_cache_test.cpp @@ -26,6 +26,7 @@ #include <stdlib.h> #include <stdio.h> #include <sys/stat.h> +#include <string.h> #include <unistd.h> #include "CppUTest/TestHarness.h" @@ -37,17 +38,32 @@ extern "C" { #include "bundle_cache_private.h" #include "celix_log.h" -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x42; } int main(int argc, char** argv) { return RUN_ALL_TESTS(argc, argv); } +static char* my_strdup(const char* s) { + if (s == NULL) { + return NULL; + } + + size_t len = strlen(s); + + char *d = (char*) calloc(len + 1, sizeof(char)); + + if (d == NULL) { + return NULL; + } + + strncpy(d, s, len); + return d; +} + TEST_GROUP(bundle_cache) { void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; } void teardown() { @@ -65,23 +81,23 @@ TEST(bundle_cache, create) { .andReturnValue((char *) NULL); bundle_cache_pt cache = NULL; - celix_status_t status = bundleCache_create(configuration, logger, &cache); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleCache_create(configuration, &cache)); + + LONGS_EQUAL(CELIX_SUCCESS, bundleCache_destroy(&cache)); } TEST(bundle_cache, deleteTree) { bundle_cache_pt cache = (bundle_cache_pt) malloc(sizeof(*cache)); char cacheDir[] = "bundle_cache_test_directory"; - char cacheFile[] = "bundle_cache_test_directory/temp"; + char cacheDir2[] = "bundle_cache_test_directory/testdir"; + char cacheFile[] = "bundle_cache_test_directory/tempXXXXXX"; cache->cacheDir = cacheDir; mkdir(cacheDir, S_IRWXU); + mkdir(cacheDir2, S_IRWXU); mktemp(cacheFile); - celix_status_t status = bundleCache_delete(cache); - - LONGS_EQUAL(CELIX_SUCCESS, status); - + LONGS_EQUAL(CELIX_SUCCESS, bundleCache_delete(cache)); } TEST(bundle_cache, getArchive) { @@ -102,9 +118,8 @@ TEST(bundle_cache, getArchive) { .andReturnValue(CELIX_SUCCESS); array_list_pt archives = NULL; - celix_status_t status = bundleCache_getArchives(cache, &archives); + LONGS_EQUAL(CELIX_SUCCESS, bundleCache_getArchives(cache, &archives)); - LONGS_EQUAL(CELIX_SUCCESS, status); CHECK(archives); LONGS_EQUAL(1, arrayList_size(archives)); POINTERS_EQUAL(archive, arrayList_get(archives, 0)); @@ -112,6 +127,9 @@ TEST(bundle_cache, getArchive) { rmdir(bundle0); rmdir(bundle1); rmdir(cacheDir); + + LONGS_EQUAL(CELIX_SUCCESS, bundleCache_getArchives(cache, &archives)); + rmdir(cacheDir); } TEST(bundle_cache, createArchive) { @@ -124,7 +142,6 @@ TEST(bundle_cache, createArchive) { char location[] = "test.zip"; bundle_archive_pt archive = (bundle_archive_pt) 0x10; mock().expectOneCall("bundleArchive_create") - .withParameter("logger", (void *) NULL) .withParameter("archiveRoot", archiveRoot) .withParameter("id", id) .withParameter("location", location) http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/bundle_context_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/bundle_context_test.cpp b/framework/private/test/bundle_context_test.cpp index db2792d..fcd6dfa 100644 --- a/framework/private/test/bundle_context_test.cpp +++ b/framework/private/test/bundle_context_test.cpp @@ -35,7 +35,7 @@ extern "C" { #include "bundle_context_private.h" #include "celix_log.h" -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x42; } int main(int argc, char** argv) { @@ -44,8 +44,6 @@ int main(int argc, char** argv) { TEST_GROUP(bundle_context) { void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; } void teardown() { @@ -55,17 +53,21 @@ TEST_GROUP(bundle_context) { }; TEST(bundle_context, create) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + framework_pt framework = (framework_pt) 0x10; - bundle_pt bundle = (bundle_pt) 0x20; + bundle_pt bundle = (bundle_pt) 0x20; - bundle_context_pt context = NULL; - bundleContext_create(framework, logger, bundle, &context); - POINTERS_EQUAL(framework, context->framework) - POINTERS_EQUAL(bundle, context->bundle) -// CHECK(context->pool); + bundle_context_pt context = NULL; + bundleContext_create(framework, logger, bundle, &context); + POINTERS_EQUAL(framework, context->framework) + POINTERS_EQUAL(bundle, context->bundle) + + bundleContext_create(NULL, logger, NULL, &context); } TEST(bundle_context, destroy) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -80,41 +82,43 @@ TEST(bundle_context, destroy) { } TEST(bundle_context, getBundle) { - bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); - framework_pt framework = (framework_pt) 0x10; - bundle_pt bundle = (bundle_pt) 0x20; - context->framework = framework; - context->bundle = bundle; - - celix_status_t status; - bundle_pt actualBundle = NULL; + mock().expectNCalls(2, "framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); + framework_pt framework = (framework_pt) 0x10; + bundle_pt bundle = (bundle_pt) 0x20; + context->framework = framework; + context->bundle = bundle; + + celix_status_t status; + bundle_pt actualBundle = NULL; status = bundleContext_getBundle(context, &actualBundle); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(bundle, actualBundle); framework_pt actualFramework = NULL; status = bundleContext_getFramework(context, &actualFramework); - LONGS_EQUAL(CELIX_SUCCESS, status); - POINTERS_EQUAL(framework, actualFramework); + LONGS_EQUAL(CELIX_SUCCESS, status); + POINTERS_EQUAL(framework, actualFramework); - actualBundle = NULL; - status = bundleContext_getBundle(NULL, &actualBundle); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + actualBundle = NULL; + status = bundleContext_getBundle(NULL, &actualBundle); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); - actualFramework = NULL; - status = bundleContext_getFramework(NULL, &actualFramework); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + actualFramework = NULL; + status = bundleContext_getFramework(NULL, &actualFramework); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); } TEST(bundle_context, installBundle) { - bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); - framework_pt framework = (framework_pt) 0x10; - bundle_pt bundle = (bundle_pt) 0x20; - context->framework = framework; - context->bundle = bundle; - - char location[] = "test.zip"; - bundle_pt installedBundle = (bundle_pt) 0x40; + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); + framework_pt framework = (framework_pt) 0x10; + bundle_pt bundle = (bundle_pt) 0x20; + context->framework = framework; + context->bundle = bundle; + + char location[] = "test.zip"; + bundle_pt installedBundle = (bundle_pt) 0x40; mock().expectOneCall("fw_installBundle") .withParameter("framework", framework) .withParameter("location", location) @@ -129,6 +133,8 @@ TEST(bundle_context, installBundle) { } TEST(bundle_context, installBundle2) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -156,6 +162,8 @@ TEST(bundle_context, installBundle2) { } TEST(bundle_context, registerService) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -187,6 +195,8 @@ TEST(bundle_context, registerService) { } TEST(bundle_context, registerServiceFactory) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -218,6 +228,8 @@ TEST(bundle_context, registerServiceFactory) { } TEST(bundle_context, getServiceReferences) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -247,6 +259,8 @@ TEST(bundle_context, getServiceReferences) { } TEST(bundle_context, getServiceReference) { + mock().expectNCalls(3, "framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -268,16 +282,38 @@ TEST(bundle_context, getServiceReference) { .andReturnValue(CELIX_SUCCESS); service_reference_pt actualReference = NULL; - celix_status_t status = bundleContext_getServiceReference(context, serviceName, &actualReference); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleContext_getServiceReference(context, serviceName, &actualReference)); POINTERS_EQUAL(reference, actualReference); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleContext_getServiceReference(NULL, serviceName, &actualReference)); actualReference = NULL; - status = bundleContext_getServiceReference(context, NULL, &actualReference); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleContext_getServiceReference(context, NULL, &actualReference)); +} + +TEST(bundle_context, ungetServiceReference) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); + framework_pt framework = (framework_pt) 0x10; + bundle_pt bundle = (bundle_pt) 0x20; + context->framework = framework; + context->bundle = bundle; + service_reference_pt reference = (service_reference_pt) 0x30; + + mock().expectOneCall("framework_ungetServiceReference") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("reference", reference); + + service_reference_pt actualReference = NULL; + LONGS_EQUAL(CELIX_SUCCESS, bundleContext_ungetServiceReference(context, reference)); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleContext_ungetServiceReference(context, NULL)); } TEST(bundle_context, getService) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -306,6 +342,8 @@ TEST(bundle_context, getService) { } TEST(bundle_context, ungetService) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -334,6 +372,8 @@ TEST(bundle_context, ungetService) { } TEST(bundle_context, getBundles) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -357,6 +397,8 @@ TEST(bundle_context, getBundles) { } TEST(bundle_context, getBundleById) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -382,6 +424,8 @@ TEST(bundle_context, getBundleById) { } TEST(bundle_context, addServiceListener) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -407,6 +451,8 @@ TEST(bundle_context, addServiceListener) { } TEST(bundle_context, removeServiceListener) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -430,6 +476,8 @@ TEST(bundle_context, removeServiceListener) { } TEST(bundle_context, addBundleListener) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -453,6 +501,8 @@ TEST(bundle_context, addBundleListener) { } TEST(bundle_context, removeBundleListener) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; @@ -475,7 +525,49 @@ TEST(bundle_context, removeBundleListener) { LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); } +TEST(bundle_context, addFrameworkListener){ + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); + framework_pt framework = (framework_pt) 0x10; + bundle_pt bundle = (bundle_pt) 0x20; + context->framework = framework; + context->bundle = bundle; + framework_listener_pt listener = (framework_listener_pt) 0x30; + + mock().expectOneCall("fw_addframeworkListener") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("listener", listener); + + LONGS_EQUAL(CELIX_SUCCESS, bundleContext_addFrameworkListener(context, listener)); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleContext_addFrameworkListener(context, NULL)); +} + +TEST(bundle_context, removeFrameworkListener){ + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); + framework_pt framework = (framework_pt) 0x10; + bundle_pt bundle = (bundle_pt) 0x20; + context->framework = framework; + context->bundle = bundle; + framework_listener_pt listener = (framework_listener_pt) 0x30; + + mock().expectOneCall("fw_removeframeworkListener") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("listener", listener); + + LONGS_EQUAL(CELIX_SUCCESS, bundleContext_removeFrameworkListener(context, listener)); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleContext_removeFrameworkListener(context, NULL)); +} + TEST(bundle_context, getProperty) { + mock().expectOneCall("framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_context_pt context = (bundle_context_pt) malloc(sizeof(*context)); framework_pt framework = (framework_pt) 0x10; bundle_pt bundle = (bundle_pt) 0x20; http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/bundle_revision_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/bundle_revision_test.cpp b/framework/private/test/bundle_revision_test.cpp index a71b8df..c9fb567 100644 --- a/framework/private/test/bundle_revision_test.cpp +++ b/framework/private/test/bundle_revision_test.cpp @@ -35,7 +35,7 @@ extern "C" { #include "bundle_revision_private.h" #include "celix_log.h" -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x10; } int main(int argc, char** argv) { @@ -44,8 +44,6 @@ int main(int argc, char** argv) { TEST_GROUP(bundle_revision) { void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; } void teardown() { @@ -71,11 +69,13 @@ TEST(bundle_revision, create) { .andReturnValue(CELIX_SUCCESS); bundle_revision_pt revision = NULL; - celix_status_t status = bundleRevision_create(logger, root, location, revisionNr, inputFile, &revision); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_create(root, location, revisionNr, inputFile, &revision)); LONGS_EQUAL(revisionNr, revision->revisionNr); STRCMP_EQUAL(root, revision->root); STRCMP_EQUAL(location, revision->location); + + mock().expectOneCall("manifest_destroy"); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_destroy(revision)); } TEST(bundle_revision, createWithInput) { @@ -96,55 +96,62 @@ TEST(bundle_revision, createWithInput) { .andReturnValue(CELIX_SUCCESS); bundle_revision_pt revision = NULL; - celix_status_t status = bundleRevision_create(logger, root, location, revisionNr, inputFile, &revision); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_create(root, location, revisionNr, inputFile, &revision)); LONGS_EQUAL(revisionNr, revision->revisionNr); STRCMP_EQUAL(root, revision->root); STRCMP_EQUAL(location, revision->location); + + mock().expectOneCall("manifest_destroy"); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_destroy(revision)); } TEST(bundle_revision, getters) { + mock().expectNCalls(5, "framework_logCode").withParameter("code", CELIX_ILLEGAL_ARGUMENT); + bundle_revision_pt revision = (bundle_revision_pt) malloc(sizeof(*revision)); char root[] = "bundle_revision_test"; char location[] = "test_bundle.zip"; long revisionNr = 1l; - manifest_pt expected = (manifest_pt) 0x42; + manifest_pt expectedManifest = (manifest_pt) 0x42; + array_list_pt handles = NULL; + arrayList_create(&handles); revision->root = root; revision->location = location; revision->revisionNr = revisionNr; - revision->manifest = expected; + revision->manifest = expectedManifest; + revision->libraryHandles = handles; char *actualRoot = NULL; char *actualLocation = NULL; long actualRevisionNr = 0l; manifest_pt actualManifest = NULL; - celix_status_t status = CELIX_SUCCESS; + array_list_pt actualHandles = NULL; - status = bundleRevision_getNumber(revision, &actualRevisionNr); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_getNumber(revision, &actualRevisionNr)); LONGS_EQUAL(revisionNr, actualRevisionNr); - status = bundleRevision_getLocation(revision, &actualLocation); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_getLocation(revision, &actualLocation)); STRCMP_EQUAL(location, actualLocation); - status = bundleRevision_getRoot(revision, &actualRoot); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_getRoot(revision, &actualRoot)); STRCMP_EQUAL(root, actualRoot); - status = bundleRevision_getManifest(revision, &actualManifest); - LONGS_EQUAL(CELIX_SUCCESS, status); - POINTERS_EQUAL(expected, actualManifest); + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_getManifest(revision, &actualManifest)); + POINTERS_EQUAL(expectedManifest, actualManifest); + + LONGS_EQUAL(CELIX_SUCCESS, bundleRevision_getHandles(revision, &actualHandles)); + POINTERS_EQUAL(handles, actualHandles); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleRevision_getNumber(NULL, &actualRevisionNr)); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleRevision_getLocation(NULL, &actualLocation)); - status = bundleRevision_getNumber(NULL, &actualRevisionNr); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleRevision_getRoot(NULL, &actualRoot)); - status = bundleRevision_getLocation(NULL, &actualLocation); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleRevision_getManifest(NULL, &actualManifest)); - status = bundleRevision_getRoot(NULL, &actualRoot); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundleRevision_getHandles(NULL, &actualHandles)); - status = bundleRevision_getManifest(NULL, &actualManifest); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + arrayList_destroy(handles); + free(revision); } http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/bundle_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/bundle_test.cpp b/framework/private/test/bundle_test.cpp index 58608ec..29fe5e8 100644 --- a/framework/private/test/bundle_test.cpp +++ b/framework/private/test/bundle_test.cpp @@ -30,12 +30,15 @@ #include "CppUTest/TestHarness_c.h" #include "CppUTest/CommandLineTestRunner.h" #include "CppUTestExt/MockSupport.h" +#include "string.h" extern "C" { +#include "bundle_revision_private.h" #include "bundle_private.h" +#include "utils.h" #include "celix_log.h" -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x42; } int main(int argc, char** argv) { @@ -44,35 +47,48 @@ int main(int argc, char** argv) { TEST_GROUP(bundle) { void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; } - void teardown() { + void teardown(void) { mock().checkExpectations(); mock().clear(); } }; +static char* my_strdup(const char* s) { + if (s == NULL) { + return NULL; + } + + size_t len = strlen(s); + + char *d = (char*) calloc(len + 1, sizeof(char)); + + if (d == NULL) { + return NULL; + } + + strncpy(d, s, len); + return d; +} + + TEST(bundle, create) { bundle_archive_pt archive = (bundle_archive_pt) 0x10; mock().expectOneCall("bundleArchive_createSystemBundleArchive") - .withParameter("logger", logger) - .withOutputParameterReturning("bundle_archive", &archive, sizeof(archive)) - .andReturnValue(CELIX_SUCCESS); + .withOutputParameterReturning("bundle_archive", &archive, sizeof(archive)) + .andReturnValue(CELIX_SUCCESS); module_pt module = (module_pt) 0x20; mock().expectOneCall("module_createFrameworkModule") - .ignoreOtherParameters() - .andReturnValue(module); + .ignoreOtherParameters() + .andReturnValue(module); mock().expectOneCall("resolver_addModule") - .withParameter("module", module); - mock().expectOneCall("resolver_addModule") - .withParameter("module", module); + .withParameter("module", module); bundle_pt actual = NULL; - celix_status_t status = bundle_create(&actual, logger); + celix_status_t status = bundle_create(&actual); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(NULL, actual->context); POINTERS_EQUAL(NULL, actual->activator); @@ -81,10 +97,13 @@ TEST(bundle, create) { POINTERS_EQUAL(archive, actual->archive); CHECK(actual->modules); POINTERS_EQUAL(NULL, actual->manifest); -// CHECK(actual->lock) + // CHECK(actual->lock) LONGS_EQUAL(0, actual->lockCount); POINTERS_EQUAL(NULL, actual->lockThread.thread); POINTERS_EQUAL(NULL, actual->framework); + + mock().expectOneCall("module_destroy"); + bundle_destroy(actual); } TEST(bundle, createFromArchive) { @@ -94,52 +113,48 @@ TEST(bundle, createFromArchive) { manifest_pt manifest = (manifest_pt) 0x30; mock().expectOneCall("bundleArchive_getCurrentRevision") - .withParameter("archive", archive) - .withOutputParameterReturning("revision", &revision, sizeof(revision)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withOutputParameterReturning("revision", &revision, sizeof(revision)) + .andReturnValue(CELIX_SUCCESS); mock().expectOneCall("bundleRevision_getManifest") - .withParameter("revision", revision) - .withOutputParameterReturning("manifest", &manifest, sizeof(manifest)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("revision", revision) + .withOutputParameterReturning("manifest", &manifest, sizeof(manifest)) + .andReturnValue(CELIX_SUCCESS); - // CPPUTest has no build in support for longs, which breaks this test. long id = 1; mock().expectOneCall("bundleArchive_getId") - .withParameter("archive", archive) - .withOutputParameterReturning("id", &id, sizeof(id)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); module_pt module = (module_pt) 0x40; mock().expectOneCall("module_create") - .withParameter("headerMap", manifest) -// .withParameter("moduleId", "1.0") -// .withParameter("bundle", (void *) 0x40) - .ignoreOtherParameters() - .andReturnValue(module); + .withParameter("headerMap", manifest) + // .withParameter("moduleId", "1.0") + // .withParameter("bundle", (void *) 0x40) + .ignoreOtherParameters() + .andReturnValue(module); version_pt version = (version_pt) 0x50; mock().expectOneCall("module_getVersion") - .withParameter("module", module) - .andReturnValue(version); + .withParameter("module", module) + .andReturnValue(version); char symbolicName[] = "name"; mock().expectOneCall("module_getSymbolicName") - .withParameter("module", module) - .withOutputParameterReturning("symbolicName", &symbolicName, sizeof(symbolicName)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("module", module) + .withOutputParameterReturning("symbolicName", &symbolicName, sizeof(symbolicName)) + .andReturnValue(CELIX_SUCCESS); array_list_pt bundles = NULL; arrayList_create(&bundles); mock().expectOneCall("framework_getBundles") - .withParameter("framework", framework) - .andReturnValue(bundles); - - mock().expectOneCall("resolver_addModule") - .withParameter("module", module); + .withParameter("framework", framework) + .andReturnValue(bundles); mock().expectOneCall("resolver_addModule") - .withParameter("module", module); + .withParameter("module", module); bundle_pt actual = NULL; celix_status_t status = bundle_createFromArchive(&actual, framework, archive); @@ -151,10 +166,16 @@ TEST(bundle, createFromArchive) { POINTERS_EQUAL(archive, actual->archive); CHECK(actual->modules); POINTERS_EQUAL(NULL, actual->manifest); -// CHECK(actual->lock) + // CHECK(actual->lock) LONGS_EQUAL(0, actual->lockCount); POINTERS_EQUAL(NULL, actual->lockThread.thread); POINTERS_EQUAL(framework, actual->framework); + + arrayList_destroy(actual->modules); + free(actual); + + + mock().clear(); } TEST(bundle, getArchive) { @@ -163,13 +184,19 @@ TEST(bundle, getArchive) { bundle->archive = archive; bundle_archive_pt actual = NULL; - celix_status_t status = bundle_getArchive(bundle, &actual); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundle_getArchive(bundle, &actual)); POINTERS_EQUAL(archive, actual); + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + actual = NULL; - status = bundle_getArchive(NULL, &actual); - LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundle_getArchive(NULL, &actual)); + + free(bundle); + + + mock().clear(); } TEST(bundle, getCurrentModule) { @@ -192,6 +219,9 @@ TEST(bundle, getCurrentModule) { actual = NULL; status = bundle_getCurrentModule(NULL, &actual); LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); + + arrayList_destroy(bundle->modules); + free(bundle); } TEST(bundle, getModules) { @@ -201,6 +231,8 @@ TEST(bundle, getModules) { array_list_pt actual = bundle_getModules(bundle); POINTERS_EQUAL(modules, actual); + + free(bundle); } TEST(bundle, getHandle) { @@ -210,6 +242,8 @@ TEST(bundle, getHandle) { void *actual = bundle_getHandle(bundle); POINTERS_EQUAL(expected, actual); + + free(bundle); } TEST(bundle, setHandle) { @@ -218,6 +252,8 @@ TEST(bundle, setHandle) { bundle_setHandle(bundle, expected); POINTERS_EQUAL(expected, bundle->handle); + + free(bundle); } TEST(bundle, getActivator) { @@ -227,6 +263,8 @@ TEST(bundle, getActivator) { activator_pt actual = bundle_getActivator(bundle); POINTERS_EQUAL(expected, actual); + + free(bundle); } TEST(bundle, setActivator) { @@ -236,6 +274,8 @@ TEST(bundle, setActivator) { celix_status_t status = bundle_setActivator(bundle, expected); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(expected, bundle->activator); + + free(bundle); } TEST(bundle, getContext) { @@ -247,6 +287,8 @@ TEST(bundle, getContext) { celix_status_t status = bundle_getContext(bundle, &actual); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(expected, actual); + + free(bundle); } TEST(bundle, setContext) { @@ -256,6 +298,8 @@ TEST(bundle, setContext) { celix_status_t status = bundle_setContext(bundle, expected); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(expected, bundle->context); + + free(bundle); } TEST(bundle, getEntry) { @@ -266,16 +310,18 @@ TEST(bundle, getEntry) { char name[] = "name"; char *expected = (char *) 0x20; mock().expectOneCall("framework_getBundleEntry") - .withParameter("framework", framework) - .withParameter("bundle", bundle) - .withParameter("name", name) - .withOutputParameterReturning("entry", &expected, sizeof(expected)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("name", name) + .withOutputParameterReturning("entry", &expected, sizeof(expected)) + .andReturnValue(CELIX_SUCCESS); char *actual = NULL; celix_status_t status = bundle_getEntry(bundle, name, &actual); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(expected, actual); + + free(bundle); } TEST(bundle, getState) { @@ -283,9 +329,14 @@ TEST(bundle, getState) { bundle->state = OSGI_FRAMEWORK_BUNDLE_ACTIVE; bundle_state_e actual = OSGI_FRAMEWORK_BUNDLE_UNKNOWN; - celix_status_t status = bundle_getState(bundle, &actual); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundle_getState(bundle, &actual)); POINTERS_EQUAL(OSGI_FRAMEWORK_BUNDLE_ACTIVE, actual); + + //get unknown bundle's state + LONGS_EQUAL(CELIX_BUNDLE_EXCEPTION, bundle_getState((bundle_pt)NULL, &actual)); + POINTERS_EQUAL(OSGI_FRAMEWORK_BUNDLE_UNKNOWN, actual); + + free(bundle); } TEST(bundle, setState) { @@ -295,8 +346,115 @@ TEST(bundle, setState) { celix_status_t status = bundle_setState(bundle, OSGI_FRAMEWORK_BUNDLE_INSTALLED); LONGS_EQUAL(CELIX_SUCCESS, status); POINTERS_EQUAL(OSGI_FRAMEWORK_BUNDLE_INSTALLED, bundle->state); + + free(bundle); } +/*//declared here, since its non-static, but not actually exported by bundle.h or bundle_private.h +extern celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module); + +TEST(bundle, createModule){ + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + + module_pt module = (module_pt) 0x01; + module_pt module2 = (module_pt) 0x02; + module_pt module3 = (module_pt) 0x03; + arrayList_create(&bundle->modules); + arrayList_add(bundle->modules, module); + arrayList_add(bundle->modules, module2); + arrayList_add(bundle->modules, module3); + + framework_pt framework = (framework_pt) 0x04; + bundle->framework = framework; + + bundle_archive_pt archive = (bundle_archive_pt) 0x05; + bundle->archive = archive; + + module_pt module_new = (module_pt) 0x06; + bundle_revision_pt revision = (bundle_revision_pt) 0x07; + version_pt version = (version_pt) 0x08; + manifest_pt manifest = (manifest_pt) 0x09; + + long id = 666; + char * symbolicName = my_strdup("name"); + + bundle_pt bundle2 = (bundle_pt) malloc(sizeof(*bundle)); + module_pt module4 = (module_pt) 0x0A; + arrayList_create(&bundle2->modules); + arrayList_add(bundle2->modules, module4); + bundle2->framework = framework; + + bundle_archive_pt archive2 = (bundle_archive_pt) 0x0B; + bundle2->archive = archive2; + + version_pt version2 = (version_pt) 0x0C; + long id2 = 667; + + array_list_pt bundles; + arrayList_create(&bundles); + arrayList_add(bundles, bundle2); + + //expected calls from bundle_createModule + mock().expectOneCall("bundleArchive_getCurrentRevision") + .withParameter("archive", archive) + .withOutputParameterReturning("revision", &revision, sizeof(revision)); + + mock().expectOneCall("bundleRevision_getManifest") + .withParameter("revision", revision) + .withOutputParameterReturning("manifest", &manifest, sizeof(manifest)); + + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)); + + mock().expectOneCall("module_create") + .withParameter("headerMap", manifest) + .withParameter("moduleId", "666.0") + .withParameter("bundle", bundle) + .andReturnValue(module_new); + + mock().expectOneCall("module_getVersion") + .withParameter("module", module_new) + .andReturnValue(version); + + mock().expectOneCall("module_getSymbolicName") + .withParameter("module", module_new) + .withOutputParameterReturning("symbolicName", &symbolicName, sizeof(char*)); + + mock().expectOneCall("framework_getBundles") + .withParameter("framework", framework) + .andReturnValue(bundles); + + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", archive2) + .withOutputParameterReturning("id", &id2, sizeof(id2)); + + //returning same symbolic name for module_new as for module4 + mock().expectOneCall("module_getSymbolicName") + .withParameter("module", module4) + .withOutputParameterReturning("symbolicName", &symbolicName, sizeof(char*)); + + //returning different version for module_new as for module4 + mock().expectOneCall("module_getVersion") + .withParameter("module", module4) + .andReturnValue(version2); + + int result = 1; //1 means not equal + mock().expectOneCall("version_compareTo") + .withParameter("version", version) + .withParameter("compare", version2) + .withOutputParameterReturning("result", &result,sizeof(result)); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_createModule(bundle, &module_new)); + + arrayList_destroy(bundle->modules); + arrayList_destroy(bundle2->modules); + + free(bundle); + free(bundle2); + free(symbolicName); +}*/ + TEST(bundle, start) { bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); framework_pt framework = (framework_pt) 0x10; @@ -307,19 +465,30 @@ TEST(bundle, start) { int options = 42; long id = 1; - mock().expectOneCall("bundleArchive_getId") - .withParameter("archive", archive) - .withOutputParameterReturning("id", &id, sizeof(id)) - .andReturnValue(CELIX_SUCCESS); + mock().expectNCalls(2, "bundleArchive_getId") + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); mock().expectOneCall("fw_startBundle") - .withParameter("framework", framework) - .withParameter("bundle", bundle) - .withParameter("options", options) - .andReturnValue(CELIX_SUCCESS); + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("options", options) + .andReturnValue(CELIX_SUCCESS); celix_status_t status = bundle_startWithOptions(bundle, options); LONGS_EQUAL(CELIX_SUCCESS, status); + + mock().expectOneCall("fw_startBundle") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("options", 0) + .andReturnValue(CELIX_SUCCESS); + + status = bundle_start(bundle); + LONGS_EQUAL(CELIX_SUCCESS, status); + + free(bundle); } TEST(bundle, update) { @@ -331,19 +500,21 @@ TEST(bundle, update) { long id = 1; mock().expectOneCall("bundleArchive_getId") - .withParameter("archive", archive) - .withOutputParameterReturning("id", &id, sizeof(id)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); char input[] = "input"; mock().expectOneCall("framework_updateBundle") - .withParameter("framework", framework) - .withParameter("bundle", bundle) - .withParameter("inputFile", input) - .andReturnValue(CELIX_SUCCESS); + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("inputFile", input) + .andReturnValue(CELIX_SUCCESS); celix_status_t status = bundle_update(bundle, input); LONGS_EQUAL(CELIX_SUCCESS, status); + + free(bundle); } TEST(bundle, stop) { @@ -354,43 +525,67 @@ TEST(bundle, stop) { bundle->archive = archive; long id = 1; - mock().expectOneCall("bundleArchive_getId") - .withParameter("archive", archive) - .withOutputParameterReturning("id", &id, sizeof(id)) - .andReturnValue(CELIX_SUCCESS); + mock().expectNCalls(2, "bundleArchive_getId") + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); int options = 1; mock().expectOneCall("fw_stopBundle") - .withParameter("framework", framework) - .withParameter("bundle", bundle) - .withParameter("record", 1) - .andReturnValue(CELIX_SUCCESS); + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("record", 1) + .andReturnValue(CELIX_SUCCESS); celix_status_t status = bundle_stopWithOptions(bundle, options); LONGS_EQUAL(CELIX_SUCCESS, status); + + mock().expectOneCall("fw_stopBundle") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withParameter("record", 0) + .andReturnValue(CELIX_SUCCESS); + + status = bundle_stop(bundle); + LONGS_EQUAL(CELIX_SUCCESS, status); + + free(bundle); } -//TEST(bundle, uninstall) { -// bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); -// framework_pt framework = (framework_pt) 0x10; -// bundle_archive_pt archive = (bundle_archive_pt) 0x20; -// bundle->framework = framework; -// bundle->archive = archive; -// -// long id = 0; -// mock().expectOneCall("bundleArchive_getId") -// .withParameter("archive", archive) -// .withOutputParameterReturning("id", &id, sizeof(id)) -// .andReturnValue(CELIX_SUCCESS); -// -// mock().expectOneCall("fw_uninstallBundle") -// .withParameter("framework", framework) -// .withParameter("bundle", bundle) -// .andReturnValue(CELIX_SUCCESS); -// -// celix_status_t status = bundle_uninstall(bundle); -// LONGS_EQUAL(CELIX_SUCCESS, status); -//} +TEST(bundle, uninstall) { + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + framework_pt framework = (framework_pt) 0x10; + bundle_archive_pt archive = (bundle_archive_pt) 0x20; + bundle->framework = framework; + bundle->archive = archive; + + long id = 666; + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); + + mock().expectOneCall("fw_uninstallBundle") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .andReturnValue(CELIX_SUCCESS); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_uninstall(bundle)); + + //attempt to uninstall framework bundle + id = 0; + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); + + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_BUNDLE_EXCEPTION); + + LONGS_EQUAL(CELIX_BUNDLE_EXCEPTION, bundle_uninstall(bundle)); + + free(bundle); +} TEST(bundle, setPersistentStateInactive) { bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); @@ -399,17 +594,18 @@ TEST(bundle, setPersistentStateInactive) { long id = 1; mock().expectOneCall("bundleArchive_getId") - .withParameter("archive", archive) - .withOutputParameterReturning("id", &id, sizeof(id)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); mock().expectOneCall("bundleArchive_setPersistentState") - .withParameter("archive", archive) - .withParameter("state", OSGI_FRAMEWORK_BUNDLE_INSTALLED) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withParameter("state", OSGI_FRAMEWORK_BUNDLE_INSTALLED) + .andReturnValue(CELIX_SUCCESS); - celix_status_t status = bundle_setPersistentStateInactive(bundle); - LONGS_EQUAL(CELIX_SUCCESS, status); + LONGS_EQUAL(CELIX_SUCCESS, bundle_setPersistentStateInactive(bundle)); + + free(bundle); } TEST(bundle, setPersistentStateUninstalled) { @@ -419,84 +615,430 @@ TEST(bundle, setPersistentStateUninstalled) { long id = 1; mock().expectOneCall("bundleArchive_getId") - .withParameter("archive", archive) - .withOutputParameterReturning("id", &id, sizeof(id)) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)) + .andReturnValue(CELIX_SUCCESS); mock().expectOneCall("bundleArchive_setPersistentState") - .withParameter("archive", archive) - .withParameter("state", OSGI_FRAMEWORK_BUNDLE_UNINSTALLED) - .andReturnValue(CELIX_SUCCESS); + .withParameter("archive", archive) + .withParameter("state", OSGI_FRAMEWORK_BUNDLE_UNINSTALLED) + .andReturnValue(CELIX_SUCCESS); celix_status_t status = bundle_setPersistentStateUninstalled(bundle); LONGS_EQUAL(CELIX_SUCCESS, status); + + free(bundle); } TEST(bundle, revise) { bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); - + arrayList_create(&bundle->modules); + bundle_archive_pt actual_archive = (bundle_archive_pt) 0x02; + bundle_revision_pt actual_revision = (bundle_revision_pt) malloc(sizeof(actual_revision)); + manifest_pt actual_manifest = (manifest_pt) malloc(sizeof(*actual_manifest)); + int actual_id = 666; + const char * actual_module_id = "666.0"; + bundle->archive = actual_archive; + char * symbolic_name = NULL; char location[] = "location"; char inputFile[] = "inputFile"; -// celix_status_t status = bundle_revise(bundle, location, inputFile); + + mock().expectNCalls(2, "bundleArchive_revise"); + + mock().expectNCalls(2, "bundleArchive_getCurrentRevision") + .withParameter("archive", bundle->archive) + .withOutputParameterReturning("revision", &actual_revision, sizeof(actual_revision)); + + mock().expectNCalls(2, "bundleRevision_getManifest") + .withParameter("revision", actual_revision) + .withOutputParameterReturning("manifest", &actual_manifest, sizeof(actual_manifest)); + + mock().expectNCalls(2, "bundleArchive_getId") + .withParameter("archive", actual_archive) + .withOutputParameterReturning("id", &actual_id, sizeof(actual_id)); + + mock().expectOneCall("module_create") + .withParameter("headerMap", actual_manifest) + .withParameter("moduleId", actual_module_id) + .withParameter("bundle", bundle); + + //module create returns NULL during test + mock().expectOneCall("resolver_addModule") + .withParameter("module", (void*)NULL); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_revise(bundle, location, inputFile)); + + mock().expectOneCall("module_create") + .withParameter("headerMap", actual_manifest) + .withParameter("moduleId", actual_module_id) + .withParameter("bundle", bundle) + .andReturnValue((void*)0x01); + + mock().expectOneCall("module_getVersion") + .withParameter("module", (void*)0x01); + + mock().expectOneCall("module_getSymbolicName") + .withParameter("module", (void*)0x01) + .withOutputParameterReturning("symbolicName", &symbolic_name,sizeof(symbolic_name)) + .andReturnValue(CELIX_ILLEGAL_ARGUMENT); + + mock().expectOneCall("bundleArchive_rollbackRevise"); + + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_BUNDLE_EXCEPTION); + + LONGS_EQUAL(CELIX_BUNDLE_EXCEPTION, bundle_revise(bundle, location, inputFile)); + + arrayList_destroy(bundle->modules); + free(bundle); + free(actual_revision); + free(actual_manifest); } TEST(bundle, isLockable) { bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); celixThreadMutex_create(&bundle->lock, NULL); + bundle->lockCount = 0; bool lockable = false; celix_status_t status = bundle_isLockable(bundle, &lockable); -// FAIL("Test not fully implemented"); -} + // FAIL("Test not fully implemented"); -TEST(bundle, getLockingThread) { -// FAIL("Test not fully implemented"); + free(bundle); } -TEST(bundle, lock) { -// FAIL("Test not fully implemented"); -} -TEST(bundle, unlock) { -// FAIL("Test not fully implemented"); +TEST(bundle, lockingThread) { + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + celixThreadMutex_create(&bundle->lock, NULL); + celix_thread_t thread; + + bundle->lockCount = 0; + + bool locked = false; + LONGS_EQUAL(CELIX_SUCCESS, bundle_lock(bundle, &locked)); + CHECK(locked); + LONGS_EQUAL(1, bundle->lockCount); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_getLockingThread(bundle, &thread)); + bool equals; + thread_equalsSelf(thread, &equals); + CHECK(equals); + + bool unlocked; + bundle->lockCount = 1; + LONGS_EQUAL(CELIX_SUCCESS, bundle_unlock(bundle, &unlocked)); + CHECK(unlocked); + LONGS_EQUAL(0, bundle->lockCount); + + //try to unlock unlocked lock + LONGS_EQUAL(CELIX_SUCCESS, bundle_unlock(bundle, &unlocked)); + CHECK_FALSE(unlocked); + LONGS_EQUAL(0, bundle->lockCount); + + celixThreadMutex_destroy(&bundle->lock); + free(bundle); } TEST(bundle, close) { -// FAIL("Test not fully implemented"); + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + + module_pt module = (module_pt) 0x01; + module_pt module2 = (module_pt) 0x02; + module_pt module3 = (module_pt) 0x03; + arrayList_create(&bundle->modules); + arrayList_add(bundle->modules, module); + arrayList_add(bundle->modules, module2); + arrayList_add(bundle->modules, module3); + + bundle_archive_pt archive = (bundle_archive_pt) 0x05; + bundle->archive = archive; + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module2); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module3); + + mock().expectNCalls(3, "module_setWires"); + + mock().expectOneCall("bundleArchive_close") + .withParameter("archive", archive); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_close(bundle)); + + arrayList_destroy(bundle->modules); + free(bundle); } TEST(bundle, closeAndDelete) { -// FAIL("Test not fully implemented"); + bundle_archive_pt archive = (bundle_archive_pt) 0x10; + mock().expectOneCall("bundleArchive_createSystemBundleArchive") + .withOutputParameterReturning("bundle_archive", &archive, sizeof(archive)) + .andReturnValue(CELIX_SUCCESS); + + module_pt module = (module_pt) 0x20; + mock().expectOneCall("module_createFrameworkModule") + .ignoreOtherParameters() + .andReturnValue(module); + + mock().expectOneCall("resolver_addModule") + .withParameter("module", module); + + bundle_pt actual = NULL; + celix_status_t status = bundle_create(&actual); + LONGS_EQUAL(CELIX_SUCCESS, status); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module); + + mock().expectOneCall("module_setWires"); + + mock().expectOneCall("bundleArchive_closeAndDelete"); + + status = bundle_closeAndDelete(actual); + LONGS_EQUAL(CELIX_SUCCESS, status); + + arrayList_destroy(actual->modules); + free(actual); } TEST(bundle, closeModules) { -// FAIL("Test not fully implemented"); + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + module_pt module = (module_pt) 0x01; + module_pt module2 = (module_pt) 0x02; + module_pt module3 = (module_pt) 0x03; + + arrayList_create(&bundle->modules); + arrayList_add(bundle->modules, module); + arrayList_add(bundle->modules, module2); + arrayList_add(bundle->modules, module3); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module2); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module3); + + mock().expectNCalls(3, "module_setWires"); + + bundle_closeModules(bundle); + + arrayList_destroy(bundle->modules); + free(bundle); } TEST(bundle, refresh) { -// FAIL("Test not fully implemented"); + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + + module_pt module = (module_pt) 0x01; + module_pt module2 = (module_pt) 0x02; + module_pt module3 = (module_pt) 0x03; + arrayList_create(&bundle->modules); + arrayList_add(bundle->modules, module); + arrayList_add(bundle->modules, module2); + arrayList_add(bundle->modules, module3); + + framework_pt framework = (framework_pt) 0x04; + bundle->framework = framework; + + bundle_archive_pt archive = (bundle_archive_pt) 0x05; + bundle->archive = archive; + + module_pt module_new = (module_pt) 0x06; + bundle_revision_pt revision = (bundle_revision_pt) 0x07; + version_pt version = (version_pt) 0x08; + manifest_pt manifest = (manifest_pt) 0x09; + + long id = 666; + char * symbolicName = my_strdup("name"); + + bundle_pt bundle2 = (bundle_pt) malloc(sizeof(*bundle)); + module_pt module4 = (module_pt) 0x0A; + arrayList_create(&bundle2->modules); + arrayList_add(bundle2->modules, module4); + bundle2->framework = framework; + + bundle_archive_pt archive2 = (bundle_archive_pt) 0x0B; + bundle2->archive = archive2; + + version_pt version2 = (version_pt) 0x0C; + long id2 = 667; + + array_list_pt bundles; + arrayList_create(&bundles); + arrayList_add(bundles, bundle2); + + //expected calls from bundle_refresh + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module2); + + mock().expectOneCall("resolver_removeModule") + .withParameter("module", module3); + + mock().expectNCalls(3, "module_setWires"); + + //expected calls from bundle_createModule + mock().expectOneCall("bundleArchive_getCurrentRevision") + .withParameter("archive", archive) + .withOutputParameterReturning("revision", &revision, sizeof(revision)); + + mock().expectOneCall("bundleRevision_getManifest") + .withParameter("revision", revision) + .withOutputParameterReturning("manifest", &manifest, sizeof(manifest)); + + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", archive) + .withOutputParameterReturning("id", &id, sizeof(id)); + + mock().expectOneCall("module_create") + .withParameter("headerMap", manifest) + .withParameter("moduleId", "666.0") + .withParameter("bundle", bundle) + .andReturnValue(module_new); + + mock().expectOneCall("module_getVersion") + .withParameter("module", module_new) + .andReturnValue(version); + + mock().expectOneCall("module_getSymbolicName") + .withParameter("module", module_new) + .withOutputParameterReturning("symbolicName", &symbolicName, sizeof(char*)); + + mock().expectOneCall("framework_getBundles") + .withParameter("framework", framework) + .andReturnValue(bundles); + + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", archive2) + .withOutputParameterReturning("id", &id2, sizeof(id2)); + + //returning same symbolic name for module_new as for module4 + mock().expectOneCall("module_getSymbolicName") + .withParameter("module", module4) + .withOutputParameterReturning("symbolicName", &symbolicName, sizeof(char*)); + + //returning different version for module_new as for module4 + mock().expectOneCall("module_getVersion") + .withParameter("module", module4) + .andReturnValue(version2); + + int result = 1; //1 means not equal + mock().expectOneCall("version_compareTo") + .withParameter("version", version) + .withParameter("compare", version2) + .withOutputParameterReturning("result", &result,sizeof(result)); + + //expected calls from bundle_addModule + mock().expectOneCall("resolver_addModule") + .withParameter("module", module_new); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_refresh(bundle)); + + arrayList_destroy(bundle->modules); + arrayList_destroy(bundle2->modules); + + free(bundle); + free(bundle2); + free(symbolicName); } TEST(bundle, getBundleId) { -// FAIL("Test not fully implemented"); + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + bundle_archive_pt actual_archive = (bundle_archive_pt) 0x42; + bundle->archive = actual_archive; + long actual_id = 666; + long get_id = 0; + + mock().expectOneCall("bundleArchive_getId") + .withParameter("archive", actual_archive) + .withOutputParameterReturning("id", &actual_id, sizeof(actual_id)); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_getBundleId(bundle, &get_id)); + LONGS_EQUAL(actual_id, get_id); + + free(bundle); } TEST(bundle, getRegisteredServices) { -// FAIL("Test not fully implemented"); + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + framework_pt framework = (framework_pt) 0x10; + bundle->framework = framework; + array_list_pt list = (array_list_pt) 0x20; + array_list_pt get = NULL; + + mock().expectOneCall("fw_getBundleRegisteredServices") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withOutputParameterReturning("services", &list, sizeof(list)); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_getRegisteredServices(bundle, &get)); + POINTERS_EQUAL(list, get); + + free(bundle); } TEST(bundle, getServicesInUse) { -// FAIL("Test not fully implemented"); -} + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + framework_pt framework = (framework_pt) 0x10; + bundle->framework = framework; + array_list_pt list = (array_list_pt) 0x20; + array_list_pt get = NULL; + + mock().expectOneCall("fw_getBundleServicesInUse") + .withParameter("framework", framework) + .withParameter("bundle", bundle) + .withOutputParameterReturning("services", &list, sizeof(list)); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_getServicesInUse(bundle, &get)); + POINTERS_EQUAL(list, get); -TEST(bundle, getMemoryPool) { -// FAIL("Test not fully implemented"); + free(bundle); } TEST(bundle, setFramework) { -// FAIL("Test not fully implemented"); + framework_pt framework = (framework_pt) 0x666; + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + + LONGS_EQUAL(CELIX_SUCCESS, bundle_setFramework(bundle, framework)); + POINTERS_EQUAL(framework, bundle->framework); + + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundle_setFramework(bundle, NULL)); + + free(bundle); } TEST(bundle, getFramework) { -// FAIL("Test not fully implemented"); + framework_pt get = NULL; + framework_pt actual = (framework_pt) 0x666; + bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); + + bundle->framework = actual; + + LONGS_EQUAL(CELIX_SUCCESS, bundle_getFramework(bundle, &get)); + + free(bundle); + bundle = NULL; + + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundle_getFramework(bundle, &get)); + + free(bundle); } http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/capability_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/capability_test.cpp b/framework/private/test/capability_test.cpp index 1874dd9..4d9f2eb 100644 --- a/framework/private/test/capability_test.cpp +++ b/framework/private/test/capability_test.cpp @@ -33,10 +33,11 @@ extern "C" { #include "capability_private.h" +#include "utils.h" #include "attribute.h" #include "celix_log.h" -framework_logger_pt logger; +framework_logger_pt logger = (framework_logger_pt) 0x42; } int main(int argc, char** argv) { @@ -45,8 +46,6 @@ int main(int argc, char** argv) { TEST_GROUP(capability) { void setup(void) { - logger = (framework_logger_pt) malloc(sizeof(*logger)); - logger->logFunction = frameworkLogger_log; } void teardown() { @@ -57,8 +56,8 @@ TEST_GROUP(capability) { TEST(capability, create) { module_pt module = (module_pt) 0x10; - hash_map_pt directives = hashMap_create(NULL, NULL, NULL, NULL); - hash_map_pt attributes = hashMap_create(NULL, NULL, NULL, NULL); + hash_map_pt directives = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); + hash_map_pt attributes = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); attribute_pt serviceAttribute = (attribute_pt) 0x01; hashMap_put(attributes, (void*) "service", serviceAttribute); @@ -90,6 +89,10 @@ TEST(capability, create) { capability_pt capability = NULL; celix_status_t status = capability_create(module, directives, attributes, &capability); + + mock().expectNCalls(2, "attribute_destroy"); + mock().expectOneCall("version_destroy"); + capability_destroy(capability); } TEST(capability, getServiceName) { @@ -100,6 +103,8 @@ TEST(capability, getServiceName) { char *actual = NULL; capability_getServiceName(capability, &actual); STRCMP_EQUAL(serviceName, actual); + + free(capability); } TEST(capability, getVersion) { @@ -110,6 +115,8 @@ TEST(capability, getVersion) { version_pt actual = NULL; capability_getVersion(capability, &actual); POINTERS_EQUAL(version, actual); + + free(capability); } TEST(capability, getModule) { @@ -120,4 +127,6 @@ TEST(capability, getModule) { module_pt actual = NULL; capability_getModule(capability, &actual); POINTERS_EQUAL(module, actual); + + free(capability); } http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/celix_errorcodes_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/celix_errorcodes_test.cpp b/framework/private/test/celix_errorcodes_test.cpp new file mode 100644 index 0000000..99ed360 --- /dev/null +++ b/framework/private/test/celix_errorcodes_test.cpp @@ -0,0 +1,87 @@ +/** + *Licensed to the Apache Software Foundation (ASF) under one + *or more contributor license agreements. See the NOTICE file + *distributed with this work for additional information + *regarding copyright ownership. The ASF licenses this file + *to you under the Apache License, Version 2.0 (the + *"License"); you may not use this file except in compliance + *with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + *Unless required by applicable law or agreed to in writing, + *software distributed under the License is distributed on an + *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + *specific language governing permissions and limitations + *under the License. + */ +/* + * celix_errorcodes_test.cpp + * + * \date Oct 16, 2015 + * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> + * \copyright Apache License, Version 2.0 + */ + +#include <stdlib.h> +#include <stdio.h> + +#include "CppUTest/TestHarness.h" +#include "CppUTest/TestHarness_c.h" +#include "CppUTest/CommandLineTestRunner.h" +#include "CppUTestExt/MockSupport.h" + +extern "C" { +#include "celix_errno.h" +} + +int main(int argc, char** argv) { + return CommandLineTestRunner::RunAllTests(argc, argv); +} + +TEST_GROUP(celix_errorcodes) { + void setup(void){ + } + + void teardown(void){ + } +}; + +TEST(celix_errorcodes, test_entire_file){ + char ret_str[100]; + + celix_strerror(CELIX_BUNDLE_EXCEPTION, ret_str, 100); + STRCMP_EQUAL("Bundle exception", ret_str); + + celix_strerror(CELIX_INVALID_BUNDLE_CONTEXT, ret_str, 100); + STRCMP_EQUAL("Invalid bundle context", ret_str); + + celix_strerror(CELIX_ILLEGAL_ARGUMENT, ret_str, 100); + STRCMP_EQUAL("Illegal argument", ret_str); + + celix_strerror(CELIX_INVALID_SYNTAX, ret_str, 100); + STRCMP_EQUAL("Invalid syntax", ret_str); + + celix_strerror(CELIX_FRAMEWORK_SHUTDOWN, ret_str, 100); + STRCMP_EQUAL("Framework shutdown", ret_str); + + celix_strerror(CELIX_ILLEGAL_STATE, ret_str, 100); + STRCMP_EQUAL("Illegal state", ret_str); + + celix_strerror(CELIX_FRAMEWORK_EXCEPTION, ret_str, 100); + STRCMP_EQUAL("Framework exception", ret_str); + + celix_strerror(CELIX_FILE_IO_EXCEPTION, ret_str, 100); + STRCMP_EQUAL("File I/O exception", ret_str); + + celix_strerror(CELIX_SERVICE_EXCEPTION, ret_str, 100); + STRCMP_EQUAL("Service exception", ret_str); + + celix_strerror(CELIX_START_ERROR, ret_str, 100); + STRCMP_EQUAL("Unknown code", ret_str); + + //test non celix error code + STRCMP_EQUAL("Cannot allocate memory", + celix_strerror(ENOMEM, ret_str, 100)); +} http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/framework_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/framework_test.cpp b/framework/private/test/framework_test.cpp index e1085f7..81dabf5 100644 --- a/framework/private/test/framework_test.cpp +++ b/framework/private/test/framework_test.cpp @@ -19,7 +19,7 @@ /* * framework_test.cpp * - * \date Feb 11, 2013 + * \date Sep 28, 2015 * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> * \copyright Apache License, Version 2.0 */ @@ -33,22 +33,79 @@ extern "C" { #include "framework.h" +#include "framework_private.h" } int main(int argc, char** argv) { - return RUN_ALL_TESTS(argc, argv); + return CommandLineTestRunner::RUN_ALL_TESTS(argc, argv); } TEST_GROUP(framework) { + properties_pt properties; + void setup(void) { + properties = properties_create(); } void teardown() { - mock().checkExpectations(); - mock().clear(); + properties_destroy(properties); } }; +TEST(framework, create){ + framework_pt framework = NULL; + + mock().expectOneCall("bundle_create"); + + framework_create(&framework, properties); + + + CHECK(framework != NULL); + POINTERS_EQUAL(&properties, framework->configurationMap); + + mock().checkExpectations(); + mock().clear(); +} + +/*TEST(framework, startFw){ + framework_pt framework = NULL; + + mock().expectOneCall("bundle_create"); + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + LONGS_EQUAL(CELIX_SUCCESS,framework_create(&framework, properties)); + + LONGS_EQUAL(CELIX_SUCCESS,fw_init(framework)); + + LONGS_EQUAL(CELIX_SUCCESS,framework_start(framework)); + + framework_stop(framework); + framework_destroy(framework); + +} + +TEST(framework, installBundle){ + framework_pt framework = NULL; + + mock().expectOneCall("bundle_create"); + mock().expectOneCall("framework_logCode") + .withParameter("code", CELIX_ILLEGAL_ARGUMENT); + + LONGS_EQUAL(CELIX_SUCCESS, framework_create(&framework, properties)); + + LONGS_EQUAL(CELIX_SUCCESS,fw_init(framework)); + + LONGS_EQUAL(CELIX_SUCCESS,framework_start(framework)); + + // fw_installBundle(); // Needs a fake bundle.. + + framework_stop(framework); + framework_destroy(framework); + +}*/ + + http://git-wip-us.apache.org/repos/asf/celix/blob/aec12cd9/framework/private/test/manifest_test.cpp ---------------------------------------------------------------------- diff --git a/framework/private/test/manifest_test.cpp b/framework/private/test/manifest_test.cpp index c90cc90..02422aa 100644 --- a/framework/private/test/manifest_test.cpp +++ b/framework/private/test/manifest_test.cpp @@ -56,7 +56,7 @@ TEST_GROUP(manifest) { }; TEST(manifest, createFromFile) { - char manifestFile[] = "../../celix/framework/private/resources-test/manifest.txt"; + char manifestFile[] = "resources-test/manifest.txt"; manifest_pt manifest = NULL; // properties_pt properties = properties_create(); properties_pt properties = (properties_pt) 0x40; @@ -98,7 +98,7 @@ TEST(manifest, createFromFile) { } TEST(manifest, createFromFileWithSections) { - char manifestFile[] = "../../celix/framework/private/resources-test/manifest_sections.txt"; + char manifestFile[] = "resources-test/manifest_sections.txt"; manifest_pt manifest = NULL; // properties_pt properties = properties_create(); properties_pt properties = (properties_pt) 0x40;
