LCOV - code coverage report
Current view: top level - app/test - test_cmdline_portlist.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 22 34 64.7 %
Date: 2024-01-22 16:26:08 Functions: 3 3 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 15 24 62.5 %

           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 <string.h>
       7                 :            : #include <inttypes.h>
       8                 :            : 
       9                 :            : #include <rte_common.h>
      10                 :            : 
      11                 :            : #include <cmdline_parse.h>
      12                 :            : #include <cmdline_parse_portlist.h>
      13                 :            : 
      14                 :            : #include "test_cmdline.h"
      15                 :            : 
      16                 :            : struct portlist_str {
      17                 :            :         const char * str;
      18                 :            :         uint32_t portmap;
      19                 :            : };
      20                 :            : 
      21                 :            : /* valid strings */
      22                 :            : const struct portlist_str portlist_valid_strs[] = {
      23                 :            :                 {"0", 0x1U },
      24                 :            :                 {"0-10", 0x7FFU},
      25                 :            :                 {"10-20", 0x1FFC00U},
      26                 :            :                 {"all", UINT32_MAX},
      27                 :            :                 {"0,1,2,3", 0xFU},
      28                 :            :                 {"0,1-5", 0x3FU},
      29                 :            :                 {"0,0,0", 0x1U},
      30                 :            :                 {"31,0-10,15", 0x800087FFU},
      31                 :            :                 {"0000", 0x1U},
      32                 :            :                 {"00,01,02,03", 0xFU},
      33                 :            :                 {"000,001,002,003", 0xFU},
      34                 :            : };
      35                 :            : 
      36                 :            : /* valid strings but with garbage at the end.
      37                 :            :  * these strings should still be valid because parser checks
      38                 :            :  * for end of token, which is either a space/tab, a newline/return,
      39                 :            :  * or a hash sign.
      40                 :            :  */
      41                 :            : 
      42                 :            : const char * portlist_garbage_strs[] = {
      43                 :            :                 "0-31 garbage",
      44                 :            :                 "0-31#garbage",
      45                 :            :                 "0-31\0garbage",
      46                 :            :                 "0-31\ngarbage",
      47                 :            :                 "0-31\rgarbage",
      48                 :            :                 "0-31\tgarbage",
      49                 :            :                 "0,1,2,3-31 garbage",
      50                 :            :                 "0,1,2,3-31#garbage",
      51                 :            :                 "0,1,2,3-31\0garbage",
      52                 :            :                 "0,1,2,3-31\ngarbage",
      53                 :            :                 "0,1,2,3-31\rgarbage",
      54                 :            :                 "0,1,2,3-31\tgarbage",
      55                 :            :                 "all garbage",
      56                 :            :                 "all#garbage",
      57                 :            :                 "all\0garbage",
      58                 :            :                 "all\ngarbage",
      59                 :            :                 "all\rgarbage",
      60                 :            :                 "all\tgarbage",
      61                 :            : };
      62                 :            : 
      63                 :            : /* invalid strings */
      64                 :            : const char * portlist_invalid_strs[] = {
      65                 :            :                 /* valid syntax, invalid chars */
      66                 :            :                 "A-B",
      67                 :            :                 "0-S",
      68                 :            :                 "1,2,3,4,Q",
      69                 :            :                 "A-4,3-15",
      70                 :            :                 "0-31invalid",
      71                 :            :                 /* valid chars, invalid syntax */
      72                 :            :                 "1, 2",
      73                 :            :                 "1- 4",
      74                 :            :                 ",2",
      75                 :            :                 ",2 ",
      76                 :            :                 "-1, 4",
      77                 :            :                 "5-1",
      78                 :            :                 "2-",
      79                 :            :                 /* misc */
      80                 :            :                 "-"
      81                 :            :                 "a",
      82                 :            :                 "A",
      83                 :            :                 ",",
      84                 :            :                 "#",
      85                 :            :                 " ",
      86                 :            :                 "\0",
      87                 :            :                 "",
      88                 :            :                 /* too long */
      89                 :            :                 "0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,"
      90                 :            :                 "0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,2",
      91                 :            : };
      92                 :            : 
      93                 :            : /* test invalid parameters */
      94                 :            : int
      95                 :          1 : test_parse_portlist_invalid_param(void)
      96                 :            : {
      97                 :            :         cmdline_portlist_t result;
      98                 :            :         char buf[CMDLINE_TEST_BUFSIZE];
      99                 :            :         int ret;
     100                 :            : 
     101                 :            :         memset(&buf, 0, sizeof(buf));
     102                 :            :         memset(&result, 0, sizeof(cmdline_portlist_t));
     103                 :            : 
     104                 :            :         /* try all null */
     105                 :          1 :         ret = cmdline_parse_portlist(NULL, NULL, NULL, 0);
     106         [ -  + ]:          1 :         if (ret != -1) {
     107                 :            :                 printf("Error: parser accepted null parameters!\n");
     108                 :          0 :                 return -1;
     109                 :            :         }
     110                 :            : 
     111                 :            :         /* try null buf */
     112                 :          1 :         ret = cmdline_parse_portlist(NULL, NULL, (void*)&result,
     113                 :            :                 sizeof(result));
     114         [ -  + ]:          1 :         if (ret != -1) {
     115                 :            :                 printf("Error: parser accepted null string!\n");
     116                 :          0 :                 return -1;
     117                 :            :         }
     118                 :            : 
     119                 :            :         /* try null result */
     120                 :          1 :         ret = cmdline_parse_portlist(NULL, portlist_valid_strs[0].str, NULL, 0);
     121         [ -  + ]:          1 :         if (ret == -1) {
     122                 :            :                 printf("Error: parser rejected null result!\n");
     123                 :          0 :                 return -1;
     124                 :            :         }
     125                 :            : 
     126                 :            :         /* token is not used in ether_parse anyway so there's no point in
     127                 :            :          * testing it */
     128                 :            : 
     129                 :            :         /* test help function */
     130                 :            : 
     131                 :            :         /* coverage! */
     132                 :          1 :         ret = cmdline_get_help_portlist(NULL, buf, sizeof(buf));
     133         [ -  + ]:          1 :         if (ret < 0) {
     134                 :            :                 printf("Error: help function failed with valid parameters!\n");
     135                 :          0 :                 return -1;
     136                 :            :         }
     137                 :            : 
     138                 :            :         return 0;
     139                 :            : }
     140                 :            : 
     141                 :            : /* test valid parameters but invalid data */
     142                 :            : int
     143                 :          1 : test_parse_portlist_invalid_data(void)
     144                 :            : {
     145                 :            :         int ret = 0;
     146                 :            :         unsigned i;
     147                 :            :         cmdline_portlist_t result;
     148                 :            : 
     149                 :            :         /* test invalid strings */
     150         [ +  + ]:         21 :         for (i = 0; i < RTE_DIM(portlist_invalid_strs); i++) {
     151                 :            : 
     152                 :            :                 memset(&result, 0, sizeof(cmdline_portlist_t));
     153                 :            : 
     154                 :         20 :                 ret = cmdline_parse_portlist(NULL, portlist_invalid_strs[i],
     155                 :            :                         (void*)&result, sizeof(result));
     156         [ -  + ]:         20 :                 if (ret != -1) {
     157                 :          0 :                         printf("Error: parsing %s succeeded!\n",
     158                 :            :                                         portlist_invalid_strs[i]);
     159                 :          0 :                         return -1;
     160                 :            :                 }
     161                 :            :         }
     162                 :            : 
     163                 :            :         return 0;
     164                 :            : }
     165                 :            : 
     166                 :            : /* test valid parameters and data */
     167                 :            : int
     168                 :          1 : test_parse_portlist_valid(void)
     169                 :            : {
     170                 :            :         int ret = 0;
     171                 :            :         unsigned i;
     172                 :            :         cmdline_portlist_t result;
     173                 :            : 
     174                 :            :         /* test full strings */
     175         [ +  + ]:         12 :         for (i = 0; i < RTE_DIM(portlist_valid_strs); i++) {
     176                 :            : 
     177                 :            :                 memset(&result, 0, sizeof(cmdline_portlist_t));
     178                 :            : 
     179                 :         11 :                 ret = cmdline_parse_portlist(NULL, portlist_valid_strs[i].str,
     180                 :            :                         (void*)&result, sizeof(result));
     181         [ -  + ]:         11 :                 if (ret < 0) {
     182                 :            :                         printf("Error: parsing %s failed!\n",
     183                 :            :                                         portlist_valid_strs[i].str);
     184                 :          0 :                         return -1;
     185                 :            :                 }
     186         [ -  + ]:         11 :                 if (result.map != portlist_valid_strs[i].portmap) {
     187                 :            :                         printf("Error: parsing %s failed: map mismatch!\n",
     188                 :            :                                         portlist_valid_strs[i].str);
     189                 :          0 :                         return -1;
     190                 :            :                 }
     191                 :            :         }
     192                 :            : 
     193                 :            :         /* test garbage strings */
     194         [ +  + ]:         19 :         for (i = 0; i < RTE_DIM(portlist_garbage_strs); i++) {
     195                 :            : 
     196                 :            :                 memset(&result, 0, sizeof(cmdline_portlist_t));
     197                 :            : 
     198                 :         18 :                 ret = cmdline_parse_portlist(NULL, portlist_garbage_strs[i],
     199                 :            :                         (void*)&result, sizeof(result));
     200         [ -  + ]:         18 :                 if (ret < 0) {
     201                 :          0 :                         printf("Error: parsing %s failed!\n",
     202                 :            :                                         portlist_garbage_strs[i]);
     203                 :          0 :                         return -1;
     204                 :            :                 }
     205         [ -  + ]:         18 :                 if (result.map != UINT32_MAX) {
     206                 :          0 :                         printf("Error: parsing %s failed: map mismatch!\n",
     207                 :            :                                         portlist_garbage_strs[i]);
     208                 :          0 :                         return -1;
     209                 :            :                 }
     210                 :            :         }
     211                 :            : 
     212                 :            :         return 0;
     213                 :            : }

Generated by: LCOV version 1.14