You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by pn...@apache.org on 2023/04/09 14:58:30 UTC
[celix] 02/02: Add test for librcm to improve coverage
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 <pe...@gmail.com>
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) {