src/tests/fdi_logger_neg.c

   1 /*
   2  * Copyright (c) 2019-2020, Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "fdi_logger_wrap.c"
  18
  19 int main()
  20 {
  21         struct fd_info fdi = {
  22                 .fd = -1,
  23                 .priv_data = NULL,
  24         };
  25         list_head used_paths = NULL;
  26
  27         ops_logger.destroy(&fdi);
  28
  29         fail_malloc = 1;
  30         assert(-ENOMEM == ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  31
  32         open_buf_ret = -536;
  33         assert(-536 == ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  34         open_buf_ret = 0;
  35         assert(-EINVAL == ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  36
  37         open_buf_path = "abc";
  38         open_buf_ret = 1;
  39         fail_malloc = 2;
  40         assert(-ENOMEM == ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  41         assert(fdi.fd < 0);
  42         assert(!fdi.priv_data);
  43
  44         fail_calloc = true;
  45         assert(-ENOMEM == ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  46         assert(fdi.fd < 0);
  47         assert(!fdi.priv_data);
  48         fail_calloc = false;
  49
  50         assert(!ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  51         ops_logger.destroy(&fdi);
  52         fdi.fd = -1;
  53
  54         assert(-EALREADY == ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  55         assert(fdi.fd == -1);
  56         assert(!fdi.priv_data);
  57
  58         open_buf_path = "def";
  59         assert(!ops_logger.create(&fdi, (struct log_config *) 0xABDUL, LOG_ID_RADIO, &used_paths, &(log_id_t){ LOG_ID_INVALID }));
  60
  61         expected_ioctl = LOGGER_FLUSH_LOG;
  62         ioctl_ret = -77;
  63         assert(-77 == ops_logger.clear(&fdi));
  64
  65         unsigned int us, sz;
  66         expected_ioctl = LOGGER_GET_LOG_BUF_SIZE;
  67         ioctl_ret = -EALREADY;
  68         assert(-EALREADY == ops_logger.get_capacity(&fdi, &sz));
  69         assert(-EALREADY == ops_logger.get_usage(&fdi, &us));
  70
  71         expected_ioctl = LOGGER_GET_LOG_LEN;
  72         ioctl_ret = -67;
  73         assert(-67 == ops_logger.prepare_print(&fdi, 123, false, (struct log_filter *) 0xCA5CADE));
  74
  75         expected_ioctl = -1;
  76         assert(!ops_logger.prepare_print(&fdi, 0, false, (struct log_filter *) 0xCA5CADE));
  77
  78         fail_read = true;
  79         assert(-334 == ops_logger.read(&fdi));
  80         fail_read = false;
  81
  82         for (size_t i = 0; i < NELEMS(READS) + 15; ++i) {
  83                 assert(!ops_logger.has_log(&fdi));
  84                 fail_read = true;
  85                 assert(NULL == ops_logger.extract_entry(&fdi));
  86                 assert(NULL == ops_logger.peek_entry(&fdi));
  87                 assert(NULL == ops_logger.extract_entry(&fdi));
  88                 fail_read = false;
  89                 fail_malloc = !(rand() % 4) * 3;
  90                 ops_logger.read(&fdi);
  91                 if (!fail_malloc && i < NELEMS(READS) && READS[i] > sizeof(struct android_logger_entry)) {
  92                         assert(ops_logger.has_log(&fdi));
  93                         assert(-EAGAIN == ops_logger.read(&fdi));
  94                         const dlogutil_entry_s *const le = ops_logger.peek_entry(&fdi);
  95                         assert(le);
  96                         assert(le == ops_logger.peek_entry(&fdi));
  97                         fail_read = true;
  98                         assert(le == ops_logger.extract_entry(&fdi));
  99                         fail_read = false;
 100                         free((dlogutil_entry_s *) le);
 101                 }
 102                 fail_malloc = 0;
 103                 assert(!ops_logger.has_log(&fdi));
 104                 assert(NULL == ops_logger.peek_entry(&fdi));
 105                 fail_read = true;
 106                 assert(NULL == ops_logger.extract_entry(&fdi));
 107                 fail_read = false;
 108         }
 109
 110         ops_logger.destroy(&fdi);
 111 }