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 2024/02/04 22:32:35 UTC
(celix) 04/04: #674 Add array list element type testing
This is an automated email from the ASF dual-hosted git repository.
pnoltes pushed a commit to branch feature/674-add-element-type-to-array-list
in repository https://gitbox.apache.org/repos/asf/celix.git
commit f0ff9d94eb83ba3589e644988c338086db251b18
Author: Pepijn Noltes <pn...@apache.org>
AuthorDate: Sun Feb 4 23:32:00 2024 +0100
#674 Add array list element type testing
---
.../log_admin/gtest/src/LogAdminTestSuite.cc | 8 -
bundles/logging/log_admin/src/celix_log_admin.c | 4 +-
.../log_service_api/include/celix_log_control.h | 12 +
libs/utils/gtest/CMakeLists.txt | 2 +-
libs/utils/gtest/src/ArrayListTestSuite.cc | 351 ++++++++++++++++-----
libs/utils/include/celix_array_list.h | 10 +-
libs/utils/src/array_list.c | 40 ++-
7 files changed, 330 insertions(+), 97 deletions(-)
diff --git a/bundles/logging/log_admin/gtest/src/LogAdminTestSuite.cc b/bundles/logging/log_admin/gtest/src/LogAdminTestSuite.cc
index 859a24a7..fe11a78f 100644
--- a/bundles/logging/log_admin/gtest/src/LogAdminTestSuite.cc
+++ b/bundles/logging/log_admin/gtest/src/LogAdminTestSuite.cc
@@ -208,10 +208,6 @@ TEST_F(LogBundleTestSuite, SinkLogControl) {
auto *list = control->currentSinks(control->handle);
EXPECT_EQ(3, celix_arrayList_size(list));
- for (int i = 0; i < celix_arrayList_size(list); ++i) {
- auto *item = celix_arrayList_get(list, i);
- free(item);
- }
celix_arrayList_destroy(list);
@@ -277,10 +273,6 @@ TEST_F(LogBundleTestSuite, LogServiceControl) {
auto *list = control->currentLogServices(control->handle);
EXPECT_EQ(4, celix_arrayList_size(list));
- for (int i = 0; i < celix_arrayList_size(list); ++i) {
- auto *item = celix_arrayList_get(list, i);
- free(item);
- }
celix_arrayList_destroy(list);
celix_bundleContext_stopTracker(ctx.get(), trkId1);
diff --git a/bundles/logging/log_admin/src/celix_log_admin.c b/bundles/logging/log_admin/src/celix_log_admin.c
index 6b1be0f5..5ed38d53 100644
--- a/bundles/logging/log_admin/src/celix_log_admin.c
+++ b/bundles/logging/log_admin/src/celix_log_admin.c
@@ -544,7 +544,7 @@ static void celix_logAdmin_InfoCmd(celix_log_admin_t* admin, FILE* outStream, FI
fprintf(outStream, "Log Admin provided log services:\n");
for (int i = 0 ; i < celix_arrayList_size(logServices); ++i) {
- char *name = celix_arrayList_get(logServices, i);
+ const char *name = celix_arrayList_getString(logServices, i);
celix_log_level_e level;
bool detailed;
bool found = celix_logAdmin_logServiceInfoEx(admin, name, &level, &detailed);
@@ -558,7 +558,7 @@ static void celix_logAdmin_InfoCmd(celix_log_admin_t* admin, FILE* outStream, FI
if (celix_arrayList_size(sinks) > 0) {
fprintf(outStream, "Log Admin found log sinks:\n");
for (int i = 0 ; i < celix_arrayList_size(sinks); ++i) {
- char *name = celix_arrayList_get(sinks, i);
+ const char *name = celix_arrayList_getString(sinks, i);
bool enabled;
bool found = celix_logAdmin_sinkInfo(admin, name, &enabled);
if (found) {
diff --git a/bundles/logging/log_service_api/include/celix_log_control.h b/bundles/logging/log_service_api/include/celix_log_control.h
index 5f3d82f3..98c9a31d 100644
--- a/bundles/logging/log_service_api/include/celix_log_control.h
+++ b/bundles/logging/log_service_api/include/celix_log_control.h
@@ -44,8 +44,20 @@ typedef struct celix_log_control {
size_t (*setSinkEnabled)(void *handle, const char* select, bool enabled);
+ /**
+ * @brief Get a list of names for the log service provided by the log service.
+ * @param handle The service handle.
+ * @return A string array list.
+ * The array list is owned by the caller and should be destroyed by calling celix_arrayList_destroy.
+ */
celix_array_list_t* (*currentLogServices)(void *handle);
+ /**
+ * @brief Get a list of sinks names used by the log service.
+ * @param handle The service handle.
+ * @return A string array list.
+ * The array list is owned by the caller and should be destroyed by calling celix_arrayList_destroy.
+ */
celix_array_list_t* (*currentSinks)(void *handle);
bool (*logServiceInfo)(void *handle, const char* loggerName, celix_log_level_e* outActiveLogLevel);
diff --git a/libs/utils/gtest/CMakeLists.txt b/libs/utils/gtest/CMakeLists.txt
index e1e22ef7..db39b903 100644
--- a/libs/utils/gtest/CMakeLists.txt
+++ b/libs/utils/gtest/CMakeLists.txt
@@ -34,6 +34,7 @@ add_executable(test_utils
src/ThreadsTestSuite.cc
src/CelixErrnoTestSuite.cc
src/CelixUtilsAutoCleanupTestSuite.cc
+ src/ArrayListTestSuite.cc
src/DeprecatedHashmapTestSuite.cc
)
@@ -45,7 +46,6 @@ configure_file(resources/properties.txt ${CMAKE_CURRENT_BINARY_DIR}/resources-te
if (CELIX_CXX17)
add_library(test_utils_cxx17tests OBJECT
- src/ArrayListTestSuite.cc #Uses constexpr
src/HashMapTestSuite.cc #Uses constexpr
)
target_link_libraries(test_utils_cxx17tests PRIVATE utils_cut Celix::utils GTest::gtest)
diff --git a/libs/utils/gtest/src/ArrayListTestSuite.cc b/libs/utils/gtest/src/ArrayListTestSuite.cc
index 488f069f..6a508188 100644
--- a/libs/utils/gtest/src/ArrayListTestSuite.cc
+++ b/libs/utils/gtest/src/ArrayListTestSuite.cc
@@ -83,76 +83,26 @@ TEST_F(ArrayListTestSuite, TestArrayListWithEquals) {
}
template<typename T>
-void testArrayListForTemplateType(int nrEntries) {
- auto* list = celix_arrayList_create();
+void testArrayListForTemplateType(const std::vector<T>& entries,
+ const std::function<celix_array_list_t*()>& create,
+ const std::function<celix_status_t(celix_array_list_t*, T)>& add,
+ const std::function<T(celix_array_list_t*, int)>& get,
+ const std::function<void(celix_array_list_t*, T)>& remove) {
+ auto* list = create();
//fill
- for (int i = 0; i < nrEntries; ++i) {
- if constexpr (std::is_same_v<void*, T>) {
- celix_arrayList_add(list, (void*)(intptr_t )i);
- } else if constexpr (std::is_same_v<int, T>) {
- celix_arrayList_addInt(list, i);
- } else if constexpr (std::is_same_v<long, T>) {
- celix_arrayList_addLong(list, i);
- } else if constexpr (std::is_same_v<unsigned int, T>) {
- celix_arrayList_addUInt(list, i);
- } else if constexpr (std::is_same_v<unsigned long, T>) {
- celix_arrayList_addULong(list, i);
- } else if constexpr (std::is_same_v<float, T>) {
- celix_arrayList_addFloat(list, i + 0.0f);
- } else if constexpr (std::is_same_v<double, T>) {
- celix_arrayList_addDouble(list, i + 0.0);
- } else if constexpr (std::is_same_v<bool, T>) {
- celix_arrayList_addBool(list, i % 2 == 0);
- } else if constexpr (std::is_same_v<size_t, T>) {
- celix_arrayList_addSize(list, i);
- }
+ for (const auto& entry : entries) {
+ add(list, entry);
}
- EXPECT_EQ(celix_arrayList_size(list), nrEntries);
+ EXPECT_EQ(celix_arrayList_size(list), entries.size());
//get
- for (int i = 0; i < nrEntries; ++i) {
- if constexpr (std::is_same_v<void*, T>) {
- EXPECT_EQ(celix_arrayList_get(list, i), (void*)(intptr_t )i);
- } else if constexpr (std::is_same_v<int, T>) {
- EXPECT_EQ(celix_arrayList_getInt(list, i), i);
- } else if constexpr (std::is_same_v<long, T>) {
- EXPECT_EQ(celix_arrayList_getLong(list, i), i);
- } else if constexpr (std::is_same_v<unsigned int, T>) {
- EXPECT_EQ(celix_arrayList_getUInt(list, i), i);
- } else if constexpr (std::is_same_v<unsigned long, T>) {
- EXPECT_EQ(celix_arrayList_getULong(list, i), i);
- } else if constexpr (std::is_same_v<float, T>) {
- EXPECT_EQ(celix_arrayList_getFloat(list, i), i + 0.0);
- } else if constexpr (std::is_same_v<double, T>) {
- EXPECT_EQ(celix_arrayList_getDouble(list, i), i + 0.0);
- } else if constexpr (std::is_same_v<bool, T>) {
- EXPECT_EQ(celix_arrayList_getBool(list, i), i % 2 == 0);
- } else if constexpr (std::is_same_v<size_t, T>) {
- EXPECT_EQ(celix_arrayList_getSize(list, i), i);
- }
+ for (int i = 0; i < (int)entries.size(); ++i) {
+ EXPECT_EQ(get(list, i), entries[i]);
}
//remove
- for (int i = 0; i < nrEntries; ++i) {
- if constexpr (std::is_same_v<void*, T>) {
- celix_arrayList_remove(list, (void*)(intptr_t)i);
- } else if constexpr (std::is_same_v<int, T>) {
- celix_arrayList_removeInt(list, i);
- } else if constexpr (std::is_same_v<long, T>) {
- celix_arrayList_removeLong(list, i);
- } else if constexpr (std::is_same_v<unsigned int, T>) {
- celix_arrayList_removeUInt(list, i);
- } else if constexpr (std::is_same_v<unsigned long, T>) {
- celix_arrayList_removeULong(list, i);
- } else if constexpr (std::is_same_v<float, T>) {
- celix_arrayList_removeFloat(list, i + 0.0);
- } else if constexpr (std::is_same_v<double, T>) {
- celix_arrayList_removeDouble(list, i + 0.0);
- } else if constexpr (std::is_same_v<bool, T>) {
- celix_arrayList_removeBool(list, i % 2 == 0);
- } else if constexpr (std::is_same_v<size_t, T>) {
- celix_arrayList_removeSize(list, i);
- }
+ for (int i = 0; i < (int)entries.size(); ++i) {
+ remove(list, entries[i]);
}
EXPECT_EQ(celix_arrayList_size(list), 0);
@@ -160,15 +110,270 @@ void testArrayListForTemplateType(int nrEntries) {
}
TEST_F(ArrayListTestSuite, TestDifferentEntyTypesForArrayList) {
- testArrayListForTemplateType<void*>(10);
- testArrayListForTemplateType<int>(10);
- testArrayListForTemplateType<long>(10);
- testArrayListForTemplateType<unsigned int>(10);
- testArrayListForTemplateType<unsigned long>(10);
- testArrayListForTemplateType<float>(10);
- testArrayListForTemplateType<double>(10);
- testArrayListForTemplateType<bool>(10);
- testArrayListForTemplateType<size_t>(10);
+ std::vector<int> intEntries{1, 2, 3, 4, 5};
+ testArrayListForTemplateType<int>(intEntries,
+ celix_arrayList_createIntArray,
+ celix_arrayList_addInt,
+ celix_arrayList_getInt,
+ celix_arrayList_removeInt);
+
+ std::vector<long> longEntries{1L, 2L, 3L, 4L, 5L};
+ testArrayListForTemplateType<long>(longEntries,
+ celix_arrayList_createLongArray,
+ celix_arrayList_addLong,
+ celix_arrayList_getLong,
+ celix_arrayList_removeLong);
+
+ std::vector<float> floatEntries{1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+ testArrayListForTemplateType<float>(floatEntries,
+ celix_arrayList_createFloatArray,
+ celix_arrayList_addFloat,
+ celix_arrayList_getFloat,
+ celix_arrayList_removeFloat);
+
+ std::vector<double> doubleEntries{1.0, 2.0, 3.0, 4.0, 5.0};
+ testArrayListForTemplateType<double>(doubleEntries,
+ celix_arrayList_createDoubleArray,
+ celix_arrayList_addDouble,
+ celix_arrayList_getDouble,
+ celix_arrayList_removeDouble);
+
+ std::vector<bool> boolEntries{true, false, true, false, true};
+ testArrayListForTemplateType<bool>(boolEntries,
+ celix_arrayList_createBoolArray,
+ celix_arrayList_addBool,
+ celix_arrayList_getBool,
+ celix_arrayList_removeBool);
+
+ std::vector<void*> voidPtrEntries{(void*)0x11, (void*)0x22, (void*)0x33, (void*)0x44, (void*)0x55};
+ testArrayListForTemplateType<void*>(voidPtrEntries,
+ celix_arrayList_createPointerArray,
+ celix_arrayList_add,
+ celix_arrayList_get,
+ celix_arrayList_remove);
+
+ std::vector<uint32_t> uintEntries{1, 2, 3, 4, 5};
+ testArrayListForTemplateType<uint32_t>(uintEntries,
+ celix_arrayList_createUIntArray,
+ celix_arrayList_addUInt,
+ celix_arrayList_getUInt,
+ celix_arrayList_removeUInt);
+
+ std::vector<uint64_t> ulongEntries{1, 2, 3, 4, 5};
+ testArrayListForTemplateType<uint64_t>(ulongEntries,
+ celix_arrayList_createULongArray,
+ celix_arrayList_addULong,
+ celix_arrayList_getULong,
+ celix_arrayList_removeULong);
+
+ std::vector<size_t> sizeEntries{1, 2, 3, 4, 5};
+ testArrayListForTemplateType<size_t>(sizeEntries,
+ celix_arrayList_createSizeArray,
+ celix_arrayList_addSize,
+ celix_arrayList_getSize,
+ celix_arrayList_removeSize);
+}
+
+TEST_F(ArrayListTestSuite, StringArrayList) {
+ celix_autoptr(celix_array_list_t) stringList = celix_arrayList_createStringArray();
+ const char* str1 = "1";
+ celix_arrayList_addString(stringList, str1);
+ celix_arrayList_addString(stringList, "2");
+ celix_arrayList_assignString(stringList, strdup("3"));
+
+ EXPECT_EQ(3, celix_arrayList_size(stringList));
+ EXPECT_STREQ("1", celix_arrayList_getString(stringList, 0));
+ EXPECT_NE((void*)str1, (void*)celix_arrayList_getString(stringList, 0)); //string is added as copy
+ EXPECT_STREQ("2", celix_arrayList_getString(stringList, 1));
+ EXPECT_STREQ("3", celix_arrayList_getString(stringList, 2));
+
+ celix_arrayList_removeString(stringList, "2");
+ EXPECT_EQ(2, celix_arrayList_size(stringList));
+
+ celix_autoptr(celix_array_list_t) stringRefList = celix_arrayList_createStringRefArray();
+ celix_arrayList_addString(stringRefList, str1);
+ celix_arrayList_addString(stringRefList, "2");
+ celix_arrayList_addString(stringRefList, "3");
+
+ EXPECT_EQ(3, celix_arrayList_size(stringRefList));
+ EXPECT_STREQ("1", celix_arrayList_getString(stringRefList, 0));
+ EXPECT_EQ((void*)str1, (void*)celix_arrayList_getString(stringRefList, 0)); //string is added as reference
+ EXPECT_STREQ("2", celix_arrayList_getString(stringRefList, 1));
+
+ celix_arrayList_removeString(stringRefList, "2");
+ EXPECT_EQ(2, celix_arrayList_size(stringRefList));
+}
+
+TEST_F(ArrayListTestSuite, VersionArrayList) {
+ celix_autoptr(celix_array_list_t) versionList = celix_arrayList_createVersionArray();
+ celix_version_t* v1 = celix_version_create(1, 2, 3, "a");
+ celix_arrayList_addVersion(versionList, v1); //copy
+ celix_arrayList_assignVersion(versionList, v1); //transfer ownership
+ celix_arrayList_assignVersion(versionList, celix_version_create(2, 3, 4, "b"));
+
+ EXPECT_EQ(3, celix_arrayList_size(versionList));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 0), 1, 2));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 1), 1, 2));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 2), 2, 3));
+
+ EXPECT_NE((void*)v1, (void*)celix_arrayList_getVersion(versionList, 0)); //version is added as copy
+ EXPECT_EQ((void*)v1, (void*)celix_arrayList_getVersion(versionList, 1)); //version is added as reference
+
+ celix_autoptr(celix_version_t) vRef = celix_version_create(1, 2, 3, "a");
+ celix_arrayList_removeVersion(versionList, vRef);
+ EXPECT_EQ(2, celix_arrayList_size(versionList));
+}
+
+TEST_F(ArrayListTestSuite, SortTypedArrayLists) {
+ // Given a ptr, string, int, long, uint, ulong, float, double, bool, size and version list
+ // with unsorted values (including duplicates)
+ celix_autoptr(celix_array_list_t) ptrList = celix_arrayList_createPointerArray();
+ celix_arrayList_add(ptrList, (void*)0x33);
+ celix_arrayList_add(ptrList, (void*)0x11);
+ celix_arrayList_add(ptrList, (void*)0x22);
+ celix_arrayList_add(ptrList, (void*)0x11);
+
+ celix_autoptr(celix_array_list_t) stringList = celix_arrayList_createStringArray();
+ celix_arrayList_addString(stringList, "3");
+ celix_arrayList_addString(stringList, "1");
+ celix_arrayList_addString(stringList, "2");
+ celix_arrayList_addString(stringList, "1");
+
+ celix_autoptr(celix_array_list_t) intList = celix_arrayList_createIntArray();
+ celix_arrayList_addInt(intList, 3);
+ celix_arrayList_addInt(intList, 1);
+ celix_arrayList_addInt(intList, 2);
+ celix_arrayList_addInt(intList, 1);
+
+ celix_autoptr(celix_array_list_t) longList = celix_arrayList_createLongArray();
+ celix_arrayList_addLong(longList, 3L);
+ celix_arrayList_addLong(longList, 1L);
+ celix_arrayList_addLong(longList, 2L);
+ celix_arrayList_addLong(longList, 1L);
+
+ celix_autoptr(celix_array_list_t) uintList = celix_arrayList_createUIntArray();
+ celix_arrayList_addUInt(uintList, 3U);
+ celix_arrayList_addUInt(uintList, 1U);
+ celix_arrayList_addUInt(uintList, 2U);
+ celix_arrayList_addUInt(uintList, 1U);
+
+ celix_autoptr(celix_array_list_t) ulongList = celix_arrayList_createULongArray();
+ celix_arrayList_addULong(ulongList, 3UL);
+ celix_arrayList_addULong(ulongList, 1UL);
+ celix_arrayList_addULong(ulongList, 2UL);
+ celix_arrayList_addULong(ulongList, 1UL);
+
+ celix_autoptr(celix_array_list_t) floatList = celix_arrayList_createFloatArray();
+ celix_arrayList_addFloat(floatList, 3.0f);
+ celix_arrayList_addFloat(floatList, 1.0f);
+ celix_arrayList_addFloat(floatList, 2.0f);
+ celix_arrayList_addFloat(floatList, 1.0f);
+
+ celix_autoptr(celix_array_list_t) doubleList = celix_arrayList_createDoubleArray();
+ celix_arrayList_addDouble(doubleList, 3.0);
+ celix_arrayList_addDouble(doubleList, 1.0);
+ celix_arrayList_addDouble(doubleList, 2.0);
+ celix_arrayList_addDouble(doubleList, 1.0);
+
+ celix_autoptr(celix_array_list_t) boolList = celix_arrayList_createBoolArray();
+ celix_arrayList_addBool(boolList, false);
+ celix_arrayList_addBool(boolList, true);
+ celix_arrayList_addBool(boolList, false);
+
+ celix_autoptr(celix_array_list_t) sizeList = celix_arrayList_createSizeArray();
+ celix_arrayList_addSize(sizeList, 3);
+ celix_arrayList_addSize(sizeList, 1);
+ celix_arrayList_addSize(sizeList, 2);
+ celix_arrayList_addSize(sizeList, 1);
+
+ celix_autoptr(celix_array_list_t) versionList = celix_arrayList_createVersionArray();
+ celix_arrayList_assignVersion(versionList, celix_version_create(2, 1, 0, ""));
+ celix_arrayList_assignVersion(versionList, celix_version_create(3, 2, 1, ""));
+ celix_arrayList_assignVersion(versionList, celix_version_create(2, 1, 0, ""));
+ celix_arrayList_assignVersion(versionList, celix_version_create(1, 0, 0, "b"));
+ celix_arrayList_assignVersion(versionList, celix_version_create(1, 0, 0, "a"));
+
+ // Then the element type is correctly set
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_POINTER, celix_arrayList_getElementType(ptrList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING, celix_arrayList_getElementType(stringList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_INT, celix_arrayList_getElementType(intList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_LONG, celix_arrayList_getElementType(longList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_UINT, celix_arrayList_getElementType(uintList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_ULONG, celix_arrayList_getElementType(ulongList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_FLOAT, celix_arrayList_getElementType(floatList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_DOUBLE, celix_arrayList_getElementType(doubleList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_BOOL, celix_arrayList_getElementType(boolList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_SIZE, celix_arrayList_getElementType(sizeList));
+ EXPECT_EQ(CELIX_ARRAY_LIST_ELEMENT_TYPE_VERSION, celix_arrayList_getElementType(versionList));
+
+ // When sorting the lists
+ celix_arrayList_sort(ptrList);
+ celix_arrayList_sort(stringList);
+ celix_arrayList_sort(intList);
+ celix_arrayList_sort(longList);
+ celix_arrayList_sort(uintList);
+ celix_arrayList_sort(ulongList);
+ celix_arrayList_sort(floatList);
+ celix_arrayList_sort(doubleList);
+ celix_arrayList_sort(boolList);
+ celix_arrayList_sort(sizeList);
+ celix_arrayList_sort(versionList);
+
+ // Then the lists are sorted
+ EXPECT_EQ((void*)0x11, celix_arrayList_get(ptrList, 0));
+ EXPECT_EQ((void*)0x11, celix_arrayList_get(ptrList, 1));
+ EXPECT_EQ((void*)0x22, celix_arrayList_get(ptrList, 2));
+ EXPECT_EQ((void*)0x33, celix_arrayList_get(ptrList, 3));
+
+ EXPECT_STREQ("1", celix_arrayList_getString(stringList, 0));
+ EXPECT_STREQ("1", celix_arrayList_getString(stringList, 1));
+ EXPECT_STREQ("2", celix_arrayList_getString(stringList, 2));
+ EXPECT_STREQ("3", celix_arrayList_getString(stringList, 3));
+
+ EXPECT_EQ(1, celix_arrayList_getInt(intList, 0));
+ EXPECT_EQ(1, celix_arrayList_getInt(intList, 1));
+ EXPECT_EQ(2, celix_arrayList_getInt(intList, 2));
+ EXPECT_EQ(3, celix_arrayList_getInt(intList, 3));
+
+ EXPECT_EQ(1L, celix_arrayList_getLong(longList, 0));
+ EXPECT_EQ(1L, celix_arrayList_getLong(longList, 1));
+ EXPECT_EQ(2L, celix_arrayList_getLong(longList, 2));
+ EXPECT_EQ(3L, celix_arrayList_getLong(longList, 3));
+
+ EXPECT_EQ(1U, celix_arrayList_getUInt(uintList, 0));
+ EXPECT_EQ(1U, celix_arrayList_getUInt(uintList, 1));
+ EXPECT_EQ(2U, celix_arrayList_getUInt(uintList, 2));
+ EXPECT_EQ(3U, celix_arrayList_getUInt(uintList, 3));
+
+ EXPECT_EQ(1UL, celix_arrayList_getULong(ulongList, 0));
+ EXPECT_EQ(1UL, celix_arrayList_getULong(ulongList, 1));
+ EXPECT_EQ(2UL, celix_arrayList_getULong(ulongList, 2));
+ EXPECT_EQ(3UL, celix_arrayList_getULong(ulongList, 3));
+
+ EXPECT_FLOAT_EQ(1.0f, celix_arrayList_getFloat(floatList, 0));
+ EXPECT_FLOAT_EQ(1.0f, celix_arrayList_getFloat(floatList, 1));
+ EXPECT_FLOAT_EQ(2.0f, celix_arrayList_getFloat(floatList, 2));
+ EXPECT_FLOAT_EQ(3.0f, celix_arrayList_getFloat(floatList, 3));
+
+ EXPECT_DOUBLE_EQ(1.0, celix_arrayList_getDouble(doubleList, 0));
+ EXPECT_DOUBLE_EQ(1.0, celix_arrayList_getDouble(doubleList, 1));
+ EXPECT_DOUBLE_EQ(2.0, celix_arrayList_getDouble(doubleList, 2));
+ EXPECT_DOUBLE_EQ(3.0, celix_arrayList_getDouble(doubleList, 3));
+
+ EXPECT_FALSE(celix_arrayList_getBool(boolList, 0));
+ EXPECT_FALSE(celix_arrayList_getBool(boolList, 1));
+ EXPECT_TRUE(celix_arrayList_getBool(boolList, 2));
+
+ EXPECT_EQ(1, celix_arrayList_getSize(sizeList, 0));
+ EXPECT_EQ(1, celix_arrayList_getSize(sizeList, 1));
+ EXPECT_EQ(2, celix_arrayList_getSize(sizeList, 2));
+ EXPECT_EQ(3, celix_arrayList_getSize(sizeList, 3));
+
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 0), 1, 0));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 1), 1, 0));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 2), 2, 1));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 3), 2, 1));
+ EXPECT_EQ(0, celix_version_compareToMajorMinor(celix_arrayList_getVersion(versionList, 4), 3, 2));
}
TEST_F(ArrayListTestSuite, TestSimpleRemovedCallbacksForArrayList) {
@@ -261,4 +466,4 @@ TEST_F(ArrayListTestSuite, TestReturnStatusAddFunctions) {
TEST_F(ArrayListTestSuite, AutoCleanupTest) {
celix_autoptr(celix_array_list_t) list = celix_arrayList_create();
EXPECT_NE(nullptr, list);
-}
\ No newline at end of file
+}
diff --git a/libs/utils/include/celix_array_list.h b/libs/utils/include/celix_array_list.h
index 25925c89..b4c2dc58 100644
--- a/libs/utils/include/celix_array_list.h
+++ b/libs/utils/include/celix_array_list.h
@@ -294,7 +294,9 @@ celix_array_list_t* celix_arrayList_createVersionArray();
/**
* @brief Creates a new empty array list using using the provided array list create options.
*
- * The underlying element type will be undefined, until the first element is added.
+ * If the element type is set to something other than CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED, the remove, equals,
+ * and compare callbacks will be set according to the corresponding celix_arrayList_create*Array function.
+ * The provided callbacks in the options will override the default callbacks.
*
* @param opts The create options, only used during the creation of the array list.
*/
@@ -311,6 +313,12 @@ void celix_arrayList_destroy(celix_array_list_t *list);
CELIX_DEFINE_AUTOPTR_CLEANUP_FUNC(celix_array_list_t, celix_arrayList_destroy)
+/**
+ * @brief Return the element type of the array list.
+ */
+CELIX_UTILS_EXPORT
+celix_array_list_element_type_t celix_arrayList_getElementType(const celix_array_list_t *list);
+
/**
* @brief Returns the size of the array list.
*/
diff --git a/libs/utils/src/array_list.c b/libs/utils/src/array_list.c
index 807d21b2..cf668150 100644
--- a/libs/utils/src/array_list.c
+++ b/libs/utils/src/array_list.c
@@ -16,13 +16,6 @@
* specific language governing permissions and limitations
* under the License.
*/
-/**
- * array_list.c
- *
- * \date Aug 4, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
#include <assert.h>
#include <stdint.h>
@@ -50,7 +43,7 @@ struct celix_array_list {
};
static bool celix_arrayList_undefinedEquals(celix_array_list_entry_t a, celix_array_list_entry_t b) {
- return memcmp(&a, &b, sizeof(a)) == 0;
+ return memcmp(&a.voidPtrVal, &b.voidPtrVal, sizeof(a)) == 0;
}
static int celix_arrayList_comparePtrEntries(celix_array_list_entry_t a, celix_array_list_entry_t b) {
@@ -195,6 +188,10 @@ static void celix_arrayList_setTypeSpecificCallbacks(celix_array_list_t* list) {
list->equalsCallback = celix_arrayList_stringEquals;
list->compareCallback = celix_arrayList_compareStringEntries;
break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING_REF:
+ list->equalsCallback = celix_arrayList_stringEquals;
+ list->compareCallback = celix_arrayList_compareStringEntries;
+ break;
case CELIX_ARRAY_LIST_ELEMENT_TYPE_INT:
list->equalsCallback = celix_arrayList_intEquals;
list->compareCallback = celix_arrayList_compareIntEntries;
@@ -252,6 +249,7 @@ celix_array_list_t* celix_arrayList_createWithOptions(const celix_array_list_cre
list->elementType = opts->elementType;
celix_arrayList_setTypeSpecificCallbacks(list);
+ //if opts contains callbacks, use them and override the default ones
if (opts->simpleRemovedCallback) {
list->simpleRemovedCallback = opts->simpleRemovedCallback;
}
@@ -259,6 +257,12 @@ celix_array_list_t* celix_arrayList_createWithOptions(const celix_array_list_cre
list->removedCallback = opts->removedCallback;
list->removedCallbackData = opts->removedCallbackData;
}
+ if (opts->equalsCallback) {
+ list->equalsCallback = opts->equalsCallback;
+ }
+ if (opts->compareCallback) {
+ list->compareCallback = opts->compareCallback;
+ }
}
return celix_steal_ptr(list);
}
@@ -317,6 +321,11 @@ celix_array_list_t* celix_arrayList_createSizeArray() {
return celix_arrayList_createTypedArray(CELIX_ARRAY_LIST_ELEMENT_TYPE_SIZE);
}
+celix_array_list_t* celix_arrayList_createVersionArray() {
+ return celix_arrayList_createTypedArray(CELIX_ARRAY_LIST_ELEMENT_TYPE_VERSION);
+}
+
+
celix_array_list_t* celix_arrayList_createWithEquals(celix_arrayList_equals_fp equals) {
celix_array_list_create_options_t opts = CELIX_EMPTY_ARRAY_LIST_CREATE_OPTIONS;
opts.equalsCallback = equals;
@@ -331,6 +340,10 @@ void celix_arrayList_destroy(celix_array_list_t *list) {
}
}
+celix_array_list_element_type_t celix_arrayList_getElementType(const celix_array_list_t *list) {
+ return list->elementType;
+}
+
int celix_arrayList_size(const celix_array_list_t *list) {
return (int)list->size;
}
@@ -448,10 +461,7 @@ celix_status_t celix_arrayList_assignString(celix_array_list_t* list, char* valu
assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING);
celix_array_list_entry_t entry;
memset(&entry, 0, sizeof(entry));
- entry.stringVal = celix_utils_strdup(value);
- if (entry.stringVal == NULL) {
- return CELIX_ENOMEM;
- }
+ entry.stringVal = value;
return celix_arrayList_addEntry(list, entry);
}
@@ -699,6 +709,12 @@ static int celix_arrayList_compareEntries(const void* voidA, const void* voidB,
return compare(*a, *b);
}
+void celix_arrayList_sort(celix_array_list_t *list) {
+ if (list->compareCallback) {
+ celix_arrayList_sortEntries(list, list->compareCallback);
+ }
+}
+
void celix_arrayList_sortEntries(celix_array_list_t *list, celix_array_list_compare_entries_fp compare) {
#if defined(__APPLE__)
qsort_r(list->elementData, list->size, sizeof(celix_array_list_entry_t), compare, celix_arrayList_compareEntries);