You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by rl...@apache.org on 2019/07/12 18:51:23 UTC
[celix] 01/02: Updated test for LDAP filter
This is an automated email from the ASF dual-hosted git repository.
rlenferink pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/celix.git
commit 9208fff4aa35f274b45702e23ab203f4e38d7c12
Author: Roy Lenferink <le...@gmail.com>
AuthorDate: Fri Jul 12 11:03:55 2019 +0200
Updated test for LDAP filter
---
libs/framework/CMakeLists.txt | 32 +-
libs/framework/private/test/filter_test.cpp | 574 ------------------
libs/utils/private/test/filter_test.cpp | 902 ++++++++++++++--------------
3 files changed, 469 insertions(+), 1039 deletions(-)
diff --git a/libs/framework/CMakeLists.txt b/libs/framework/CMakeLists.txt
index cbab5c9..97b4100 100644
--- a/libs/framework/CMakeLists.txt
+++ b/libs/framework/CMakeLists.txt
@@ -286,11 +286,10 @@ if (ENABLE_TESTING AND FRAMEWORK_TESTS)
# private/mock/celix_log_mock.c)
# target_link_libraries(service_tracker_test ${CPPUTEST_LIBRARY} ${CPPUTEST_EXT_LIBRARY} Celix::utils pthread)
-
add_executable(wire_test
- private/mock/requirement_mock.c
- private/mock/capability_mock.c
- private/mock/module_mock.c
+ private/mock/requirement_mock.c
+ private/mock/capability_mock.c
+ private/mock/module_mock.c
src/celix_errorcodes.c
private/mock/celix_log_mock.c
src/wire.c
@@ -300,51 +299,48 @@ if (ENABLE_TESTING AND FRAMEWORK_TESTS)
configure_file(private/resources-test/manifest_sections.txt ${CMAKE_CURRENT_BINARY_DIR}/resources-test/manifest_sections.txt COPYONLY)
configure_file(private/resources-test/manifest.txt ${CMAKE_CURRENT_BINARY_DIR}/resources-test/manifest.txt COPYONLY)
- #set_target_properties(wire_test PROPERTIES COMPILE_FLAGS "-include ${CPPUTEST_INCLUDE_DIR}/CppUTest/MemoryLeakDetectorMallocMacros.h -include ${CPPUTEST_INCLUDE_DIR}/CppUTest/MemoryLeakDetectorNewMacros.h")
+# set_target_properties(wire_test PROPERTIES COMPILE_FLAGS "-include ${CPPUTEST_INCLUDE_DIR}/CppUTest/MemoryLeakDetectorMallocMacros.h -include ${CPPUTEST_INCLUDE_DIR}/CppUTest/MemoryLeakDetectorNewMacros.h")
add_test(NAME attribute_test COMMAND attribute_test)
-# add_test(NAME bundle_archive_test COMMAND bundle_archive_test)
+# add_test(NAME bundle_archive_test COMMAND bundle_archive_test)
add_test(NAME bundle_cache_test COMMAND bundle_cache_test)
add_test(NAME bundle_context_test COMMAND bundle_context_test)
add_test(NAME bundle_revision_test COMMAND bundle_revision_test)
add_test(NAME bundle_test COMMAND bundle_test)
add_test(NAME capability_test COMMAND capability_test)
add_test(NAME celix_errorcodes_test COMMAND celix_errorcodes_test)
- add_test(NAME filter_test COMMAND filter_test)
add_test(NAME framework_test COMMAND framework_test)
add_test(NAME manifest_parser_test COMMAND manifest_parser_test)
add_test(NAME manifest_test COMMAND manifest_test)
-# add_test(NAME module_test COMMAND module_test)
+# add_test(NAME module_test COMMAND module_test)
add_test(NAME requirement_test COMMAND requirement_test)
-# add_test(NAME resolver_test COMMAND resolver_test)
+# add_test(NAME resolver_test COMMAND resolver_test)
add_test(NAME service_reference_test COMMAND service_reference_test)
add_test(NAME service_registration_test COMMAND service_registration_test)
add_test(NAME service_registry_test COMMAND service_registry_test)
add_test(NAME service_tracker_customizer_test COMMAND service_tracker_customizer_test)
-# add_test(NAME service_tracker_test COMMAND service_tracker_test)
-add_test(NAME wire_test COMMAND wire_test)
+# add_test(NAME service_tracker_test COMMAND service_tracker_test)
+ add_test(NAME wire_test COMMAND wire_test)
-SETUP_TARGET_FOR_COVERAGE(attribute_test attribute_test ${CMAKE_BINARY_DIR}/coverage/attribute_test/attribute_test)
-# SETUP_TARGET_FOR_COVERAGE(bundle_archive_test bundle_archive_test ${CMAKE_BINARY_DIR}/coverage/bundle_archive_test/bundle_archive_test)
+ SETUP_TARGET_FOR_COVERAGE(attribute_test attribute_test ${CMAKE_BINARY_DIR}/coverage/attribute_test/attribute_test)
+# SETUP_TARGET_FOR_COVERAGE(bundle_archive_test bundle_archive_test ${CMAKE_BINARY_DIR}/coverage/bundle_archive_test/bundle_archive_test)
SETUP_TARGET_FOR_COVERAGE(bundle_cache_test bundle_cache_test ${CMAKE_BINARY_DIR}/coverage/bundle_cache_test/bundle_cache_test)
SETUP_TARGET_FOR_COVERAGE(bundle_context_test bundle_context_test ${CMAKE_BINARY_DIR}/coverage/bundle_context_test/bundle_context_test)
SETUP_TARGET_FOR_COVERAGE(bundle_revision_test bundle_revision_test ${CMAKE_BINARY_DIR}/coverage/bundle_revision_test/bundle_revision_test)
SETUP_TARGET_FOR_COVERAGE(bundle_test bundle_test ${CMAKE_BINARY_DIR}/coverage/bundle_test/bundle_test)
SETUP_TARGET_FOR_COVERAGE(capability_test capability_test ${CMAKE_BINARY_DIR}/coverage/capability_test/capability_test)
SETUP_TARGET_FOR_COVERAGE(celix_errorcodes_test celix_errorcodes_test ${CMAKE_BINARY_DIR}/coverage/celix_errorcodes_test/celix_errorcodes_test)
- SETUP_TARGET_FOR_COVERAGE(filter_test filter_test ${CMAKE_BINARY_DIR}/coverage/filter_test/filter_test)
SETUP_TARGET_FOR_COVERAGE(framework_test framework_test ${CMAKE_BINARY_DIR}/coverage/framework_test/framework_test)
SETUP_TARGET_FOR_COVERAGE(manifest_parser_test manifest_parser_test ${CMAKE_BINARY_DIR}/coverage/manifest_parser_test/manifest_parser_test)
SETUP_TARGET_FOR_COVERAGE(manifest_test manifest_test ${CMAKE_BINARY_DIR}/coverage/manifest_test/manifest_test)
-# SETUP_TARGET_FOR_COVERAGE(module_test module_test ${CMAKE_BINARY_DIR}/coverage/module_test/module_test)
+# SETUP_TARGET_FOR_COVERAGE(module_test module_test ${CMAKE_BINARY_DIR}/coverage/module_test/module_test)
SETUP_TARGET_FOR_COVERAGE(requirement_test requirement_test ${CMAKE_BINARY_DIR}/coverage/requirement_test/requirement_test)
-# SETUP_TARGET_FOR_COVERAGE(resolver_test resolver_test ${CMAKE_BINARY_DIR}/coverage/resolver_test/resolver_test)
+# SETUP_TARGET_FOR_COVERAGE(resolver_test resolver_test ${CMAKE_BINARY_DIR}/coverage/resolver_test/resolver_test)
SETUP_TARGET_FOR_COVERAGE(service_reference_test service_reference_test ${CMAKE_BINARY_DIR}/coverage/service_reference_test/service_reference_test)
SETUP_TARGET_FOR_COVERAGE(service_registration_test service_registration_test ${CMAKE_BINARY_DIR}/coverage/service_registration_test/service_registration_test)
SETUP_TARGET_FOR_COVERAGE(service_registry_test service_registry_test ${CMAKE_BINARY_DIR}/coverage/service_registry_test/service_registry_test)
SETUP_TARGET_FOR_COVERAGE(service_tracker_customizer_test service_tracker_customizer_test ${CMAKE_BINARY_DIR}/coverage/service_tracker_customizer_test/service_tracker_customizer_test)
-# SETUP_TARGET_FOR_COVERAGE(service_tracker_test service_tracker_test ${CMAKE_BINARY_DIR}/coverage/service_tracker_test/service_tracker_test)
+# SETUP_TARGET_FOR_COVERAGE(service_tracker_test service_tracker_test ${CMAKE_BINARY_DIR}/coverage/service_tracker_test/service_tracker_test)
SETUP_TARGET_FOR_COVERAGE(wire_test wire_test ${CMAKE_BINARY_DIR}/coverage/wire_test/wire_test)
endif (ENABLE_TESTING AND FRAMEWORK_TESTS)
-
diff --git a/libs/framework/private/test/filter_test.cpp b/libs/framework/private/test/filter_test.cpp
deleted file mode 100644
index df7255e..0000000
--- a/libs/framework/private/test/filter_test.cpp
+++ /dev/null
@@ -1,574 +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 "CppUTestExt/MockSupport.h"
-
-extern "C" {
-#include "celix_log.h"
-#include "filter.h"
-
-framework_logger_pt logger = (framework_logger_pt) 0x42;
-}
-
-int main(int argc, char** argv) {
- 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) {
- }
-
- void teardown() {
- mock().clear();
- }
-};
-
-//----------------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 = filter_create(filter_str);
- CHECK(get_filter != NULL);
-
- filter_destroy(get_filter);
-
- //cleanup
- free(filter_str);
-
- mock().checkExpectations();
-}
-
-TEST(filter, create_fail_missing_opening_brackets){
- celix_filter_t * get_filter;
-
- mock().ignoreOtherCalls();
-
- //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 = filter_create(filter_str1);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //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 = filter_create(filter_str2);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //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 = filter_create(filter_str3);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //test missing opening brackets in NOT comparator
- //mock().expectNCalls(4, "framework_log");
- const char *filter_str4 = "(&(test_attr1=attr1)(!test_attr2=attr2)";
- get_filter = filter_create(filter_str4);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-}
-
-TEST(filter, create_fail_missing_closing_brackets){
- char * filter_str;
- celix_filter_t * get_filter;
- //test missing closing brackets in substring
- mock().expectNCalls(5, "framework_log");
- filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3");
- get_filter = filter_create(filter_str);
- POINTERS_EQUAL(NULL, get_filter);
- free(filter_str);
- mock().checkExpectations();
-
- //test missing closing brackets in value
- mock().expectNCalls(4, "framework_log");
- filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=attr3");
- get_filter = filter_create(filter_str);
- POINTERS_EQUAL(NULL, get_filter);
- free(filter_str);
- mock().checkExpectations();
-}
-
-TEST(filter, create_fail_invalid_closing_brackets){
- char * filter_str;
- celix_filter_t * get_filter;
-
- mock().ignoreOtherCalls();
-
- //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 = filter_create(filter_str);
- POINTERS_EQUAL(NULL, get_filter);
- free(filter_str);
- mock().checkExpectations();
-
- //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 = filter_create(filter_str);
- POINTERS_EQUAL(NULL, get_filter);
- free(filter_str);
- mock().checkExpectations();
-}
-
-TEST(filter, create_misc){
- celix_filter_t * get_filter;
-
- mock().ignoreOtherCalls();
-
- //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 = filter_create(filter_str1);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //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 = filter_create(filter_str2);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //test PRESENT operator with trailing chars (should just register as substrings: "*" and "attr3")
- const char *filter_str3 = "(test_attr3=*attr3)";
- get_filter = filter_create(filter_str3);
- CHECK(get_filter != NULL);
- LONGS_EQUAL(CELIX_FILTER_OPERAND_SUBSTRING, get_filter->operand)
- LONGS_EQUAL(2, arrayList_size((array_list_pt) get_filter->children));
- filter_destroy(get_filter);
- mock().checkExpectations();
-
- //test parsing a attribute of 0 length
- //mock().expectNCalls(3, "framework_log");
- const char* filter_str4 = "(>=attr3)";
- get_filter = filter_create(filter_str4);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //test parsing a value of 0 length
- //mock().expectOneCall("framework_log");
- const char* filter_str5 = "(test_attr3>=)";
- get_filter = filter_create(filter_str5);
- POINTERS_EQUAL(NULL, get_filter);
- mock().checkExpectations();
-
- //test parsing a value with a escaped closing bracket "\)"
- const char* filter_str6 = "(test_attr3>=strWith\\)inIt)";
- get_filter = filter_create(filter_str6);
- CHECK(get_filter != NULL);
- STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value);
- filter_destroy(get_filter);
- mock().checkExpectations();
-
- //test parsing a substring with a escaped closing bracket "\)"
- const char *filter_str7 = "(test_attr3=strWith\\)inIt)";
- get_filter = filter_create(filter_str7);
- CHECK(get_filter != NULL);
- STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value);
- filter_destroy(get_filter);
- mock().checkExpectations();
-}
-
-TEST(filter, match_comparators){
- char * filter_str;
- celix_filter_t * filter;
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- //test AND
- filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(!(test_attr3=attr3))))");
- filter = filter_create(filter_str);
- bool result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test AND false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(&(test_attr1=attr1)(test_attr1=attr2))");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
-
- mock().checkExpectations();
-}
-
-TEST(filter, match_operators){
- char * filter_str;
- celix_filter_t * filter;
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- //test EQUALS
- filter_str = my_strdup("(test_attr1=attr1)");
- filter = filter_create(filter_str);
- bool result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test EQUALS false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=falseString)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test APPROX TODO: update this test once APPROX is implemented
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1~=attr1)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test APROX false TODO: update this test once APPROX is implemented
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1~=ATTR1)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test PRESENT
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=*)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test PRESENT false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr3=*)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test LESSEQUAL less
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1<=attr5)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test LESSEQUAL equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<=attr2)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test LESSEQUAL false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<=attr1)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test GREATEREQUAL greater
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>=attr1)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test GREATEREQUAL equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>=attr2)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test GREATEREQUAL false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1>=attr5)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test LESS less
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1<attr5)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test LESS equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<attr2)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test LESS false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<attr1)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test GREATER greater
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>attr1)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test GREATER equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>attr2)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test GREATER false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1>attr5)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test SUBSTRING equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=attr*)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test SUBSTRING false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=attr*charsNotPresent)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
-
- mock().checkExpectations();
-}
-
-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 = filter_create(filter_str);
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- bool result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
-
- mock().checkExpectations();
-}
-
-TEST(filter, match_false){
- char * filter_str = my_strdup("(&(test_attr1=attr1)(&(test_attr2=attr2)(test_attr3=attr3)))");
- celix_filter_t * filter = filter_create(filter_str);
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- bool result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
-
- mock().checkExpectations();
-}
-
-TEST(filter, match_filter){
- mock().ignoreOtherCalls(); //only log
-
- celix_filter_t *filter = filter_create("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
- celix_filter_t *compareTo = 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
- filter_destroy(filter);
- filter_destroy(compareTo);
-
- filter = filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr3=attr3))");
- compareTo = 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
- filter_destroy(filter);
- filter_destroy(compareTo);
-
- filter = filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr3=attr3))");
- compareTo = 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
- filter_destroy(filter);
- filter_destroy(compareTo);
-
- filter_match_filter(NULL, NULL, &result); //both null -> equal
- CHECK_TRUE(result);
-
- filter = 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);
-
- filter_destroy(filter);
-}
-
-TEST(filter, getString){
- char * filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
- celix_filter_t * filter = filter_create(filter_str);
-
- const char * get_str;
- filter_getString(filter, &get_str);
-
- //cleanup
- filter_destroy(filter);
- free(filter_str);
-
- mock().checkExpectations();
-}
-
-
diff --git a/libs/utils/private/test/filter_test.cpp b/libs/utils/private/test/filter_test.cpp
index c42c8f1..696e69d 100644
--- a/libs/utils/private/test/filter_test.cpp
+++ b/libs/utils/private/test/filter_test.cpp
@@ -1,20 +1,20 @@
/**
- *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
+ * 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
+ * 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.
+ * 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>
@@ -29,509 +29,517 @@
#include "filter.h"
int main(int argc, char** argv) {
- return RUN_ALL_TESTS(argc, argv);
+ return RUN_ALL_TESTS(argc, argv);
}
static char* my_strdup(const char* s){
- if(s==NULL){
- return NULL;
- }
+ if (s == NULL) {
+ return NULL;
+ }
- size_t len = strlen(s);
+ size_t len = strlen(s);
- char *d = (char*) calloc (len + 1,sizeof(char));
+ char *d = (char *) calloc (len + 1,sizeof(char));
- if (d == NULL){
- return NULL;
- }
+ if (d == NULL) {
+ return NULL;
+ }
- strncpy (d,s,len);
- return d;
+ strncpy(d,s,len);
+ return d;
}
//----------------TESTGROUPS----------------
TEST_GROUP(filter) {
- void setup(void) {
- }
+ void setup() {
+ }
- void teardown() {
- }
+ 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;
+ char * filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
+ celix_filter_t * get_filter;
- get_filter = filter_create(filter_str);
- CHECK(get_filter != NULL);
+ get_filter = celix_filter_create(filter_str);
+ CHECK(get_filter != NULL);
- filter_destroy(get_filter);
+ celix_filter_destroy(get_filter);
- //cleanup
- free(filter_str);
+ //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 = 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 = 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 = 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 = filter_create(filter_str4);
- POINTERS_EQUAL(NULL, get_filter);
+ 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 = 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 = filter_create(filter_str);
- POINTERS_EQUAL(NULL, get_filter);
- free(filter_str);
+ 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 = 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 = filter_create(filter_str);
- POINTERS_EQUAL(NULL, get_filter);
- free(filter_str);
+ 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 = 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 = 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 = 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));
- filter_destroy(get_filter);
-
- //test parsing a attribute of 0 length
- //mock().expectNCalls(3, "framework_log");
- const char* filter_str4 = "(>=attr3)";
- get_filter = 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 = 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 = filter_create(filter_str6);
- CHECK(get_filter != NULL);
- STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value);
- filter_destroy(get_filter);
-
- //test parsing a substring with a escaped closing bracket "\)"
- const char *filter_str7 = "(test_attr3=strWith\\)inIt)";
- get_filter = filter_create(filter_str7);
- CHECK(get_filter != NULL);
- STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value);
- filter_destroy(get_filter);
+ 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;
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- //test AND
- filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(!(test_attr3=attr3))))");
- filter = filter_create(filter_str);
- bool result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test AND false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(&(test_attr1=attr1)(test_attr1=attr2))");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
+ 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
+ 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;
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- //test EQUALS
- filter_str = my_strdup("(test_attr1=attr1)");
- filter = filter_create(filter_str);
- bool result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test EQUALS false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=falseString)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test APPROX TODO: update this test once APPROX is implemented
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1~=attr1)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test APROX false TODO: update this test once APPROX is implemented
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1~=ATTR1)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test PRESENT
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=*)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test PRESENT false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr3=*)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test LESSEQUAL less
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1<=attr5)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test LESSEQUAL equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<=attr2)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test LESSEQUAL false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<=attr1)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test GREATEREQUAL greater
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>=attr1)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test GREATEREQUAL equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>=attr2)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test GREATEREQUAL false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1>=attr5)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test LESS less
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1<attr5)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test LESS equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<attr2)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test LESS false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2<attr1)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test GREATER greater
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>attr1)");
- filter = filter_create(filter_str);
- result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test GREATER equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr2>attr2)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test GREATER false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1>attr5)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //test SUBSTRING equals
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=attr*)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //test SUBSTRING false
- filter_destroy(filter);
- free(filter_str);
- filter_str = my_strdup("(test_attr1=attr*charsNotPresent)");
- filter = filter_create(filter_str);
- result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
+ 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
+ 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 = filter_create(filter_str);
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- bool result = false;
- filter_match(filter, props, &result);
- CHECK(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
+ 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 = filter_create(filter_str);
- properties_pt props = properties_create();
- char * key = my_strdup("test_attr1");
- char * val = my_strdup("attr1");
- char * key2 = my_strdup("test_attr2");
- char * val2 = my_strdup("attr2");
- properties_set(props, key, val);
- properties_set(props, key2, val2);
-
- bool result = true;
- filter_match(filter, props, &result);
- CHECK_FALSE(result);
-
- //cleanup
- properties_destroy(props);
- filter_destroy(filter);
- free(filter_str);
- free(key);
- free(key2);
- free(val);
- free(val2);
+ 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 = filter_create("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
- celix_filter_t *compareTo = filter_create("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
+ 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
+ bool result;
+ filter_match_filter(filter, compareTo, &result); //equal same order
CHECK_TRUE(result);
- //cleanup
- filter_destroy(filter);
- filter_destroy(compareTo);
-
- filter = filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr3=attr3))");
- compareTo = filter_create("(&(test_attr3=attr3)(test_attr2=attr2)(test_attr1=attr1))");
- CHECK(filter != NULL);
- CHECK(compareTo != NULL);
+ //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
- filter_destroy(filter);
- filter_destroy(compareTo);
+ celix_filter_destroy(filter);
+ celix_filter_destroy(compareTo);
- filter = filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr3=attr3))");
- compareTo = filter_create("(&(test_attr1=attr1)(test_attr2=attr2)(test_attr4=attr4))");
- CHECK(filter != NULL);
- CHECK(compareTo != NULL);
+ 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
- filter_destroy(filter);
- filter_destroy(compareTo);
+ celix_filter_destroy(filter);
+ celix_filter_destroy(compareTo);
- filter_match_filter(NULL, NULL, &result); //both null -> equal
- CHECK_TRUE(result);
+ filter_match_filter(NULL, NULL, &result); //both null -> equal
+ CHECK_TRUE(result);
- filter = filter_create("(attr1=)");
- filter_match_filter(filter, NULL, &result); //one null -> not equal
- CHECK_FALSE(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);
+ filter_match_filter(NULL, filter, &result); //one null -> not equal
+ CHECK_FALSE(result);
- filter_destroy(filter);
+ 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 = filter_create(filter_str);
+ 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
- filter_destroy(filter);
- free(filter_str);
+ const char * get_str;
+ filter_getString(filter, &get_str);
+ //cleanup
+ celix_filter_destroy(filter);
+ free(filter_str);
}