Rename log_filter to dlogutil_filter_options

This also changes the namespace, as log_filter used to be a typedef, but
dlogutil_filter_options is just a normal struct.

Change-Id: I7a0aed07fd8ec0318e07269307c65d09d66e65fe

diff --git a/include/fd_info.h b/include/fd_info.h
index d1940ee..1566551 100644 (file)
--- a/include/fd_info.h
+++ b/include/fd_info.h
@@ -54,7 +54,7 @@ struct fd_ops {
 
        /// Transition into a state that allows reading and printing out logs
        /// Return values > 0 mean everything went fine but we don't want to print
-       int (*prepare_print)(struct fd_info *fdi, int dump, log_filter *filter_object);
+       int (*prepare_print)(struct fd_info *fdi, int dump, struct dlogutil_filter_options *filter_object);
 
        /// Clear the buffer
        int (*clear)(struct fd_info *fdi);
@@ -70,6 +70,6 @@ struct fd_info *fdi_create(struct fd_ops *ops, const char *name);
 void fdi_free(struct fd_info *fdi);
 void fdi_array_free(struct fd_info ***arr);
 bool fdi_has_log(struct fd_info *fdi);
-int fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, log_filter *filter);
+int fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, struct dlogutil_filter_options *filter);
 struct dlogutil_entry *fdi_extract_entry(struct fd_info *fdi);
 int fdi_read(struct fd_info *fdi);

diff --git a/include/logprint.h b/include/logprint.h
index 109dafe..b87d010 100644 (file)
--- a/include/logprint.h
+++ b/include/logprint.h
@@ -52,16 +52,14 @@ struct log_format {
        bool color;
 };
 
-typedef struct log_filter_t log_filter;
+struct dlogutil_filter_options *log_filter_new();
 
-log_filter *log_filter_new();
-
-void log_filter_free(log_filter *p_filter);
+void log_filter_free(struct dlogutil_filter_options *p_filter);
 
 /**
  * Returns a deep copy of the passed object.
  */
-log_filter *log_filter_from_filter(const log_filter *p_filter);
+struct dlogutil_filter_options *log_filter_from_filter(const struct dlogutil_filter_options *p_filter);
 
 /**
  * Returns FORMAT_OFF on invalid string
@@ -78,7 +76,7 @@ log_print_format log_format_from_string(const char *s);
  *
  */
 
-int log_add_filter_rule(log_filter *p_filter, const char *filterExpression);
+int log_add_filter_rule(struct dlogutil_filter_options *p_filter, const char *filterExpression);
 
 /**
  * filterString: a whitespace-separated set of filter expressions
@@ -90,7 +88,7 @@ int log_add_filter_rule(log_filter *p_filter, const char *filterExpression);
  *
  */
 
-int log_add_filter_string(log_filter *p_filter, const char *filterString);
+int log_add_filter_string(struct dlogutil_filter_options *p_filter, const char *filterString);
 
 
 /**
@@ -105,7 +103,7 @@ int log_add_filter_string(log_filter *p_filter, const char *filterString);
  *
  */
 
-int log_add_filter_pid(log_filter *p_filter, pid_t pid);
+int log_add_filter_pid(struct dlogutil_filter_options *p_filter, pid_t pid);
 
 
 /**
@@ -120,9 +118,9 @@ int log_add_filter_pid(log_filter *p_filter, pid_t pid);
  *
  */
 
-int log_add_filter_tid(log_filter *p_filter, pid_t tid);
+int log_add_filter_tid(struct dlogutil_filter_options *p_filter, pid_t tid);
 
-void log_filter_clear(log_filter *p_filter);
+void log_filter_clear(struct dlogutil_filter_options *p_filter);
 
 struct tag_and_prio {
        char *tag;
@@ -145,16 +143,16 @@ typedef struct FilterInfo_t {
        };
 } FilterInfo;
 
