src/tests/logutil.c

   1 #include <stdbool.h>
   2
   3 #include <queued_entry.h>
   4 #include <log_file.h>
   5 #include <dlog-internal.h>
   6 #include <sort_vector.h>
   7 #include "../libdlogutil/fd_info.h"
   8
   9 bool process_log(const dlogutil_entry_s *e, struct timespec reference_ts, dlogutil_sorting_order_e stamp_type, long timeout, int *callback_ret);
  10 struct fd_info *find_earliest_log(struct fd_info **data_fds, int fd_count, dlogutil_sorting_order_e sort_by);
  11 int put_logs_into_vector(struct fd_info **data_fds, int fd_count, struct sort_vector *logs, struct log_filter *filter, bool limited_dump, bool *at_least_one_buffer_drained, bool *all_buffers_empty, dlogutil_entry_s **entry_out);
  12
  13 int __wrap_clock_gettime(clockid_t clk_id, struct timespec *tp)
  14 {
  15         assert(clk_id == CLOCK_MONOTONIC);
  16
  17         tp->tv_sec  = 1;
  18         tp->tv_nsec = 900000000;
  19         return 0;
  20 }
  21
  22 bool __wrap_log_should_print_line(struct log_filter *p_filter, const dlogutil_entry_s *entry)
  23 {
  24         return true;
  25 }
  26
  27 struct fdi_internal
  28 {
  29         bool has_log;
  30         const dlogutil_entry_s *ent;
  31 };
  32
  33 bool test_has_log(struct fd_info *fdi)
  34 {
  35         struct fdi_internal *ii = fdi->priv_data;
  36         return ii->has_log;
  37 }
  38
  39 const dlogutil_entry_s *test_peek_entry(const struct fd_info *fdi)
  40 {
  41         struct fdi_internal *ii = fdi->priv_data;
  42         return ii->ent;
  43 }
  44
  45 int fdi_push_log_ret = 0;
  46 int __wrap_fdi_push_log(struct fd_info *fdi, struct sort_vector *logs, bool limited_dump, dlogutil_entry_s **entry_out, struct log_filter *filter)
  47 {
  48         assert(filter == (struct log_filter *)0xEEE);
  49         if (fdi_push_log_ret != 0)
  50                 return fdi_push_log_ret;
  51         dlogutil_entry_s *ent = calloc(1, sizeof(*ent));
  52         assert(ent);
  53         memcpy(ent, fdi->ops->peek_entry(fdi), sizeof(*ent));
  54         struct fdi_internal *ii = fdi->priv_data;
  55         ii->has_log = false;
  56
  57         *entry_out = NULL;
  58         if (sort_vector_full(logs)) {
  59                 if (!limited_dump)
  60                         *entry_out = sort_vector_pop_ret(logs);
  61                 else
  62                         sort_vector_pop(logs);
  63         }
  64         sort_vector_push(logs, ent);
  65         return 0;
  66 }
  67
  68 int main(void)
  69 {
  70         struct sort_vector sv;
  71         sort_vector_init(&sv);
  72         sv.sort_by = DLOGUTIL_SORT_SENT_MONO;
  73         sv.timeout = 60;
  74         sv.size = DEFAULT_SORT_BUFFER_SIZE;
  75         sort_vector_finalize(&sv);
  76         assert(sort_vector_time_span(&sv, (struct timespec) { .tv_nsec = -1, }) == 0);
  77
  78         for (int i = 0; i < 10; ++i) {
  79                 dlogutil_entry_s *ent2 = calloc(1, sizeof(*ent2));
  80                 assert(ent2);
  81                 ent2->sec_sent_mono = 1;
  82                 ent2->nsec_sent_mono = (79 + i) * 10000000;
  83                 sort_vector_push(&sv, ent2);
  84         }
  85
  86         assert(sort_vector_time_span(&sv, (struct timespec) { .tv_nsec = -1, }) == 110);
  87
  88         dlogutil_entry_s *ent3 = calloc(1, sizeof(*ent3));
  89         assert(ent3);
  90         ent3->sec_sent_mono = 0;
  91         ent3->nsec_sent_mono = 999999999;
  92         sort_vector_push(&sv, ent3);
  93         assert(sort_vector_time_span(&sv, (struct timespec) { .tv_nsec = -1, }) == 900);
  94
  95         struct fd_ops test_ops = {
  96                 .has_log = test_has_log,
  97                 .peek_entry = test_peek_entry,
  98         };
  99
 100         struct fd_info fd_stor[10] = {};
 101         struct fdi_internal ii_stor[10] = {};
 102         dlogutil_entry_s ent_stor[10 - 3] = {};
 103         for (int i = 0; i < 10; ++i) {
 104                 if (i < 3)
 105                         ii_stor[i].has_log = false;
 106                 else {
 107                         ent_stor[i - 3].sec_sent_mono = i % 2;
 108                         ent_stor[i - 3].nsec_sent_mono = i;
 109
 110                         ii_stor[i].has_log = true;
 111                         ii_stor[i].ent = &ent_stor[i - 3];
 112                 }
 113
 114                 int t = i * 3 % 10;
 115                 fd_stor[i].ops = &test_ops;
 116                 fd_stor[i].priv_data = &ii_stor[t];
 117         }
 118
 119         struct fd_info *fds[10] = {};
 120         for (int i = 0; i < 10; ++i) {
 121                 fds[i] = &fd_stor[i];
 122         }
 123         assert(!find_earliest_log(fds, 0, DLOGUTIL_SORT_SENT_MONO));
 124         assert(find_earliest_log(fds, 10, DLOGUTIL_SORT_SENT_MONO) == fds[8]);
 125
 126         while (!sort_vector_empty(&sv))
 127                 sort_vector_pop(&sv);
 128
 129         dlogutil_entry_s *vector_overflown = NULL;
 130         bool need_epoll = false, all_drained = false;
 131         assert(put_logs_into_vector(fds, 0, &sv, (struct log_filter *)0xEEE, false, &need_epoll, &all_drained, &vector_overflown) == 0);
 132         assert(!vector_overflown);
 133         assert(all_drained);
 134         assert(need_epoll);
 135
 136         fdi_push_log_ret = -EIO;
 137         assert(put_logs_into_vector(fds, 10, &sv, (struct log_filter *)0xEEE, false, &need_epoll, &all_drained, &vector_overflown) == -EIO);
 138         assert(!vector_overflown);
 139
 140         fdi_push_log_ret = 0;
 141         all_drained = false;
 142         need_epoll = false;
 143         assert(put_logs_into_vector(fds, 10, &sv, (struct log_filter *)0xEEE, false, &need_epoll, &all_drained, &vector_overflown) == 0);
 144         assert(!vector_overflown);
 145         assert(sort_vector_used_size(&sv) == 1);
 146         assert(!all_drained);
 147         assert(need_epoll);
 148
 149         sort_vector_free(&sv);
 150 }