This is an automated email from the ASF dual-hosted git repository. pnoltes pushed a commit to branch feature/cap_req_model_lib in repository https://gitbox.apache.org/repos/asf/celix.git
commit 7c7a118ac05f1f92e950ed02f65b6e4b81e86669 Author: Pepijn Noltes <[email protected]> AuthorDate: Sun Apr 9 16:58:19 2023 +0200 Add test for librcm to improve coverage --- .../celix_array_list/include/celix_array_list_ei.h | 2 +- .../celix_array_list/src/celix_array_list_ei.cc | 13 ++- libs/rcm/CMakeLists.txt | 1 + libs/rcm/README.md | 11 ++ libs/rcm/gtest/CMakeLists.txt | 1 + .../src/RequirementCapabilityModelTestSuite.cc | 115 +++++++++++++++------ ...ntCapabilityModelWithErrorInjectionTestSuite.cc | 27 ++++- libs/rcm/src/celix_capability.c | 1 - libs/rcm/src/celix_rcm_err.c | 36 ++++--- libs/rcm/src/celix_requirement.c | 1 - libs/rcm/src/celix_resource.c | 62 ----------- 11 files changed, 152 insertions(+), 118 deletions(-) diff --git a/libs/error_injector/celix_array_list/include/celix_array_list_ei.h b/libs/error_injector/celix_array_list/include/celix_array_list_ei.h index 0184c128..fb754682 100644 --- a/libs/error_injector/celix_array_list/include/celix_array_list_ei.h +++ b/libs/error_injector/celix_array_list/include/celix_array_list_ei.h @@ -44,7 +44,7 @@ CELIX_EI_DECLARE(celix_arrayList_addFloat, celix_status_t); CELIX_EI_DECLARE(celix_arrayList_addDouble, celix_status_t); -//CELIX_EI_DECLARE(celix_arrayList_addBool, celix_status_t); +CELIX_EI_DECLARE(celix_arrayList_addBool, celix_status_t); CELIX_EI_DECLARE(celix_arrayList_addSize, celix_status_t); diff --git a/libs/error_injector/celix_array_list/src/celix_array_list_ei.cc b/libs/error_injector/celix_array_list/src/celix_array_list_ei.cc index 6916b5f8..7de8b6c9 100644 --- a/libs/error_injector/celix_array_list/src/celix_array_list_ei.cc +++ b/libs/error_injector/celix_array_list/src/celix_array_list_ei.cc @@ -84,13 +84,12 @@ celix_status_t __wrap_celix_arrayList_addDouble(celix_array_list_t* list, double return __real_celix_arrayList_addDouble(list, value); } -//TODO -//celix_status_t __real_celix_arrayList_addBool(celix_array_list_t* list, bool value); -//CELIX_EI_DEFINE(celix_arrayList_addBool, celix_status_t) -//celix_status_t __wrap_celix_arrayList_addBool(celix_array_list_t* list, bool value) -// CELIX_EI_IMPL_POSITIVE(celix_arrayList_addBool); -// return __real_celix_arrayList_addBool(list, value); -//} +celix_status_t __real_celix_arrayList_addBool(celix_array_list_t* list, bool value); +CELIX_EI_DEFINE(celix_arrayList_addBool, celix_status_t) +celix_status_t __wrap_celix_arrayList_addBool(celix_array_list_t* list, bool value) { + CELIX_EI_IMPL_POSITIVE(celix_arrayList_addBool); + return __real_celix_arrayList_addBool(list, value); +} celix_status_t __real_celix_arrayList_addSize(celix_array_list_t* list, size_t value); CELIX_EI_DEFINE(celix_arrayList_addSize, celix_status_t) diff --git a/libs/rcm/CMakeLists.txt b/libs/rcm/CMakeLists.txt index bc812dc1..d4d6c919 100644 --- a/libs/rcm/CMakeLists.txt +++ b/libs/rcm/CMakeLists.txt @@ -25,6 +25,7 @@ set_target_properties(rcm PROPERTIES OUTPUT_NAME "celix_rcm") target_include_directories(rcm PRIVATE src) target_include_directories(rcm PUBLIC include) target_link_libraries(rcm PUBLIC Celix::utils) +set_target_properties(rcm PROPERTIES VERSION 0.0.1 SOVERSION 0) add_library(Celix::rcm ALIAS rcm) diff --git a/libs/rcm/README.md b/libs/rcm/README.md index f77602b6..828a3d08 100644 --- a/libs/rcm/README.md +++ b/libs/rcm/README.md @@ -26,6 +26,17 @@ C library based on the OSGi Requirement-Capability-Model, part of and [Chapter 7](https://docs.osgi.org/specification/osgi.core/8.0.0/framework.wiring.html) in the OSGi Core Specification 8. +Warning: This library is still under development and not yet ready for production use. + +## TODOs + + - Replace pthread thread specific storage with a celix wrapper (e.g. `celixThread_keyCreate`, `celixThread_keySet`, `celixThread_keyGet`, `celixThread_keyDelete`) + - TBD use `__attribute__((constructor))`/`__attribute__((destructor))` for tss key creation/deletion or use `celix_rcm_init`/`celix_rcm_deinit` (with usage count) + - Note currently `__attribute__((constructor))` and `__attribute__((destructor))` are used for tss key creation/deletion + - Add missing ei functions for tss key creation, deletion and setting values + - Wiring + - Resolver + ## Base Requirement-Capability-Model The Requirement-Capability-Model (RCM) is a model for describing the capabilities and requirements for a resource. diff --git a/libs/rcm/gtest/CMakeLists.txt b/libs/rcm/gtest/CMakeLists.txt index 52d3b485..fbbcec86 100644 --- a/libs/rcm/gtest/CMakeLists.txt +++ b/libs/rcm/gtest/CMakeLists.txt @@ -31,6 +31,7 @@ if (LINKER_WRAP_SUPPORTED) ) target_link_libraries(test_rcm_with_error_injection PRIVATE Celix::rcm GTest::gtest GTest::gtest_main) target_link_libraries(test_rcm_with_error_injection PRIVATE Celix::malloc_ei Celix::utils_ei Celix::array_list_ei) + target_include_directories(test_rcm_with_error_injection PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src) #private headers add_test(NAME test_rcm_with_error_injection COMMAND test_rcm_with_error_injection) setup_target_for_coverage(test_rcm_with_error_injection SCAN_DIR ..) endif () diff --git a/libs/rcm/gtest/src/RequirementCapabilityModelTestSuite.cc b/libs/rcm/gtest/src/RequirementCapabilityModelTestSuite.cc index 50db0e5e..216b6cbc 100644 --- a/libs/rcm/gtest/src/RequirementCapabilityModelTestSuite.cc +++ b/libs/rcm/gtest/src/RequirementCapabilityModelTestSuite.cc @@ -32,20 +32,9 @@ class RequirementCapabilityModelTestSuite : public ::testing::Test {}; TEST_F(RequirementCapabilityModelTestSuite, TestRequirement) { celix_requirement_t* req = celix_requirement_create(nullptr, "test-namespace", "(&(capability.attribute1=foo)(capability.attribute2=bar))"); ASSERT_TRUE(req != nullptr); - EXPECT_TRUE(celix_requirement_equals(req, req)); EXPECT_STREQ("test-namespace", celix_requirement_getNamespace(req)); EXPECT_STREQ("(&(capability.attribute1=foo)(capability.attribute2=bar))", celix_requirement_getFilter(req)); - celix_requirement_t* req2 = celix_requirement_create(nullptr, "test-namespace", "(&(capability.attribute1=foo)(capability.attribute2=bar))"); - ASSERT_TRUE(req2 != nullptr); - EXPECT_EQ(celix_requirement_hashCode(req), celix_requirement_hashCode(req2)); - EXPECT_TRUE(celix_requirement_equals(req, req2)); - - celix_requirement_t* req3 = celix_requirement_create(nullptr, "test-namespace2", "(&(capability.attribute1=foo)(capability.attribute2=bar2))"); //note different filter - ASSERT_TRUE(req3 != nullptr); - EXPECT_NE(celix_requirement_hashCode(req), celix_requirement_hashCode(req3)); - EXPECT_FALSE(celix_requirement_equals(req, req3)); - //test attributes/directives EXPECT_EQ(0, celix_properties_size(celix_requirement_getAttributes(req))); EXPECT_EQ(1, celix_properties_size(celix_requirement_getDirectives(req))); //1 filter directive @@ -66,33 +55,65 @@ TEST_F(RequirementCapabilityModelTestSuite, TestRequirement) { EXPECT_EQ(4, celix_properties_size(celix_requirement_getDirectives(req))); EXPECT_STREQ("(&(capability.attribute1=foo)(capability.attribute2=bar3))", celix_requirement_getFilter(req)); - EXPECT_FALSE(celix_requirement_equals(req, req2)); //note req 1 changed EXPECT_STREQ(celix_requirement_getDirective(req, "test-directive"), "test-directive-value"); EXPECT_EQ(nullptr, celix_requirement_getDirective(req, "test-directive-non-existing")); EXPECT_STREQ(celix_requirement_getAttribute(req, "test-attribute"), "test-attribute-value"); EXPECT_EQ(nullptr, celix_requirement_getAttribute(req, "test-attribute-non-existing")); + celix_requirement_t* req2 = celix_requirement_create(nullptr, "test-namespace", nullptr); + ASSERT_TRUE(req2 != nullptr); + EXPECT_EQ(0, celix_properties_size(celix_requirement_getDirectives(req2))); //0 filter directive, because no filter is set on creation + + + celix_requirement_destroy(req); + celix_requirement_destroy(req2); +} + +TEST_F(RequirementCapabilityModelTestSuite, TestRequirementEqualsAndHashCode) { + celix_requirement_t* req = celix_requirement_create(nullptr, "test-namespace", "(&(capability.attribute1=foo)(capability.attribute2=bar))"); + ASSERT_TRUE(req != nullptr); + celix_requirement_addAttribute(req, "test-attribute1", "test-attribute-value1"); + + EXPECT_TRUE(celix_requirement_equals(req, req)); + EXPECT_EQ(celix_requirement_hashCode(req), celix_requirement_hashCode(req)); + + celix_requirement_t* req2 = celix_requirement_create(nullptr, "test-namespace", "(&(capability.attribute1=foo)(capability.attribute2=bar))"); + ASSERT_TRUE(req2 != nullptr); + EXPECT_FALSE(celix_requirement_equals(req, req2)); + EXPECT_NE(celix_requirement_hashCode(req), celix_requirement_hashCode(req2)); + + celix_requirement_addAttribute(req2, "test-attribute1", "test-attribute-value1"); + EXPECT_TRUE(celix_requirement_equals(req, req2)); + EXPECT_EQ(celix_requirement_hashCode(req), celix_requirement_hashCode(req2)); + + celix_requirement_addAttribute(req2, "test-attribute1", "test-attribute-value1-changed"); + EXPECT_FALSE(celix_requirement_equals(req, req2)); + EXPECT_NE(celix_requirement_hashCode(req), celix_requirement_hashCode(req2)); + + celix_requirement_addAttribute(req2, "test-attribute1", "test-attribute-value1"); //overwrite changed + celix_requirement_addDirective(req2, "filter", "(&(capability.attribute1=foo)(capability.attribute2=bar-changed))"); + EXPECT_FALSE(celix_requirement_equals(req, req2)); + EXPECT_NE(celix_requirement_hashCode(req), celix_requirement_hashCode(req2)); + + celix_requirement_t* req3 = celix_requirement_create(nullptr, "test-namespace2", nullptr); + ASSERT_TRUE(req3 != nullptr); + celix_requirement_t* req4 = celix_requirement_create(nullptr, "test-namespace3", nullptr); + ASSERT_TRUE(req4 != nullptr); + EXPECT_FALSE(celix_requirement_equals(req3, req4)); //different namespace + EXPECT_NE(celix_requirement_hashCode(req3), celix_requirement_hashCode(req4)); + celix_requirement_destroy(req); celix_requirement_destroy(req2); celix_requirement_destroy(req3); + celix_requirement_destroy(req4); } + TEST_F(RequirementCapabilityModelTestSuite, TestCapability) { celix_capability_t* cap = celix_capability_create(nullptr, "test-namespace"); ASSERT_TRUE(cap != nullptr); - EXPECT_TRUE(celix_capability_equals(cap, cap)); EXPECT_STREQ("test-namespace", celix_capability_getNamespace(cap)); - celix_capability_t* cap2 = celix_capability_create(nullptr, "test-namespace"); - ASSERT_TRUE(cap2 != nullptr); - EXPECT_EQ(celix_capability_hashCode(cap), celix_capability_hashCode(cap2)); - EXPECT_TRUE(celix_capability_equals(cap, cap2)); - - celix_capability_t* cap3 = celix_capability_create(nullptr, "test-namespace2"); - ASSERT_TRUE(cap3 != nullptr); - EXPECT_NE(celix_capability_hashCode(cap), celix_capability_hashCode(cap3)); - EXPECT_FALSE(celix_capability_equals(cap, cap3)); - //test attributes/directives EXPECT_EQ(0, celix_properties_size(celix_capability_getAttributes(cap))); EXPECT_EQ(0, celix_properties_size(celix_capability_getDirectives(cap))); @@ -108,15 +129,53 @@ TEST_F(RequirementCapabilityModelTestSuite, TestCapability) { EXPECT_EQ(3, celix_properties_size(celix_capability_getAttributes(cap))); EXPECT_EQ(3, celix_properties_size(celix_capability_getDirectives(cap))); - EXPECT_FALSE(celix_capability_equals(cap, cap2)); //note cap 1 changed EXPECT_STREQ(celix_capability_getDirective(cap, "test-directive"), "test-directive-value"); EXPECT_EQ(nullptr, celix_capability_getDirective(cap, "test-directive-non-existing")); EXPECT_STREQ(celix_capability_getAttribute(cap, "test-attribute"), "test-attribute-value"); EXPECT_EQ(nullptr, celix_capability_getAttribute(cap, "test-attribute-non-existing")); + celix_capability_destroy(cap); +} + +TEST_F(RequirementCapabilityModelTestSuite, TestCapabilityEqualsAndHashCode) { + celix_capability_t* cap = celix_capability_create(nullptr, "test-namespace"); + ASSERT_TRUE(cap != nullptr); + celix_capability_addDirective(cap, "test-directive", "test-directive-value"); + celix_capability_addAttribute(cap, "test-attribute", "test-attribute-value"); + + EXPECT_TRUE(celix_capability_equals(cap, cap)); + EXPECT_EQ(celix_capability_hashCode(cap), celix_capability_hashCode(cap)); + + celix_capability_t* cap2 = celix_capability_create(nullptr, "test-namespace"); + ASSERT_TRUE(cap2 != nullptr); + EXPECT_FALSE(celix_capability_equals(cap, cap2)); + EXPECT_NE(celix_capability_hashCode(cap), celix_capability_hashCode(cap2)); + + celix_capability_addDirective(cap2, "test-directive", "test-directive-value"); + celix_capability_addAttribute(cap2, "test-attribute", "test-attribute-value"); + EXPECT_TRUE(celix_capability_equals(cap, cap2)); + EXPECT_EQ(celix_capability_hashCode(cap), celix_capability_hashCode(cap2)); + + celix_capability_addAttribute(cap2, "test-attribute", "test-attribute-value-changed"); + EXPECT_FALSE(celix_capability_equals(cap, cap2)); + EXPECT_NE(celix_capability_hashCode(cap), celix_capability_hashCode(cap2)); + + celix_capability_addAttribute(cap2, "test-attribute", "test-attribute-value"); //overwrite changed + celix_capability_addDirective(cap2, "test-directive", "test-directive-value-changed"); + EXPECT_FALSE(celix_capability_equals(cap, cap2)); + EXPECT_NE(celix_capability_hashCode(cap), celix_capability_hashCode(cap2)); + + celix_capability_t* cap3 = celix_capability_create(nullptr, "test-namespace2"); + ASSERT_TRUE(cap3 != nullptr); + celix_capability_t* cap4 = celix_capability_create(nullptr, "test-namespace3"); + ASSERT_TRUE(cap4 != nullptr); + EXPECT_FALSE(celix_capability_equals(cap3, cap4)); //different namespace + EXPECT_NE(celix_capability_hashCode(cap3), celix_capability_hashCode(cap4)); + celix_capability_destroy(cap); celix_capability_destroy(cap2); celix_capability_destroy(cap3); + celix_capability_destroy(cap4); } TEST_F(RequirementCapabilityModelTestSuite, TestNoNamespaceForCapabilityAndRequirement) { @@ -157,9 +216,6 @@ TEST_F(RequirementCapabilityModelTestSuite, TestResource) { EXPECT_EQ(0, celix_arrayList_size(celix_resource_getRequirements(res, nullptr))); EXPECT_EQ(0, celix_arrayList_size(celix_resource_getCapabilities(res, nullptr))); -// EXPECT_EQ(celix_resource_hashCode(res), celix_resource_hashCode(res2)); -// EXPECT_TRUE(celix_resource_equals(res, res2)); - celix_requirement_t* req = celix_requirement_create(res, "test-namespace", "(&(capability.attribute1=foo)(capability.attribute2=bar))"); EXPECT_TRUE(celix_resource_addRequirement(res, req)); EXPECT_EQ(res, celix_requirement_getResource(req)); @@ -173,17 +229,12 @@ TEST_F(RequirementCapabilityModelTestSuite, TestResource) { EXPECT_EQ(res, celix_capability_getResource(cap)); EXPECT_EQ(1, celix_arrayList_size(celix_resource_getCapabilities(res, nullptr))); -// EXPECT_FALSE(celix_resource_equals(res, res2)); //note res 1 changed -// EXPECT_NE(celix_resource_hashCode(res), celix_resource_hashCode(res2)); - req = celix_requirement_create(res2, "test-namespace2", nullptr); EXPECT_TRUE(celix_resource_addRequirement(res2, req)); req = celix_requirement_create(res2, "test-namespace", "(&(capability.attribute1=foo)(capability.attribute2=bar))"); EXPECT_TRUE(celix_resource_addRequirement(res2, req)); cap = celix_capability_create(res2, "test-namespace"); EXPECT_TRUE(celix_resource_addCapability(res2, cap)); -// EXPECT_TRUE(celix_resource_equals(res, res2)); //note res and res2 are the same again -// EXPECT_EQ(celix_resource_hashCode(res), celix_resource_hashCode(res2)); //test get capabilities/requirements by namespace req = celix_requirement_create(res, "test-namespace2", nullptr); diff --git a/libs/rcm/gtest/src/RequirementCapabilityModelWithErrorInjectionTestSuite.cc b/libs/rcm/gtest/src/RequirementCapabilityModelWithErrorInjectionTestSuite.cc index 33bec6e9..1718e15c 100644 --- a/libs/rcm/gtest/src/RequirementCapabilityModelWithErrorInjectionTestSuite.cc +++ b/libs/rcm/gtest/src/RequirementCapabilityModelWithErrorInjectionTestSuite.cc @@ -25,11 +25,11 @@ #include "celix_utils_ei.h" #include "celix_array_list_ei.h" -#include "celix/Properties.h" #include "celix_capability.h" #include "celix_requirement.h" #include "celix_resource.h" #include "celix_rcm_err.h" +#include "celix_rcm_err_private.h" class RequirementCapabilityModelWithErrorInjectionTestSuite : public ::testing::Test { public: @@ -41,6 +41,7 @@ public: celix_ei_expect_celix_arrayList_createWithOptions(nullptr, 0, nullptr); celix_ei_expect_celix_arrayList_create(nullptr, 0, nullptr); celix_ei_expect_celix_arrayList_add(nullptr, 0, CELIX_SUCCESS); + celix_ei_expect_celix_utils_strdup(nullptr, 0, nullptr); celix_rcmErr_resetErrors(); } }; @@ -128,4 +129,28 @@ TEST_F(RequirementCapabilityModelWithErrorInjectionTestSuite, TestResourceErrorH celix_capability_destroy(cap); celix_requirement_destroy(req); celix_resource_destroy(res); +} + +TEST_F(RequirementCapabilityModelWithErrorInjectionTestSuite, TestRcmErrErrorHandling) { + //inject error on first celix_utils_strdup call from celix_rcmErr_push + EXPECT_EQ(0, celix_rcmErr_getErrorCount()); + celix_ei_expect_celix_utils_strdup((void*)celix_rcmErr_push, 0, nullptr); + celix_rcmErr_push("test"); + EXPECT_EQ(0, celix_rcmErr_getErrorCount()); //error could not get pushed, so no error + + celix_rcmErr_resetErrors(); + + //inject error on first celix_arrayList_create call from (indirect) celix_rcmErr_push + EXPECT_EQ(0, celix_rcmErr_getErrorCount()); + celix_ei_expect_celix_arrayList_create((void*)celix_rcmErr_push, 1, nullptr); + celix_rcmErr_push("test"); + EXPECT_EQ(0, celix_rcmErr_getErrorCount()); //error could not get pushed, so no error + + celix_rcmErr_resetErrors(); + + //inject error on first celix_arrayList_add call from (indirect) celix_rcmErr_push + EXPECT_EQ(0, celix_rcmErr_getErrorCount()); + celix_ei_expect_celix_arrayList_add((void*)celix_rcmErr_push, 1, CELIX_ENOMEM); + celix_rcmErr_push("test"); + EXPECT_EQ(0, celix_rcmErr_getErrorCount()); //error could not get pushed, so no error } \ No newline at end of file diff --git a/libs/rcm/src/celix_capability.c b/libs/rcm/src/celix_capability.c index 692b1acf..5ea4dcb1 100644 --- a/libs/rcm/src/celix_capability.c +++ b/libs/rcm/src/celix_capability.c @@ -110,7 +110,6 @@ unsigned int celix_capability_hashCode(const celix_capability_t* cap) { unsigned int hash = celix_utils_stringHash(cap->ns); const char* visit; - //FIXME order of attributes/directives is not taken into account CELIX_PROPERTIES_FOR_EACH(cap->attributes, visit) { const char* value = celix_properties_get(cap->attributes, visit, NULL); hash += celix_utils_stringHash(visit); diff --git a/libs/rcm/src/celix_rcm_err.c b/libs/rcm/src/celix_rcm_err.c index f3a32ab5..13fce808 100644 --- a/libs/rcm/src/celix_rcm_err.c +++ b/libs/rcm/src/celix_rcm_err.c @@ -20,7 +20,6 @@ #include <stdlib.h> #include <stdarg.h> #include <stdio.h> -//#include <threads.h> #include <pthread.h> #include "celix_array_list.h" @@ -28,7 +27,6 @@ #include "celix_rcm_err.h" #include "celix_utils.h" -//static tss_t celix_rcm_tssErrorsKey; pthread_key_t celix_rcm_tssErrorsKey; static void celix_rcm_destroyTssErrors(void* data) { @@ -43,18 +41,21 @@ static void celix_rcm_destroyTssErrors(void* data) { } __attribute__((constructor)) void celix_rcm_initThreadSpecificStorageKey() { - //tss_create(&celix_rcm_tssErrorsKey, celix_rcm_destroyTssErrors); - pthread_key_create(&celix_rcm_tssErrorsKey, celix_rcm_destroyTssErrors); + int rc = pthread_key_create(&celix_rcm_tssErrorsKey, celix_rcm_destroyTssErrors); + if (rc != 0) { + fprintf(stderr,"Failed to create thread specific storage key for Apache Celix rcm lib\n"); + } } __attribute__((destructor)) void celix_rcm_deinitThreadSpecificStorageKey() { - //tss_delete(celix_rcm_tssErrorsKey); - pthread_key_delete(celix_rcm_tssErrorsKey); + int rc = pthread_key_delete(celix_rcm_tssErrorsKey); + if (rc != 0) { + fprintf(stderr,"Failed to delete thread specific storage key for Apache Celix rcm lib\n"); + } } char* celix_rcmErr_popLastError() { char* result = NULL; - //celix_array_list_t* errors = tss_get(celix_rcm_tssErrorsKey); celix_array_list_t* errors = pthread_getspecific(celix_rcm_tssErrorsKey); if (errors != NULL && celix_arrayList_size(errors) > 0) { result = celix_arrayList_get(errors, 0); @@ -65,7 +66,6 @@ char* celix_rcmErr_popLastError() { int celix_rcmErr_getErrorCount() { int result = 0; - //celix_array_list_t* errors = tss_get(celix_rcm_tssErrorsKey); celix_array_list_t* errors = pthread_getspecific(celix_rcm_tssErrorsKey); if (errors != NULL) { result = celix_arrayList_size(errors); @@ -74,27 +74,37 @@ int celix_rcmErr_getErrorCount() { } void celix_rcmErr_resetErrors() { - //celix_array_list_t* errors = tss_get(celix_rcm_tssErrorsKey); celix_array_list_t* errors = pthread_getspecific(celix_rcm_tssErrorsKey); celix_rcm_destroyTssErrors(errors); pthread_setspecific(celix_rcm_tssErrorsKey, NULL); } static void celix_rcm_pushMsg(char* msg) { - //celix_array_list_t* errors = tss_get(celix_rcm_tssErrorsKey); celix_array_list_t* errors = pthread_getspecific(celix_rcm_tssErrorsKey); if (errors == NULL) { errors = celix_arrayList_create(); - //tss_set(celix_rcm_tssErrorsKey, errors); + if (errors == NULL) { + fprintf(stderr, "Failed to create error list for Apache Celix rcm lib\n"); + return; + } pthread_setspecific(celix_rcm_tssErrorsKey, errors); } if (errors != NULL) { - celix_arrayList_add(errors, msg); + celix_status_t rc = celix_arrayList_add(errors, msg); + if (rc != CELIX_SUCCESS) { + fprintf(stderr, "Failed to add error to error list for Apache Celix rcm lib\n"); + free(msg); + } } } void celix_rcmErr_push(const char* msg) { - celix_rcm_pushMsg(celix_utils_strdup(msg)); + char* msgCpy = celix_utils_strdup(msg); + if (msgCpy == NULL) { + fprintf(stderr, "Failed to copy error message for Apache Celix rcm lib\n"); + return; + } + celix_rcm_pushMsg(msgCpy); } void celix_rcmErr_pushf(char* format, ...) { diff --git a/libs/rcm/src/celix_requirement.c b/libs/rcm/src/celix_requirement.c index 6e796f88..5b385054 100644 --- a/libs/rcm/src/celix_requirement.c +++ b/libs/rcm/src/celix_requirement.c @@ -119,7 +119,6 @@ unsigned int celix_requirement_hashCode(const celix_requirement_t* req) { unsigned int hash = celix_utils_stringHash(req->ns); const char* visit; - //FIXME order of attributes/directives is not taken into account CELIX_PROPERTIES_FOR_EACH(req->attributes, visit) { const char* val = celix_properties_get(req->attributes, visit, NULL); hash += celix_utils_stringHash(visit); diff --git a/libs/rcm/src/celix_resource.c b/libs/rcm/src/celix_resource.c index 3dd25782..a3c2cf4b 100644 --- a/libs/rcm/src/celix_resource.c +++ b/libs/rcm/src/celix_resource.c @@ -83,68 +83,6 @@ void celix_resource_destroy(celix_resource_t* resource) { free(resource); } } -/* -bool celix_resource_equals(const celix_resource_t* res1, const celix_resource_t* res2) { - if (res1 == res2) { - return true; - } - - if (celix_arrayList_size(res1->allCapabilities) != celix_arrayList_size(res2->allCapabilities) || - celix_arrayList_size(res1->allRequirements) != celix_arrayList_size(res2->allRequirements)) { - return false; - } - - - int equalCount = 0; - for (int i = 0; i < celix_arrayList_size(res1->allCapabilities); ++i) { - celix_capability_t* cap1 = celix_arrayList_get(res1->allCapabilities, i); - for (int k = 0; k < celix_arrayList_size(res2->allCapabilities); ++k) { - celix_capability_t* cap2 = celix_arrayList_get(res2->allCapabilities, k); - if (celix_capability_equals(cap1, cap2)) { - equalCount++; - break; - } - } - } - //FIXME only correct if all capabilities are unique - if (equalCount != celix_arrayList_size(res1->allCapabilities)) { - return false; - } - - equalCount = 0; - for (int i = 0; i < celix_arrayList_size(res1->allRequirements); ++i) { - celix_requirement_t* req1 = celix_arrayList_get(res1->allRequirements, i); - for (int k = 0; k < celix_arrayList_size(res2->allRequirements); ++k) { - celix_requirement_t* req2 = celix_arrayList_get(res2->allRequirements, k); - if (celix_requirement_equals(req1, req2)) { - equalCount++; - break; - } - } - } - //FIXME only correct if all capabilities are unique - if (equalCount != celix_arrayList_size(res1->allCapabilities)) { - return false; - } - - return true; -} - -unsigned int celix_resource_hashCode(const celix_resource_t* res) { - unsigned int hash = 0; - - for (int i = 0; i < celix_arrayList_size(res->allCapabilities); ++i) { - celix_capability_t* cap = celix_arrayList_get(res->allCapabilities, i); - hash += celix_capability_hashCode(cap); - } - - for (int i = 0; i < celix_arrayList_size(res->allRequirements); ++i) { - celix_requirement_t* req = celix_arrayList_get(res->allRequirements, i); - hash += celix_requirement_hashCode(req); - } - return hash; -} - */ const celix_array_list_t* celix_resource_getCapabilities(const celix_resource_t* res, const char* ns) { if (ns != NULL) {