-list_head log_filter_get_list(log_filter *p_filter);
+list_head log_filter_get_list(struct dlogutil_filter_options *p_filter);
 
-log_priority log_filter_get_global_priority(log_filter *p_filter, bool *is_exact);
+log_priority log_filter_get_global_priority(struct dlogutil_filter_options *p_filter, bool *is_exact);
 
 /**
  * returns true if this log line should be printed based on its entry
  * data (priority, tag, pid and tid), and false if it should not
  */
 bool log_should_print_line(
-               log_filter *p_filter, const struct dlogutil_entry *entry);
+               struct dlogutil_filter_options *p_filter, const struct dlogutil_entry *entry);
 
 /**
  * Returns pointer to log entry tag

diff --git a/include/logretrieve.h b/include/logretrieve.h
index 024ddf1..ed1daa8 100644 (file)
--- a/include/logretrieve.h
+++ b/include/logretrieve.h
@@ -4,7 +4,7 @@
 #include <logconfig.h>
 
 struct additional_options {
-       log_filter *filter_object;
+       struct dlogutil_filter_options *filter_object;
        size_t logs_dump;
        size_t logs_size;
 };

diff --git a/src/logger/logger_internal.h b/src/logger/logger_internal.h
index 5fda29a..3c64d46 100644 (file)
--- a/src/logger/logger_internal.h
+++ b/src/logger/logger_internal.h
@@ -136,7 +136,7 @@ typedef int (*service_reader_t)(struct reader *reader);
 struct reader {
        struct fd_entity   fd_entity;
        struct log_file    file;
-       log_filter*        filter;
+       struct dlogutil_filter_options*        filter;
        struct log_buffer* buf_ptr;
        int                read_fd;
        bool               dumpcount;

diff --git a/src/shared/fd_info.c b/src/shared/fd_info.c
index 478aa1a..053dcd3 100644 (file)
--- a/src/shared/fd_info.c
+++ b/src/shared/fd_info.c
@@ -76,7 +76,7 @@ void fdi_array_free(struct fd_info ***arr)
        free(*arr);
 }
 
-int fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, log_filter *filter)
+int fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, struct dlogutil_filter_options *filter)
 {
        assert(fdi);
        assert(userdata);

diff --git a/src/shared/fdi_logger.c b/src/shared/fdi_logger.c
index c3fd6f6..fd358a5 100644 (file)
--- a/src/shared/fdi_logger.c
+++ b/src/shared/fdi_logger.c
@@ -159,7 +159,7 @@ static void logger_destroy(struct fd_info *fdi)
        fdi->priv_data = NULL;
 }
 
-static int logger_prepare_print(struct fd_info *fdi, int dump, log_filter *filter_object)
+static int logger_prepare_print(struct fd_info *fdi, int dump, struct dlogutil_filter_options *filter_object)
 {
        assert(fdi);
        struct logger_priv_data *const lpd = (struct logger_priv_data *)fdi->priv_data;

diff --git a/src/shared/fdi_pipe.c b/src/shared/fdi_pipe.c
index d75db46..8bd1353 100644 (file)
--- a/src/shared/fdi_pipe.c
+++ b/src/shared/fdi_pipe.c
@@ -77,7 +77,7 @@ static int pipe_clear(struct fd_info *fdi)
  * @param[in] sock_fd Socket file descriptor
  * @return 0 on success, -errno on failure
  */
-static int send_logger_request(log_filter *filters, int dump, int sock_fd)
+static int send_logger_request(struct dlogutil_filter_options *filters, int dump, int sock_fd)
 {
        assert(filters);
        assert(sock_fd >= 0);
@@ -192,7 +192,7 @@ static void pipe_destroy(struct fd_info *fdi)
        fdi->priv_data = NULL;
 }
 
