This is an automated email from the ASF dual-hosted git repository. pnoltes pushed a commit to branch feature/parse_filter_attribute_types in repository https://gitbox.apache.org/repos/asf/celix.git
commit 3493d6a1c626e87d35cfa5fb5f3870364c5fa5c2 Author: Pepijn Noltes <[email protected]> AuthorDate: Fri Mar 31 15:45:07 2023 +0200 Refactor cpputest filter tests to gtest --- libs/utils/CMakeLists.txt | 6 - libs/utils/gtest/CMakeLists.txt | 1 + libs/utils/gtest/src/FilterTestSuite.cc | 403 +++++++++++++++++++++++ libs/utils/private/test/filter_test.cpp | 546 -------------------------------- libs/utils/src/filter.c | 41 ++- 5 files changed, 437 insertions(+), 560 deletions(-) diff --git a/libs/utils/CMakeLists.txt b/libs/utils/CMakeLists.txt index d1aa4bdc..7444f540 100644 --- a/libs/utils/CMakeLists.txt +++ b/libs/utils/CMakeLists.txt @@ -126,10 +126,6 @@ if (ENABLE_TESTING) target_include_directories(ip_utils_test PRIVATE include_deprecated) target_link_libraries(ip_utils_test CppUTest::CppUTest Celix::utils pthread) - add_executable(filter_test private/test/filter_test.cpp) - target_include_directories(filter_test PRIVATE include_deprecated) - target_link_libraries(filter_test CppUTest::CppUTest Celix::utils pthread) - add_executable(version_test private/test/version_test.cpp) target_include_directories(version_test PRIVATE include_deprecated) target_link_libraries(version_test CppUTest::CppUTest Celix::utils pthread) @@ -143,7 +139,6 @@ if (ENABLE_TESTING) add_test(NAME run_properties_test COMMAND properties_test) add_test(NAME run_utils_test COMMAND utils_test) add_test(NAME run_ip_utils_test COMMAND ip_utils_test) - add_test(NAME filter_test COMMAND filter_test) add_test(NAME version_test COMMAND version_test) setup_target_for_coverage(array_list_test) @@ -153,7 +148,6 @@ if (ENABLE_TESTING) setup_target_for_coverage(properties_test) setup_target_for_coverage(utils_test) setup_target_for_coverage(ip_utils_test) - setup_target_for_coverage(filter_test) setup_target_for_coverage(version_test) else () message(WARNING "Cannot find CppUTest, deprecated cpputest-based unit test will not be added") diff --git a/libs/utils/gtest/CMakeLists.txt b/libs/utils/gtest/CMakeLists.txt index 7440357c..15778d13 100644 --- a/libs/utils/gtest/CMakeLists.txt +++ b/libs/utils/gtest/CMakeLists.txt @@ -30,6 +30,7 @@ add_executable(test_utils src/HashMapTestSuite.cc src/ArrayListTestSuite.cc src/FileUtilsTestSuite.cc + src/FilterTestSuite.cc ${CELIX_UTIL_TEST_SOURCES_FOR_CXX_HEADERS} ) diff --git a/libs/utils/gtest/src/FilterTestSuite.cc b/libs/utils/gtest/src/FilterTestSuite.cc new file mode 100644 index 00000000..e83dffeb --- /dev/null +++ b/libs/utils/gtest/src/FilterTestSuite.cc @@ -0,0 +1,403 @@ +/* + * 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. + */ + +#include <gtest/gtest.h> +#include "celix_filter.h" +#include "celix_utils.h" + + +class FilterTestSuite : public ::testing::Test {}; + +TEST_F(FilterTestSuite, create_destroy){ + const char* filter_str = "(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))"; + celix_filter_t * get_filter; + + get_filter = celix_filter_create(filter_str); + ASSERT_TRUE(get_filter != NULL); + + celix_filter_destroy(get_filter); +} + +TEST_F(FilterTestSuite, create_fail_missing_opening_brackets){ + celix_filter_t * get_filter; + + //test missing opening brackets in main filter + const char *filter_str1 = "&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3))"; + get_filter = celix_filter_create(filter_str1); + ASSERT_TRUE(get_filter == NULL); + + //test missing opening brackets in AND comparator + const char *filter_str2 = "(&test_attr1=attr1|(test_attr2=attr2)(test_attr3=attr3))"; + get_filter = celix_filter_create(filter_str2); + ASSERT_TRUE(get_filter == NULL); + + //test missing opening brackets in AND comparator + const char *filter_str3 = "(&(test_attr1=attr1)(|test_attr2=attr2(test_attr3=attr3))"; + get_filter = celix_filter_create(filter_str3); + ASSERT_TRUE(get_filter == NULL); + + //test missing opening brackets in NOT comparator + const char *filter_str4 = "(&(test_attr1=attr1)(!test_attr2=attr2)"; + get_filter = celix_filter_create(filter_str4); + ASSERT_TRUE(get_filter == NULL); +} + +TEST_F(FilterTestSuite, create_fail_missing_closing_brackets){ + char * filter_str; + celix_filter_t * get_filter; + //test missing closing brackets in substring + filter_str = celix_utils_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3"); + get_filter = celix_filter_create(filter_str); + ASSERT_TRUE(get_filter == NULL); + free(filter_str); + + //test missing closing brackets in value + filter_str = celix_utils_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=attr3"); + get_filter = celix_filter_create(filter_str); + ASSERT_TRUE(get_filter == NULL); + free(filter_str); +} + +TEST_F(FilterTestSuite, create_fail_invalid_closing_brackets) { + char *filter_str; + celix_filter_t *get_filter; + + //test missing closing brackets in substring + filter_str = celix_utils_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=at(tr3)))"); + get_filter = celix_filter_create(filter_str); + ASSERT_TRUE(get_filter == NULL); + free(filter_str); + + //test missing closing brackets in value + filter_str = celix_utils_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=att(r3)))"); + get_filter = celix_filter_create(filter_str); + ASSERT_TRUE(get_filter == NULL); + free(filter_str); +} + +TEST_F(FilterTestSuite, create_misc) { + celix_filter_t *get_filter; + //test trailing chars + const char *filter_str1 = "(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3))) oh no! trailing chars"; + get_filter = celix_filter_create(filter_str1); + ASSERT_TRUE(get_filter == NULL); + + //test half APPROX operator (should be "~=", instead is "~") + const char *filter_str2 = "(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3~attr3)))"; + get_filter = celix_filter_create(filter_str2); + ASSERT_TRUE(get_filter == NULL); + + //test PRESENT operator with trailing chars (should just register as substrings: "*" and "attr3") + const char *filter_str3 = "(test_attr3=*attr3)"; + get_filter = celix_filter_create(filter_str3); + ASSERT_TRUE(get_filter != NULL); + ASSERT_EQ(CELIX_FILTER_OPERAND_SUBSTRING, get_filter->operand); + ASSERT_EQ(2, celix_arrayList_size((celix_array_list_t *) get_filter->children)); + celix_filter_destroy(get_filter); + + //test parsing a attribute of 0 length + const char *filter_str4 = "(>=attr3)"; + get_filter = celix_filter_create(filter_str4); + ASSERT_TRUE(get_filter == NULL); + + //test parsing a value of 0 length + const char *filter_str5 = "(test_attr3>=)"; + get_filter = celix_filter_create(filter_str5); + ASSERT_TRUE(get_filter == NULL); + + //test parsing a value with a escaped closing bracket "\)" + const char *filter_str6 = "(test_attr3>=strWith\\)inIt)"; + get_filter = celix_filter_create(filter_str6); + ASSERT_TRUE(get_filter != NULL); + ASSERT_STREQ("strWith)inIt", (char *) get_filter->value); + celix_filter_destroy(get_filter); + + //test parsing a substring with a escaped closing bracket "\)" + const char *filter_str7 = "(test_attr3=strWith\\)inIt)"; + get_filter = celix_filter_create(filter_str7); + ASSERT_TRUE(get_filter != NULL); + ASSERT_STREQ("strWith)inIt", (char *) get_filter->value); + celix_filter_destroy(get_filter); +} + +TEST_F(FilterTestSuite, match_comparators) { + char *filter_str; + celix_filter_t *filter; + celix_properties_t *props = celix_properties_create(); + char *key = celix_utils_strdup("test_attr1"); + char *val = celix_utils_strdup("attr1"); + char *key2 = celix_utils_strdup("test_attr2"); + char *val2 = celix_utils_strdup("attr2"); + celix_properties_set(props, key, val); + celix_properties_set(props, key2, val2); + //test AND + filter_str = celix_utils_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(!(test_attr3=attr3))))"); + filter = celix_filter_create(filter_str); + bool result = celix_filter_match(filter, props); + ASSERT_TRUE(result); + + //test AND false + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1=attr1)(test_attr1=attr2))"); + filter = celix_filter_create(filter_str); + ASSERT_TRUE(filter == nullptr); + result = celix_filter_match(filter, props); + ASSERT_TRUE(result); + +//cleanup + celix_properties_destroy(props); + celix_filter_destroy(filter); + free(filter_str); + free(key); + free(key2); + free(val); + free(val2); +} + +TEST_F(FilterTestSuite, match_operators) { + char *filter_str; + celix_filter_t *filter; + celix_properties_t *props = celix_properties_create(); + char *key = celix_utils_strdup("test_attr1"); + char *val = celix_utils_strdup("attr1"); + char *key2 = celix_utils_strdup("test_attr2"); + char *val2 = celix_utils_strdup("attr2"); + celix_properties_set(props, key, val); + celix_properties_set(props, key2, val2); + + // Test EQUALS + filter_str = celix_utils_strdup("(test_attr1=attr1)"); + filter = celix_filter_create(filter_str); + bool result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + // Test EQUALS false + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1=falseString)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1~=attr1)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1~=ATTR1)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + // Test PRESENT + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1=*)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + // Test NOT PRESENT + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr3=*)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + // Test NOT PRESENT + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(!(test_attr3=*))"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + // Test LESSEQUAL less + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1<=attr5)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + // Test LESSEQUAL equals + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2<=attr2)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + //test LESSEQUAL false + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2<=attr1)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //test GREATEREQUAL greater + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2>=attr1)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + //test GREATEREQUAL equals + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2>=attr2)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + //test GREATEREQUAL false + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1>=attr5)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //test LESS less + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1<attr5)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + //test LESS equals + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2<attr2)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //test LESS false + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2<attr1)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //test GREATER greater + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2>attr1)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + //test GREATER equals + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr2>attr2)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //test GREATER false + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1>attr5)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //test SUBSTRING equals + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1=attr*)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_TRUE(result); + + celix_filter_destroy(filter); + free(filter_str); + filter_str = celix_utils_strdup("(test_attr1=attr*charsNotPresent)"); + filter = celix_filter_create(filter_str); + result = celix_filter_match(filter, props); + EXPECT_FALSE(result); + + //cleanup + celix_properties_destroy(props); + celix_filter_destroy(filter); + free(filter_str); + free(key); + free(key2); + free(val); + free(val2); +} + +TEST_F(FilterTestSuite, match_recursion) { + auto* filter_str = "(&(test_attr1=attr1)(|(&(test_attr2=attr2)(!(&(test_attr1=attr1)(test_attr3=attr3))))(test_attr3=attr3)))"; + auto* filter = celix_filter_create(filter_str); + auto* props = celix_properties_create(); + auto* key = "test_attr1"; + auto* val = "attr1"; + auto* key2 = "test_attr2"; + auto* val2 = "attr2"; + celix_properties_set(props, key, val); + celix_properties_set(props, key2, val2); + bool result = celix_filter_match(filter, props); + ASSERT_TRUE(result); + + celix_properties_destroy(props); + celix_filter_destroy(filter); +} + +TEST_F(FilterTestSuite, match_false) { + auto* filter_str = "(&(test_attr1=attr1)(&(test_attr2=attr2)(test_attr3=attr3)))"; + celix_filter_t* filter = celix_filter_create(filter_str); + celix_properties_t* props = celix_properties_create(); + auto* key = "test_attr1"; + auto* val = "attr1"; + auto* key2 = "test_attr2"; + auto* val2 = "attr2"; + celix_properties_set(props, key, val); + celix_properties_set(props, key2, val2); + + bool result = celix_filter_match(filter, props); + ASSERT_FALSE(result); + + //cleanup + celix_properties_destroy(props); + celix_filter_destroy(filter); +} + +TEST_F(FilterTestSuite, getString) { + auto* filter_str = "(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))"; + celix_filter_t * filter = celix_filter_create(filter_str); + + const char * get_str = celix_filter_getFilterString(filter); + ASSERT_STREQ(filter_str, get_str); + + //cleanup + celix_filter_destroy(filter); +} diff --git a/libs/utils/private/test/filter_test.cpp b/libs/utils/private/test/filter_test.cpp deleted file mode 100644 index e0c25ef8..00000000 --- a/libs/utils/private/test/filter_test.cpp +++ /dev/null @@ -1,546 +0,0 @@ -/* - * 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. - */ - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> - -#include "CppUTest/TestHarness.h" -#include "CppUTest/TestHarness_c.h" -#include "CppUTest/CommandLineTestRunner.h" - -#include "celix_filter.h" -#include "filter.h" - -int main(int argc, char** argv) { - MemoryLeakWarningPlugin::turnOffNewDeleteOverloads(); - return RUN_ALL_TESTS(argc, argv); -} - -static char* my_strdup(const char* s){ - if (s == NULL) { - return NULL; - } - - size_t len = strlen(s); - - char *d = (char *) calloc (len + 1,sizeof(char)); - - if (d == NULL) { - return NULL; - } - - strncpy(d,s,len); - return d; -} - -//----------------TESTGROUPS---------------- -TEST_GROUP(filter) { - void setup() { - } - - void teardown() { - } -}; - -//----------------FILTER TESTS---------------- -TEST(filter, create_destroy){ - char * filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))"); - celix_filter_t * get_filter; - - get_filter = celix_filter_create(filter_str); - CHECK(get_filter != NULL); - - celix_filter_destroy(get_filter); - - //cleanup - free(filter_str); -} - -TEST(filter, create_fail_missing_opening_brackets){ - celix_filter_t * get_filter; - - //test missing opening brackets in main filter - //mock().expectNCalls(2, "framework_log"); - const char *filter_str1 = "&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3))"; - get_filter = celix_filter_create(filter_str1); - POINTERS_EQUAL(NULL, get_filter); - - //test missing opening brackets in AND comparator - //mock().expectNCalls(3, "framework_log"); - const char *filter_str2 = "(&test_attr1=attr1|(test_attr2=attr2)(test_attr3=attr3))"; - get_filter = celix_filter_create(filter_str2); - POINTERS_EQUAL(NULL, get_filter); - - //test missing opening brackets in AND comparator - //mock().expectNCalls(4, "framework_log"); - const char *filter_str3 = "(&(test_attr1=attr1)(|test_attr2=attr2(test_attr3=attr3))"; - get_filter = celix_filter_create(filter_str3); - POINTERS_EQUAL(NULL, get_filter); - - //test missing opening brackets in NOT comparator - //mock().expectNCalls(4, "framework_log"); - const char *filter_str4 = "(&(test_attr1=attr1)(!test_attr2=attr2)"; - get_filter = celix_filter_create(filter_str4); - POINTERS_EQUAL(NULL, get_filter); -} - -TEST(filter, create_fail_missing_closing_brackets){ - char * filter_str; - celix_filter_t * get_filter; - //test missing closing brackets in substring - filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3"); - get_filter = celix_filter_create(filter_str); - POINTERS_EQUAL(NULL, get_filter); - free(filter_str); - - //test missing closing brackets in value - filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=attr3"); - get_filter = celix_filter_create(filter_str); - POINTERS_EQUAL(NULL, get_filter); - free(filter_str); -} - -TEST(filter, create_fail_invalid_closing_brackets){ - char * filter_str; - celix_filter_t * get_filter; - - //test missing closing brackets in substring - //mock().expectNCalls(6, "framework_log"); - filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=at(tr3)))"); - get_filter = celix_filter_create(filter_str); - POINTERS_EQUAL(NULL, get_filter); - free(filter_str); - - //test missing closing brackets in value - //mock().expectNCalls(5, "framework_log"); - filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=att(r3)))"); - get_filter = celix_filter_create(filter_str); - POINTERS_EQUAL(NULL, get_filter); - free(filter_str); -} - -TEST(filter, create_misc){ - celix_filter_t * get_filter; - - //test trailing chars - //mock().expectOneCall("framework_log"); - const char *filter_str1 = "(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3))) oh no! trailing chars"; - get_filter = celix_filter_create(filter_str1); - POINTERS_EQUAL(NULL, get_filter); - - //test half APPROX operator (should be "~=", instead is "~") - //mock().expectNCalls(5, "framework_log"); - const char* filter_str2 = "(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3~attr3)))"; - get_filter = celix_filter_create(filter_str2); - POINTERS_EQUAL(NULL, get_filter); - - //test PRESENT operator with trailing chars (should just register as substrings: "*" and "attr3") - const char *filter_str3 = "(test_attr3=*attr3)"; - get_filter = celix_filter_create(filter_str3); - CHECK(get_filter != NULL); - LONGS_EQUAL(CELIX_FILTER_OPERAND_SUBSTRING, get_filter->operand); - LONGS_EQUAL(2, celix_arrayList_size((celix_array_list_t*) get_filter->children)); - celix_filter_destroy(get_filter); - - //test parsing a attribute of 0 length - //mock().expectNCalls(3, "framework_log"); - const char* filter_str4 = "(>=attr3)"; - get_filter = celix_filter_create(filter_str4); - POINTERS_EQUAL(NULL, get_filter); - - //test parsing a value of 0 length - //mock().expectOneCall("framework_log"); - const char* filter_str5 = "(test_attr3>=)"; - get_filter = celix_filter_create(filter_str5); - POINTERS_EQUAL(NULL, get_filter); - - //test parsing a value with a escaped closing bracket "\)" - const char* filter_str6 = "(test_attr3>=strWith\\)inIt)"; - get_filter = celix_filter_create(filter_str6); - CHECK(get_filter != NULL); - STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value); - celix_filter_destroy(get_filter); - - //test parsing a substring with a escaped closing bracket "\)" - const char *filter_str7 = "(test_attr3=strWith\\)inIt)"; - get_filter = celix_filter_create(filter_str7); - CHECK(get_filter != NULL); - STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value); - celix_filter_destroy(get_filter); -} - -TEST(filter, match_comparators){ - char * filter_str; - celix_filter_t * filter; - celix_properties_t *props = celix_properties_create(); - char * key = my_strdup("test_attr1"); - char * val = my_strdup("attr1"); - char * key2 = my_strdup("test_attr2"); - char * val2 = my_strdup("attr2"); - celix_properties_set(props, key, val); - celix_properties_set(props, key2, val2); - - //test AND - filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(!(test_attr3=attr3))))"); - filter = celix_filter_create(filter_str); - bool result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test AND false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(&(test_attr1=attr1)(test_attr1=attr2))"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //cleanup - celix_properties_destroy(props); - celix_filter_destroy(filter); - free(filter_str); - free(key); - free(key2); - free(val); - free(val2); - -} - -TEST(filter, match_operators){ - char * filter_str; - celix_filter_t * filter; - celix_properties_t *props = celix_properties_create(); - char * key = my_strdup("test_attr1"); - char * val = my_strdup("attr1"); - char * key2 = my_strdup("test_attr2"); - char * val2 = my_strdup("attr2"); - celix_properties_set(props, key, val); - celix_properties_set(props, key2, val2); - - //test EQUALS - filter_str = my_strdup("(test_attr1=attr1)"); - filter = celix_filter_create(filter_str); - bool result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test EQUALS false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1=falseString)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test APPROX TODO: update this test once APPROX is implemented - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1~=attr1)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test APROX false TODO: update this test once APPROX is implemented - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1~=ATTR1)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test PRESENT - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1=*)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test NOT PRESENT - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr3=*)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test NOT PRESENT - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(!(test_attr3=*))"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK_TRUE(result); - - //test LESSEQUAL less - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1<=attr5)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test LESSEQUAL equals - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2<=attr2)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test LESSEQUAL false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2<=attr1)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test GREATEREQUAL greater - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2>=attr1)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test GREATEREQUAL equals - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2>=attr2)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test GREATEREQUAL false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1>=attr5)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test LESS less - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1<attr5)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test LESS equals - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2<attr2)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test LESS false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2<attr1)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test GREATER greater - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2>attr1)"); - filter = celix_filter_create(filter_str); - result = false; - filter_match(filter, props, &result); - CHECK(result); - - //test GREATER equals - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr2>attr2)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test GREATER false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1>attr5)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //test SUBSTRING equals - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1=attr*)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK(result); - - //test SUBSTRING false - celix_filter_destroy(filter); - free(filter_str); - filter_str = my_strdup("(test_attr1=attr*charsNotPresent)"); - filter = celix_filter_create(filter_str); - result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //cleanup - celix_properties_destroy(props); - celix_filter_destroy(filter); - free(filter_str); - free(key); - free(key2); - free(val); - free(val2); - -} - -TEST(filter, match_recursion){ - - char * filter_str = my_strdup("(&(test_attr1=attr1)(|(&(test_attr2=attr2)(!(&(test_attr1=attr1)(test_attr3=attr3))))(test_attr3=attr3)))"); - celix_filter_t * filter = celix_filter_create(filter_str); - celix_properties_t *props = celix_properties_create(); - char * key = my_strdup("test_attr1"); - char * val = my_strdup("attr1"); - char * key2 = my_strdup("test_attr2"); - char * val2 = my_strdup("attr2"); - celix_properties_set(props, key, val); - celix_properties_set(props, key2, val2); - - bool result = false; - filter_match(filter, props, &result); - CHECK(result); - - //cleanup - celix_properties_destroy(props); - celix_filter_destroy(filter); - free(filter_str); - free(key); - free(key2); - free(val); - free(val2); - -} - -TEST(filter, match_false){ - char * filter_str = my_strdup("(&(test_attr1=attr1)(&(test_attr2=attr2)(test_attr3=attr3)))"); - celix_filter_t * filter = celix_filter_create(filter_str); - celix_properties_t *props = celix_properties_create(); - char * key = my_strdup("test_attr1"); - char * val = my_strdup("attr1"); - char * key2 = my_strdup("test_attr2"); - char * val2 = my_strdup("attr2"); - celix_properties_set(props, key, val); - celix_properties_set(props, key2, val2); - - bool result = true; - filter_match(filter, props, &result); - CHECK_FALSE(result); - - //cleanup - celix_properties_destroy(props); - celix_filter_destroy(filter); - free(filter_str); - free(key); - free(key2); - free(val); - free(val2); - -} - -TEST(filter, match_filter){ - - celix_filter_t *filter = celix_filter_create("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))"); - celix_filter_t *compareTo = celix_filter_create("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))"); - - bool result; - filter_match_filter(filter, compareTo, &result); //equal same order - CHECK_TRUE(result); - //cleanup - celix_filter_destroy(filter); - celix_filter_destroy(compareTo); - - filter = celix_filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr3=attr3))"); - compareTo = celix_filter_create("(&(test_attr3=attr3)(test_attr2=attr2)(test_attr1=attr1))"); - CHECK(filter != NULL); - CHECK(compareTo != NULL); - filter_match_filter(filter, compareTo, &result); //equal not same order - CHECK_TRUE(result); - //cleanup - celix_filter_destroy(filter); - celix_filter_destroy(compareTo); - - filter = celix_filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr3=attr3))"); - compareTo = celix_filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr4=attr4))"); - CHECK(filter != NULL); - CHECK(compareTo != NULL); - filter_match_filter(filter, compareTo, &result); //almost, but not equal - CHECK_FALSE(result); - //cleanup - celix_filter_destroy(filter); - celix_filter_destroy(compareTo); - - filter_match_filter(NULL, NULL, &result); //both null -> equal - CHECK_TRUE(result); - - filter = celix_filter_create("(attr1=)"); - filter_match_filter(filter, NULL, &result); //one null -> not equal - CHECK_FALSE(result); - - filter_match_filter(NULL, filter, &result); //one null -> not equal - CHECK_FALSE(result); - - celix_filter_destroy(filter); -} - -TEST(filter, getString){ - char * filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))"); - celix_filter_t * filter = celix_filter_create(filter_str); - - const char * get_str; - filter_getString(filter, &get_str); - - //cleanup - celix_filter_destroy(filter); - free(filter_str); -} - - diff --git a/libs/utils/src/filter.c b/libs/utils/src/filter.c index bf5ee47e..aebf9adc 100644 --- a/libs/utils/src/filter.c +++ b/libs/utils/src/filter.c @@ -39,6 +39,31 @@ struct celix_filter_internal { celix_version_t *versionValue; }; +//TODO remove with usage of celix_convert_utils.h if gh-476 is merged +static const char* celix_utils_eatWhitespace(const char* str) { + if (str != NULL) { + while (isspace(*str)) { + str++; + } + } + return str; +} + +//TODO remove with usage of celix_convert_utils.h if gh-476 is merged +static bool celix_utils_endptrIsEndOfStringOrOnlyWhitespace(const char* endptr) { + bool result = false; + if (endptr != NULL) { + while (*endptr != '\0') { + if (!isspace(*endptr)) { + break; + } + endptr++; + } + result = *endptr == '\0'; + } + return result; +} + //TODO replace with usage of celix_convert_utils.h if gh-476 is merged static double celix_utils_convertStringToDouble(const char* val, double defaultValue, bool* converted) { double result = defaultValue; @@ -47,8 +72,8 @@ static double celix_utils_convertStringToDouble(const char* val, double defaultV } if (val != NULL) { char *endptr; - double d = strtod(val, &endptr); - if (endptr != val && *endptr == '\0') { + double d = strtod(celix_utils_eatWhitespace(val), &endptr); + if (endptr != val && celix_utils_endptrIsEndOfStringOrOnlyWhitespace(endptr)) { result = d; if (converted) { *converted = true; @@ -66,8 +91,8 @@ static long celix_utils_convertStringToLong(const char* val, long defaultValue, } if (val != NULL) { char *endptr; - long l = strtol(val, &endptr, 10); - if (endptr != val && *endptr == '\0') { + long l = strtol(celix_utils_eatWhitespace(val), &endptr, 10); + if (endptr != val && celix_utils_endptrIsEndOfStringOrOnlyWhitespace(endptr)) { result = l; if (converted) { *converted = true; @@ -79,11 +104,11 @@ static long celix_utils_convertStringToLong(const char* val, long defaultValue, //TODO replace with usage of celix_convert_utils.h if gh-476 is merged static celix_version_t* celix_utils_convertStringToVersion(const char* val, const celix_version_t* defaultValue, bool* converted) { - celix_version_t *result = NULL; + celix_version_t* result = NULL; if (val != NULL) { //check if string has two dots ('.'), and only try to create string if it has two dots - char *firstDot = strchr(val, '.'); - char *lastDot = strrchr(val, '.'); + char* firstDot = strchr(val, '.'); + char* lastDot = strrchr(val, '.'); if (firstDot != NULL && lastDot != NULL && firstDot != lastDot) { result = celix_version_createVersionFromString(val); } @@ -649,7 +674,7 @@ static celix_status_t filter_compare(const celix_filter_t* filter, const char *p return CELIX_SUCCESS; } case CELIX_FILTER_OPERAND_APPROX: { - *out = strcasestr(propertyValue, filter->value) != NULL; + *out = strcasecmp(propertyValue, filter->value) == 0; return CELIX_SUCCESS; } case CELIX_FILTER_OPERAND_EQUAL: {
