| /** |
| *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. |
| */ |
| /* |
| * bundle_test.cpp |
| * |
| * \date Feb 11, 2013 |
| * \author <a href="mailto:dev@celix.apache.org">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" |
| #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) 0x42; |
| } |
| |
| int main(int argc, char** argv) { |
| return RUN_ALL_TESTS(argc, argv); |
| } |
| |
| TEST_GROUP(bundle) { |
| void setup(void) { |
| } |
| |
| 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") |
| .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); |
| POINTERS_EQUAL(NULL, actual->context); |
| POINTERS_EQUAL(NULL, actual->activator); |
| LONGS_EQUAL(OSGI_FRAMEWORK_BUNDLE_INSTALLED, actual->state); |
| POINTERS_EQUAL(NULL, actual->handle); |
| POINTERS_EQUAL(archive, actual->archive); |
| CHECK(actual->modules); |
| POINTERS_EQUAL(NULL, actual->manifest); |
| // 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) { |
| framework_pt framework = (framework_pt) 0x10; |
| bundle_archive_pt archive = (bundle_archive_pt) 0x20; |
| bundle_revision_pt revision = (bundle_revision_pt) 0x21; |
| manifest_pt manifest = (manifest_pt) 0x30; |
| |
| mock().expectOneCall("bundleArchive_getCurrentRevision") |
| .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); |
| |
| long id = 1; |
| mock().expectOneCall("bundleArchive_getId") |
| .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); |
| |
| version_pt version = (version_pt) 0x50; |
| mock().expectOneCall("module_getVersion") |
| .withParameter("module", module) |
| .andReturnValue(version); |
| |
| char symbolicName[] = "name"; |
| mock().expectOneCall("module_getSymbolicName") |
| .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); |
| |
| bundle_pt actual = NULL; |
| celix_status_t status = bundle_createFromArchive(&actual, framework, archive); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| POINTERS_EQUAL(NULL, actual->context); |
| POINTERS_EQUAL(NULL, actual->activator); |
| LONGS_EQUAL(OSGI_FRAMEWORK_BUNDLE_INSTALLED, actual->state); |
| POINTERS_EQUAL(NULL, actual->handle); |
| POINTERS_EQUAL(archive, actual->archive); |
| CHECK(actual->modules); |
| POINTERS_EQUAL(NULL, actual->manifest); |
| // 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) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| bundle_archive_pt archive = (bundle_archive_pt) 0x10; |
| bundle->archive = archive; |
| |
| bundle_archive_pt actual = NULL; |
| LONGS_EQUAL(CELIX_SUCCESS, bundle_getArchive(bundle, &actual)); |
| POINTERS_EQUAL(archive, actual); |
| |
| mock().expectOneCall("framework_logCode") |
| .withParameter("code", CELIX_ILLEGAL_ARGUMENT); |
| |
| actual = NULL; |
| LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, bundle_getArchive(NULL, &actual)); |
| |
| free(bundle); |
| |
| |
| mock().clear(); |
| } |
| |
| TEST(bundle, getCurrentModule) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| module_pt module1 = (module_pt) 0x11; |
| module_pt module2 = (module_pt) 0x12; |
| module_pt module3 = (module_pt) 0x13; |
| module_pt module4 = (module_pt) 0x14; |
| arrayList_create(&bundle->modules); |
| arrayList_add(bundle->modules, module1); |
| arrayList_add(bundle->modules, module2); |
| arrayList_add(bundle->modules, module3); |
| arrayList_add(bundle->modules, module4); |
| |
| module_pt actual = NULL; |
| celix_status_t status = bundle_getCurrentModule(bundle, &actual); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| POINTERS_EQUAL(module4, actual); |
| |
| actual = NULL; |
| status = bundle_getCurrentModule(NULL, &actual); |
| LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status); |
| |
| arrayList_destroy(bundle->modules); |
| free(bundle); |
| } |
| |
| TEST(bundle, getModules) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| array_list_pt modules = (array_list_pt) 0x10; |
| bundle->modules = modules; |
| |
| array_list_pt actual = bundle_getModules(bundle); |
| POINTERS_EQUAL(modules, actual); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, getHandle) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| void *expected = (void *) 0x10; |
| bundle->handle = expected; |
| |
| void *actual = bundle_getHandle(bundle); |
| POINTERS_EQUAL(expected, actual); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, setHandle) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| void *expected = (void *) 0x10; |
| |
| bundle_setHandle(bundle, expected); |
| POINTERS_EQUAL(expected, bundle->handle); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, getActivator) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| activator_pt expected = (activator_pt) 0x10; |
| bundle->activator = expected; |
| |
| activator_pt actual = bundle_getActivator(bundle); |
| POINTERS_EQUAL(expected, actual); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, setActivator) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| activator_pt expected = (activator_pt) 0x10; |
| |
| celix_status_t status = bundle_setActivator(bundle, expected); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| POINTERS_EQUAL(expected, bundle->activator); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, getContext) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| bundle_context_pt expected = (bundle_context_pt) 0x10; |
| bundle->context = expected; |
| |
| bundle_context_pt actual = NULL; |
| celix_status_t status = bundle_getContext(bundle, &actual); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| POINTERS_EQUAL(expected, actual); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, setContext) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| bundle_context_pt expected = (bundle_context_pt) 0x10; |
| |
| celix_status_t status = bundle_setContext(bundle, expected); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| POINTERS_EQUAL(expected, bundle->context); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, getEntry) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| framework_pt framework = (framework_pt) 0x10; |
| bundle->framework = framework; |
| |
| 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); |
| |
| char *actual = NULL; |
| celix_status_t status = bundle_getEntry(bundle, name, &actual); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| POINTERS_EQUAL(expected, actual); |
| |
| //free(actual); |
| free(bundle); |
| } |
| |
| TEST(bundle, getState) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| bundle->state = OSGI_FRAMEWORK_BUNDLE_ACTIVE; |
| |
| bundle_state_e actual = OSGI_FRAMEWORK_BUNDLE_UNKNOWN; |
| 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) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| bundle->state = OSGI_FRAMEWORK_BUNDLE_UNKNOWN; |
| |
| 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; |
| bundle_archive_pt archive = (bundle_archive_pt) 0x20; |
| bundle->framework = framework; |
| bundle->archive = archive; |
| |
| int options = 42; |
| |
| long id = 1; |
| 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); |
| |
| 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) { |
| 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 = 1; |
| mock().expectOneCall("bundleArchive_getId") |
| .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); |
| |
| celix_status_t status = bundle_update(bundle, input); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, stop) { |
| 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 = 1; |
| 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); |
| |
| 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 = 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)); |
| bundle_archive_pt archive = (bundle_archive_pt) 0x10; |
| bundle->archive = archive; |
| |
| long id = 1; |
| mock().expectOneCall("bundleArchive_getId") |
| .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); |
| |
| LONGS_EQUAL(CELIX_SUCCESS, bundle_setPersistentStateInactive(bundle)); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, setPersistentStateUninstalled) { |
| bundle_pt bundle = (bundle_pt) malloc(sizeof(*bundle)); |
| bundle_archive_pt archive = (bundle_archive_pt) 0x10; |
| bundle->archive = archive; |
| |
| long id = 1; |
| mock().expectOneCall("bundleArchive_getId") |
| .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); |
| |
| 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"; |
| |
| mock().expectNCalls(2, "bundleArchive_revise") |
| .withParameter("archive", actual_archive) |
| .withParameter("location", location) |
| .withParameter("inputFile", inputFile); |
| |
| 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) |
| .andReturnValue((void*)NULL); |
| |
| //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); |
| |
| bool rolledBack = true; |
| mock().expectOneCall("bundleArchive_rollbackRevise") |
| .withParameter("archive", actual_archive) |
| .withOutputParameterReturning("rolledback", &rolledBack, sizeof(rolledBack)); |
| |
| 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); |
| LONGS_EQUAL(CELIX_SUCCESS, status); |
| // FAIL("Test not fully implemented"); |
| |
| free(bundle); |
| } |
| |
| |
| 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) { |
| 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) { |
| 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) { |
| 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) { |
| 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) { |
| 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) { |
| 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) { |
| 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); |
| |
| free(bundle); |
| } |
| |
| TEST(bundle, setFramework) { |
| 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) { |
| 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); |
| } |