-static int pipe_prepare_print(struct fd_info *fdi, int dump, log_filter *filter_object)
+static int pipe_prepare_print(struct fd_info *fdi, int dump, struct dlogutil_filter_options *filter_object)
 {
        assert(filter_object);
        assert(fdi);

diff --git a/src/shared/logprint.c b/src/shared/logprint.c
index 254d2b4..5352518 100644 (file)
--- a/src/shared/logprint.c
+++ b/src/shared/logprint.c
@@ -32,7 +32,7 @@
 #define FILTERINFO_PID_NONE -1
 #define FILTERINFO_TID_NONE -1
 
-struct log_filter_t {
+struct dlogutil_filter_options {
        list_head filters;
        log_priority global_pri;
        bool exact_global_pri;
@@ -201,7 +201,7 @@ char filter_pri_to_char(log_priority pri)
  * @param[in] entry The log entry to filter
  * @return True if the line should be printed, else false
  */
-bool log_should_print_line(log_filter *p_filter, const struct dlogutil_entry *entry)
+bool log_should_print_line(struct dlogutil_filter_options *p_filter, const struct dlogutil_entry *entry)
 {
        assert(p_filter);
        assert(entry);
@@ -267,11 +267,11 @@ bool log_should_print_line(log_filter *p_filter, const struct dlogutil_entry *en
  * @return The new structure (or NULL if allocation failed).
  * @see log_filter_free
  */
-log_filter *log_filter_new(void)
+struct dlogutil_filter_options *log_filter_new(void)
 {
-       log_filter *p_ret;
+       struct dlogutil_filter_options *p_ret;
 
-       p_ret = calloc(1, sizeof(log_filter));
+       p_ret = calloc(1, sizeof(struct dlogutil_filter_options));
 
        if (!p_ret)
                return NULL;
@@ -288,9 +288,9 @@ log_filter *log_filter_new(void)
  * @return The new structure (or NULL if allocation failed)
  * @see log_filter_free
  */
-log_filter *log_filter_from_filter(const log_filter *p_filter)
+struct dlogutil_filter_options *log_filter_from_filter(const struct dlogutil_filter_options *p_filter)
 {
-       log_filter *p_ret;
+       struct dlogutil_filter_options *p_ret;
 
        if (!(p_ret = log_filter_new()))
                return NULL;
@@ -313,7 +313,7 @@ log_filter *log_filter_from_filter(const log_filter *p_filter)
  * @details Deallocates the entire log format structure
  * @param[in] p_format The structure to deallocate
  */
-void log_filter_free(log_filter *p_filter)
+void log_filter_free(struct dlogutil_filter_options *p_filter)
 {
        if (p_filter) {
                log_filter_clear(p_filter);
@@ -322,7 +322,7 @@ void log_filter_free(log_filter *p_filter)
        }
 }
 
-void log_filter_clear(log_filter *p_filter)
+void log_filter_clear(struct dlogutil_filter_options *p_filter)
 {
        assert(p_filter);
 
@@ -331,14 +331,14 @@ void log_filter_clear(log_filter *p_filter)
        p_filter->exact_global_pri = false;
 }
 
-list_head log_filter_get_list(log_filter *p_filter)
+list_head log_filter_get_list(struct dlogutil_filter_options *p_filter)
 {
        assert(p_filter);
 
        return p_filter->filters;
 }
 
-log_priority log_filter_get_global_priority(log_filter *p_filter, bool *is_exact)
+log_priority log_filter_get_global_priority(struct dlogutil_filter_options *p_filter, bool *is_exact)
 {
        assert(is_exact);
        assert(p_filter);
@@ -388,7 +388,7 @@ log_print_format log_format_from_string(const char *formatString)
  * @return 0 on success, else -1
  * @remarks Assumes single threaded execution
  */
-int log_add_filter_rule(log_filter *p_filter,
+int log_add_filter_rule(struct dlogutil_filter_options *p_filter,
                const char *filterExpression)
 {
        size_t tagNameLength, priPosition;
@@ -465,7 +465,7 @@ error:
  * @return 0 on success, else -1
  * @remarks Assumes single threaded execution
  */
-int log_add_filter_string(log_filter *p_filter,
+int log_add_filter_string(struct dlogutil_filter_options *p_filter,
                const char *filterString)
 {
        assert(p_filter);
@@ -504,7 +504,7 @@ error:
  * @return 0 on success, else -ENOMEM
  * @remarks Assumes single threaded execution
  */
-int log_add_filter_pid(log_filter *p_filter, pid_t pid)
+int log_add_filter_pid(struct dlogutil_filter_options *p_filter, pid_t pid)
 {
        assert(p_filter);
 
@@ -523,7 +523,7 @@ int log_add_filter_pid(log_filter *p_filter, pid_t pid)
  * @return 0 on success, else -ENOMEM
  * @remarks Assumes single threaded execution
  */
-int log_add_filter_tid(log_filter *p_filter, pid_t tid)
+int log_add_filter_tid(struct dlogutil_filter_options *p_filter, pid_t tid)
 {
        assert(p_filter);
 

diff --git a/src/shared/logretrieve.c b/src/shared/logretrieve.c
index c4d3626..6f7e5a4 100644 (file)
--- a/src/shared/logretrieve.c
+++ b/src/shared/logretrieve.c
@@ -117,7 +117,7 @@ struct fd_info *find_earliest_log(struct fd_info **data_fds, int fd_count, enum
        return best_fdi;
 }
 
-int put_logs_into_vector(struct fd_info **data_fds, int fd_count, int nfds, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, log_filter *filter)
+int put_logs_into_vector(struct fd_info **data_fds, int fd_count, int nfds, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, struct dlogutil_filter_options *filter)
 {
        assert(data_fds);
        assert(logs);

diff --git a/src/tests/fd_info.c b/src/tests/fd_info.c
index fcb856f..dbd159f 100644 (file)
--- a/src/tests/fd_info.c
+++ b/src/tests/fd_info.c
@@ -81,9 +81,9 @@ void test_destroy(struct fd_info *fdi)
 }
 
 static bool should_print_line = true;
-bool __wrap_log_should_print_line(log_filter *p_filter, const struct dlogutil_entry *entry)
+bool __wrap_log_should_print_line(struct dlogutil_filter_options *p_filter, const struct dlogutil_entry *entry)
 {
-       assert(p_filter == (log_filter *)404);
+       assert(p_filter == (struct dlogutil_filter_options *)404);
        assert(entry == (struct dlogutil_entry *)0xBADFEEL);
        return should_print_line;
 }
@@ -151,23 +151,23 @@ int main()
 
        should_print_line = false;
        expect_free1 = (void *) 0xBADFEEL;
-       assert(0 == fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(0 == fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        should_print_line = true;
 
        fail_extract = true;
-       assert(-ENOMEM == fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(-ENOMEM == fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        fail_extract = false;
 
        sv.size = 99;
        expect_free1 = NULL;
-       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(sv_pushed);
        assert(!sv_flushed);
        sv_pushed = false;
 
        sv_push_retval = -83;
        expect_free1 = &G_fdi;
-       assert(-83 == fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(-83 == fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(sv_pushed);
        assert(!sv_flushed);
        sv_push_retval = 0;
@@ -175,31 +175,31 @@ int main()
        sv.old_logs_dumped = false;
        sv.start.tv_sec = 2;
        sv.start.tv_nsec = 0;
-       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(!sv.old_logs_dumped);
 
        sv.old_logs_dumped = false;
        sv.start.tv_sec = 1;
        sv.start.tv_nsec = 1;
-       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(!sv.old_logs_dumped);
 
        sv.old_logs_dumped = false;
        sv.start.tv_sec = 1;
        sv.start.tv_nsec = 0;
-       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(sv.old_logs_dumped);
 
        sv.old_logs_dumped = false;
        sv.start.tv_sec = 0;
        sv.start.tv_nsec = 2;
-       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(sv.old_logs_dumped);
 
        sv_pushed = false;
        sv.size = 0;
        expect_free1 = (void *) 0xBADFEEL;
-       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (log_filter *) 404));
+       assert(!fdi_push_log(&G_fdi, &sv, callback, (void *) 0xDEFACED, (struct dlogutil_filter_options *) 404));
        assert(!sv_pushed);
        assert(sv_flushed);
 

diff --git a/src/tests/fdi_logger.c b/src/tests/fdi_logger.c
index c8ad86c..17ede4b 100644 (file)
--- a/src/tests/fdi_logger.c
+++ b/src/tests/fdi_logger.c
@@ -22,10 +22,10 @@ int __wrap_logger_open_buffer_from_config_get_path(int buf_id, const struct log_
 
 static size_t filters_added;
 static char *const filter_strs[] = {"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne"};
-int __wrap_log_add_filter_string(log_filter *p_filter, const char *filterString)
+int __wrap_log_add_filter_string(struct dlogutil_filter_options *p_filter, const char *filterString)
 {
        assert(filterString);
-       assert(p_filter == (log_filter *) 0xCA5CADE);
+       assert(p_filter == (struct dlogutil_filter_options *) 0xCA5CADE);
 
        ++filters_added;
        for (size_t i = 0; i < NELEMS(filter_strs); ++i)
@@ -180,14 +180,14 @@ int main()
        assert(2019 == sz);
 
        expected_ioctl = -1;
-       assert(!ops_logger.prepare_print(&fdi, DLOGUTIL_MODE_CONTINUOUS, (log_filter *) 0xCA5CADE));
+       assert(!ops_logger.prepare_print(&fdi, DLOGUTIL_MODE_CONTINUOUS, (struct dlogutil_filter_options *) 0xCA5CADE));
 
        expected_ioctl = LOGGER_GET_LOG_LEN;
        ioctl_ret = -67;
-       assert(-67 == ops_logger.prepare_print(&fdi, 123, (log_filter *) 0xCA5CADE));
+       assert(-67 == ops_logger.prepare_print(&fdi, 123, (struct dlogutil_filter_options *) 0xCA5CADE));
        expected_ioctl = LOGGER_GET_LOG_LEN;
        ioctl_ret = 0;
-       assert(1 == ops_logger.prepare_print(&fdi, 123, (log_filter *) 0xCA5CADE));
+       assert(1 == ops_logger.prepare_print(&fdi, 123, (struct dlogutil_filter_options *) 0xCA5CADE));
 
        fail_read = true;
        assert(-334 == ops_logger.read(&fdi));

diff --git a/src/tests/fdi_pipe.c b/src/tests/fdi_pipe.c
index 980e777..8e9e07c 100644 (file)
--- a/src/tests/fdi_pipe.c
+++ b/src/tests/fdi_pipe.c
@@ -132,7 +132,7 @@ int main()
 
        assert(!ops_pipe.has_log(&info));
 
-       log_filter *filter = log_filter_new();
+       struct dlogutil_filter_options *filter = log_filter_new();
        assert(filter);
        log_add_filter_string(filter, "filter0");
 

diff --git a/src/tests/filters.c b/src/tests/filters.c
index f18d416..dee1fb8 100644 (file)
--- a/src/tests/filters.c
+++ b/src/tests/filters.c
@@ -29,7 +29,7 @@ int pid_tid_filter_list[] = {
  * @param[in] expected The expected result returned by log_should_print_line function
  * @return 0 if the log_should_print_line returns the expected result, 1 otherwise
  */
-int check_print_line_tid_single(int line, log_filter *p_filter, pthread_t tid, bool expected)
+int check_print_line_tid_single(int line, struct dlogutil_filter_options *p_filter, pthread_t tid, bool expected)
 {
        struct dlogutil_entry_with_msg entry;
 
@@ -58,7 +58,7 @@ int check_print_line_tid_single(int line, log_filter *p_filter, pthread_t tid, b
  * @return Number of tids for which log_should_print_line returns wrong answer
  */
 
-int check_print_line_tid(int line, log_filter *p_filter, pthread_t tid)
+int check_print_line_tid(int line, struct dlogutil_filter_options *p_filter, pthread_t tid)
 {
        int result = 0;
        for (int tid_no = 0; tid_no < NELEMS(pid_tid_filter_list); tid_no++)
@@ -75,7 +75,7 @@ int check_print_line_tid(int line, log_filter *p_filter, pthread_t tid)
  * @param[in] expected The expected result returned by log_should_print_line function
  * @return 0 if the log_should_print_line returns the expected result, 1 otherwise
  */
-int check_print_line_pid_single(int line, log_filter *p_filter, pid_t pid, bool expected)
+int check_print_line_pid_single(int line, struct dlogutil_filter_options *p_filter, pid_t pid, bool expected)
 {
        struct dlogutil_entry_with_msg entry;
 
@@ -104,7 +104,7 @@ int check_print_line_pid_single(int line, log_filter *p_filter, pid_t pid, bool
  * @return Number of pids for which log_should_print_line returns wrong answer
  */
 
-int check_print_line_pid(int line, log_filter *p_filter, pid_t pid)
+int check_print_line_pid(int line, struct dlogutil_filter_options *p_filter, pid_t pid)
 {
        int result = 0;
        for (int pid_no = 0; pid_no < NELEMS(pid_tid_filter_list); pid_no++)
@@ -122,7 +122,7 @@ int check_print_line_pid(int line, log_filter *p_filter, pid_t pid)
  * @param[in] expected The expected result returned by log_should_print_line function
  * @return 0 if the log_should_print_line returns the expected result, 1 otherwise
  */
-int check_print_line_tag_prior(int line, log_filter *p_filter, char *tag, int priority, bool expected)
+int check_print_line_tag_prior(int line, struct dlogutil_filter_options *p_filter, char *tag, int priority, bool expected)
 {
        struct dlogutil_entry_with_msg entry;
 
@@ -151,7 +151,7 @@ int check_print_line_tag_prior(int line, log_filter *p_filter, char *tag, int pr
  * @return Number of priorities for which log_should_print_line returns wrong answer
  */
 
-int check_print_line_tag(int line, log_filter *p_filter, char *tag, int priors)
+int check_print_line_tag(int line, struct dlogutil_filter_options *p_filter, char *tag, int priors)
 {
        int result = 0;
        result += check_print_line_tag_prior(line, p_filter, tag, DLOG_VERBOSE, (priors & verbose) > 0);
@@ -168,7 +168,7 @@ int main()
        int err;
        int result = 0;
        char *tag, *tag_short, *tag_middle, *tag_long;
-       log_filter *p_filter;
+       struct dlogutil_filter_options *p_filter;
        struct dlogutil_entry_with_msg entry;
 
        entry.header.tid = 0;

diff --git a/src/tests/logprint.c b/src/tests/logprint.c
index 063a34c..d6b4b62 100644 (file)
--- a/src/tests/logprint.c
+++ b/src/tests/logprint.c
@@ -525,13 +525,13 @@ void check_isatty_detection()
 
 void check_syscall_failure_handling()
 {
-       log_filter *const filter = log_filter_new();
+       struct dlogutil_filter_options *const filter = log_filter_new();
        assert(filter);
        assert(!log_add_filter_tid(filter, 123));
        assert(!log_add_filter_pid(filter, 456));
        assert(!log_add_filter_rule(filter, "FOO:E"));
 
-       log_filter *const clone = log_filter_from_filter(filter);
+       struct dlogutil_filter_options *const clone = log_filter_from_filter(filter);
        assert(clone);
        log_filter_free(clone);
 
@@ -598,7 +598,7 @@ void check_invalid_input()
        assert(!log_buffer_get_message(&entry));
        assert(!log_buffer_get_tag(&entry));
 
-       log_filter *const filter = log_filter_new();
+       struct dlogutil_filter_options *const filter = log_filter_new();
        assert(filter);
        assert(-1 == log_add_filter_rule(filter, ":D")); // >mfw tagless rule gets processed correctly
        log_filter_free(filter);

diff --git a/src/tests/logutil.c b/src/tests/logutil.c
index 03d2c8d..4efdc56 100644 (file)
--- a/src/tests/logutil.c
+++ b/src/tests/logutil.c
@@ -8,7 +8,7 @@
 
 bool process_log(const struct dlogutil_entry *e, struct timespec reference_ts, enum dlogutil_sorting_order stamp_type, dlogutil_write_callback callback, void *userdata, long timeout, int *callback_ret);
 struct fd_info *find_earliest_log(struct fd_info **data_fds, int fd_count, enum dlogutil_sorting_order sort_by);
-int put_logs_into_vector(struct fd_info **data_fds, int fd_count, int nfds, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, log_filter *filter);
+int put_logs_into_vector(struct fd_info **data_fds, int fd_count, int nfds, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, struct dlogutil_filter_options *filter);
 int validate_buffers(int *enabled_buffers);
 
 int written_logs = 0;
@@ -33,7 +33,7 @@ int __wrap_clock_gettime(clockid_t clk_id, struct timespec *tp)
        return 0;
 }
 
-bool __wrap_log_should_print_line(log_filter *p_filter, const struct dlogutil_entry *entry)
+bool __wrap_log_should_print_line(struct dlogutil_filter_options *p_filter, const struct dlogutil_entry *entry)
 {
        return true;
 }
@@ -57,9 +57,9 @@ const struct dlogutil_entry *test_peek_entry(const struct fd_info *fdi)
 }
 
 int fdi_push_log_ret = 0;
-int __wrap_fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, log_filter *filter)
+int __wrap_fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, dlogutil_write_callback callback, void *userdata, struct dlogutil_filter_options *filter)
 {
-       assert(filter == (log_filter *)0xEEE);
+       assert(filter == (struct dlogutil_filter_options *)0xEEE);
        if (fdi_push_log_ret != 0)
                return fdi_push_log_ret;
        struct dlogutil_entry *ent = calloc(1, sizeof(struct dlogutil_entry));
@@ -195,16 +195,16 @@ int main()
        assert(written_logs == 1);
        assert(sort_vector_used_size(&sv) == 0);
 
-       assert(put_logs_into_vector(fds, 0, 1, &sv, callback, (void *)0xDDD, (log_filter *)0xEEE) == 0);
+       assert(put_logs_into_vector(fds, 0, 1, &sv, callback, (void *)0xDDD, (struct dlogutil_filter_options *)0xEEE) == 0);
 
        fdi_push_log_ret = -EIO;
-       assert(put_logs_into_vector(fds, 10, 1, &sv, callback, (void *)0xDDD, (log_filter *)0xEEE) == -EIO);
+       assert(put_logs_into_vector(fds, 10, 1, &sv, callback, (void *)0xDDD, (struct dlogutil_filter_options *)0xEEE) == -EIO);
 
        fdi_push_log_ret = 0;
-       assert(put_logs_into_vector(fds, 10, 1, &sv, callback, (void *)0xDDD, (log_filter *)0xEEE) == 0);
+       assert(put_logs_into_vector(fds, 10, 1, &sv, callback, (void *)0xDDD, (struct dlogutil_filter_options *)0xEEE) == 0);
        assert(sort_vector_used_size(&sv) == 1);
 
-       assert(put_logs_into_vector(fds, 10, 0, &sv, callback, (void *)0xDDD, (log_filter *)0xEEE) == 0);
+       assert(put_logs_into_vector(fds, 10, 0, &sv, callback, (void *)0xDDD, (struct dlogutil_filter_options *)0xEEE) == 0);
        assert(sort_vector_used_size(&sv) == 7);
 
        int buf = 0;