LCOV - code coverage report
Current view: top level - app/test - test_logs.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 48 50 96.0 %
Date: 2024-12-01 18:57:19 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 21 42 50.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2010-2014 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <stdio.h>
       6                 :            : #include <stdint.h>
       7                 :            : #include <stdarg.h>
       8                 :            : #include <sys/queue.h>
       9                 :            : 
      10                 :            : #include <rte_log.h>
      11                 :            : #include <rte_memory.h>
      12                 :            : #include <rte_launch.h>
      13                 :            : #include <rte_eal.h>
      14                 :            : #include <rte_per_lcore.h>
      15                 :            : #include <rte_lcore.h>
      16                 :            : 
      17                 :            : #include "test.h"
      18                 :            : 
      19                 :            : /* for legacy log test */
      20                 :            : #define RTE_LOGTYPE_TESTAPP1 RTE_LOGTYPE_USER1
      21                 :            : #define RTE_LOGTYPE_TESTAPP2 RTE_LOGTYPE_USER2
      22                 :            : 
      23         [ -  + ]:        251 : RTE_LOG_REGISTER(logtype3, logtype3, ERR)
      24                 :            : 
      25                 :            : /*
      26                 :            :  * Logs
      27                 :            :  * ====
      28                 :            :  *
      29                 :            :  * - Enable log types.
      30                 :            :  * - Set log level.
      31                 :            :  * - Send logs with different types and levels, some should not be displayed.
      32                 :            :  */
      33                 :            : static int
      34                 :          1 : test_legacy_logs(void)
      35                 :            : {
      36                 :            :         printf("== static log types\n");
      37                 :            : 
      38                 :            :         /* set logtype level low to so we can test global level */
      39                 :          1 :         rte_log_set_level(RTE_LOGTYPE_TESTAPP1, RTE_LOG_DEBUG);
      40                 :          1 :         rte_log_set_level(RTE_LOGTYPE_TESTAPP2, RTE_LOG_DEBUG);
      41                 :            : 
      42                 :            :         /* log in error level */
      43                 :          1 :         rte_log_set_global_level(RTE_LOG_ERR);
      44                 :          1 :         RTE_LOG(ERR, TESTAPP1, "error message\n");
      45                 :          1 :         RTE_LOG(CRIT, TESTAPP1, "critical message\n");
      46                 :            : 
      47                 :            :         /* log in critical level */
      48                 :          1 :         rte_log_set_global_level(RTE_LOG_CRIT);
      49                 :          1 :         RTE_LOG(ERR, TESTAPP2, "error message (not displayed)\n");
      50                 :          1 :         RTE_LOG(CRIT, TESTAPP2, "critical message\n");
      51                 :            : 
      52                 :            :         /* bump up single log type level above global to test it */
      53                 :          1 :         rte_log_set_level(RTE_LOGTYPE_TESTAPP2, RTE_LOG_EMERG);
      54                 :            : 
      55                 :            :         /* log in error level */
      56                 :          1 :         rte_log_set_global_level(RTE_LOG_ERR);
      57                 :          1 :         RTE_LOG(ERR, TESTAPP1, "error message\n");
      58                 :          1 :         RTE_LOG(ERR, TESTAPP2, "error message (not displayed)\n");
      59                 :            : 
      60                 :          1 :         return 0;
      61                 :            : }
      62                 :            : 
      63                 :            : static int
      64                 :          1 : test_logs(void)
      65                 :            : {
      66                 :            :         int logtype1, logtype2;
      67                 :            :         int ret;
      68                 :            : 
      69                 :            : #define CHECK_LEVELS(exp1, exp2, exp3) do \
      70                 :            : { \
      71                 :            :         ret = rte_log_get_level(logtype1); \
      72                 :            :         TEST_ASSERT_EQUAL(ret, exp1, \
      73                 :            :                 "invalid level for logtype1 got %d, expecting %d\n", \
      74                 :            :                 ret, exp1); \
      75                 :            :         ret = rte_log_get_level(logtype2); \
      76                 :            :         TEST_ASSERT_EQUAL(ret, exp2, \
      77                 :            :                 "invalid level for logtype2 got %d, expecting %d\n", \
      78                 :            :                 ret, exp2); \
      79                 :            :         ret = rte_log_get_level(logtype3); \
      80                 :            :         TEST_ASSERT_EQUAL(ret, exp3, \
      81                 :            :                 "invalid level for logtype3 got %d, expecting %d\n", \
      82                 :            :                 ret, exp3); \
      83                 :            : } while (0)
      84                 :            : 
      85                 :            :         printf("== dynamic log types\n");
      86                 :            : 
      87                 :          1 :         logtype1 = rte_log_register("logtype1");
      88         [ -  + ]:          1 :         if (logtype1 < 0) {
      89                 :            :                 printf("Cannot register logtype1\n");
      90                 :          0 :                 return -1;
      91                 :            :         }
      92                 :          1 :         logtype2 = rte_log_register("logtype2");
      93         [ -  + ]:          1 :         if (logtype2 < 0) {
      94                 :            :                 printf("Cannot register logtype2\n");
      95                 :          0 :                 return -1;
      96                 :            :         }
      97                 :            : 
      98                 :          1 :         ret = rte_log_get_level(logtype1);
      99         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(ret, RTE_LOG_INFO,
     100                 :            :                 "invalid default level for logtype1 got %d, expecting %d\n",
     101                 :            :                 ret, RTE_LOG_INFO);
     102                 :            : 
     103                 :          1 :         ret = rte_log_get_level(logtype2);
     104         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(ret, RTE_LOG_INFO,
     105                 :            :                 "invalid default level for logtype2 got %d, expecting %d\n",
     106                 :            :                 ret, RTE_LOG_INFO);
     107                 :            : 
     108                 :          1 :         ret = rte_log_get_level(logtype3);
     109         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(ret, RTE_LOG_ERR,
     110                 :            :                 "invalid default level for logtype3 got %d, expecting %d\n",
     111                 :            :                 ret, RTE_LOG_ERR);
     112                 :            : 
     113                 :          1 :         rte_log_set_level(logtype1, RTE_LOG_ERR);
     114   [ -  +  -  +  :          1 :         CHECK_LEVELS(RTE_LOG_ERR, RTE_LOG_INFO, RTE_LOG_ERR);
                   -  + ]
     115                 :            : 
     116                 :            : #ifndef RTE_EXEC_ENV_WINDOWS
     117                 :          1 :         rte_log_set_level_regexp("type$", RTE_LOG_EMERG);
     118   [ -  +  -  +  :          1 :         CHECK_LEVELS(RTE_LOG_ERR, RTE_LOG_INFO, RTE_LOG_ERR);
                   -  + ]
     119                 :            : 
     120                 :          1 :         rte_log_set_level_regexp("type[23]", RTE_LOG_EMERG);
     121   [ -  +  -  +  :          1 :         CHECK_LEVELS(RTE_LOG_ERR, RTE_LOG_EMERG, RTE_LOG_EMERG);
                   -  + ]
     122                 :            : 
     123                 :          1 :         rte_log_set_level_pattern("logtype", RTE_LOG_DEBUG);
     124   [ -  +  -  +  :          1 :         CHECK_LEVELS(RTE_LOG_ERR, RTE_LOG_EMERG, RTE_LOG_EMERG);
                   -  + ]
     125                 :            : #else
     126                 :            :         rte_log_set_level_pattern("logtype", RTE_LOG_DEBUG);
     127                 :            :         CHECK_LEVELS(RTE_LOG_ERR, RTE_LOG_INFO, RTE_LOG_ERR);
     128                 :            : #endif
     129                 :            : 
     130                 :            :         /* set logtype level low to so we can test global level */
     131                 :          1 :         rte_log_set_level_pattern("logtype*", RTE_LOG_DEBUG);
     132   [ -  +  -  +  :          1 :         CHECK_LEVELS(RTE_LOG_DEBUG, RTE_LOG_DEBUG, RTE_LOG_DEBUG);
                   -  + ]
     133                 :            : 
     134                 :            :         /* log in error level */
     135                 :          1 :         rte_log_set_global_level(RTE_LOG_ERR);
     136                 :          1 :         rte_log(RTE_LOG_ERR, logtype1, "error message\n");
     137                 :          1 :         rte_log(RTE_LOG_CRIT, logtype1, "critical message\n");
     138                 :            : 
     139                 :            :         /* log in critical level */
     140                 :          1 :         rte_log_set_global_level(RTE_LOG_CRIT);
     141                 :          1 :         rte_log(RTE_LOG_ERR, logtype2, "error message (not displayed)\n");
     142                 :          1 :         rte_log(RTE_LOG_CRIT, logtype2, "critical message\n");
     143                 :            : 
     144                 :            :         /* bump up single log type level above global to test it */
     145                 :          1 :         rte_log_set_level(logtype2, RTE_LOG_EMERG);
     146                 :            : 
     147                 :            :         /* log in error level */
     148                 :          1 :         rte_log_set_global_level(RTE_LOG_ERR);
     149                 :          1 :         rte_log(RTE_LOG_ERR, logtype1, "error message\n");
     150                 :          1 :         rte_log(RTE_LOG_ERR, logtype2, "error message (not displayed)\n");
     151                 :            : 
     152                 :          1 :         ret = test_legacy_logs();
     153                 :            :         if (ret < 0)
     154                 :            :                 return ret;
     155                 :            : 
     156                 :            : #undef CHECK_LEVELS
     157                 :            : 
     158                 :            :         return 0;
     159                 :            : }
     160                 :            : 
     161                 :        251 : REGISTER_FAST_TEST(logs_autotest, true, true, test_logs);

Generated by: LCOV version 1.14