app/test/test_cmdline_lib.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <stdio.h>
   7 #include <stdint.h>
   8 #include <stdarg.h>
   9 #include <stdlib.h>
  10 #include <errno.h>
  11 #include <termios.h>
  12 #include <ctype.h>
  13 #include <sys/queue.h>
  14
  15 #include <rte_common.h>
  16
  17 #include <cmdline_vt100.h>
  18 #include <cmdline_rdline.h>
  19 #include <cmdline_parse.h>
  20 #include <cmdline_socket.h>
  21 #include <cmdline.h>
  22
  23 #include "test_cmdline.h"
  24
  25 /****************************************************************/
  26 /* static functions required for some tests */
  27 static void
  28 valid_buffer(__rte_unused struct rdline *rdl,
  29                         __rte_unused const char *buf,
  30                         __rte_unused unsigned int size)
  31 {
  32 }
  33
  34 static int
  35 complete_buffer(__rte_unused struct rdline *rdl,
  36                         __rte_unused const char *buf,
  37                         __rte_unused char *dstbuf,
  38                         __rte_unused unsigned int dstsize,
  39                         __rte_unused int *state)
  40 {
  41         return 0;
  42 }
  43
  44 /****************************************************************/
  45
  46 static int
  47 test_cmdline_parse_fns(void)
  48 {
  49         struct cmdline *cl;
  50         cmdline_parse_ctx_t ctx;
  51         int i = 0;
  52         char dst[CMDLINE_TEST_BUFSIZE];
  53
  54         cl = cmdline_new(&ctx, "prompt", -1, -1);
  55         if (cl == NULL) {
  56                 printf("Error: cannot create cmdline to test parse fns!\n");
  57                 return -1;
  58         }
  59
  60         if (cmdline_parse(NULL, "buffer") >= 0)
  61                 goto error;
  62         if (cmdline_parse(cl, NULL) >= 0)
  63                 goto error;
  64
  65         if (cmdline_complete(NULL, "buffer", &i, dst, sizeof(dst)) >= 0)
  66                 goto error;
  67         if (cmdline_complete(cl, NULL, &i, dst, sizeof(dst)) >= 0)
  68                 goto error;
  69         if (cmdline_complete(cl, "buffer", NULL, dst, sizeof(dst)) >= 0)
  70                 goto error;
  71         if (cmdline_complete(cl, "buffer", &i, NULL, sizeof(dst)) >= 0)
  72                 goto error;
  73
  74         cmdline_free(cl);
  75         return 0;
  76
  77 error:
  78         printf("Error: function accepted null parameter!\n");
  79         cmdline_free(cl);
  80         return -1;
  81 }
  82
  83 static int
  84 test_cmdline_rdline_fns(void)
  85 {
  86         struct rdline *rdl;
  87         rdline_write_char_t *wc = &cmdline_write_char;
  88         rdline_validate_t *v = &valid_buffer;
  89         rdline_complete_t *c = &complete_buffer;
  90
  91         rdl = rdline_new(NULL, v, c, NULL);
  92         if (rdl != NULL)
  93                 goto error;
  94         rdl = rdline_new(wc, NULL, c, NULL);
  95         if (rdl != NULL)
  96                 goto error;
  97         rdl = rdline_new(wc, v, NULL, NULL);
  98         if (rdl != NULL)
  99                 goto error;
 100         if (rdline_char_in(NULL, 0) >= 0)
 101                 goto error;
 102         if (rdline_get_buffer(NULL) != NULL)
 103                 goto error;
 104         if (rdline_add_history(NULL, "history") >= 0)
 105                 goto error;
 106         if (rdline_add_history(rdl, NULL) >= 0)
 107                 goto error;
 108         if (rdline_get_history_item(NULL, 0) != NULL)
 109                 goto error;
 110
 111         /* void functions */
 112         rdline_get_history_buffer_size(NULL);
 113         rdline_get_opaque(NULL);
 114         rdline_newline(NULL, "prompt");
 115         rdline_newline(rdl, NULL);
 116         rdline_stop(NULL);
 117         rdline_quit(NULL);
 118         rdline_restart(NULL);
 119         rdline_redisplay(NULL);
 120         rdline_reset(NULL);
 121         rdline_clear_history(NULL);
 122         rdline_free(NULL);
 123
 124         rdline_free(rdl);
 125         return 0;
 126
 127 error:
 128         printf("Error: function accepted null parameter!\n");
 129         rdline_free(rdl);
 130         return -1;
 131 }
 132
 133 static int
 134 test_cmdline_vt100_fns(void)
 135 {
 136         if (vt100_parser(NULL, 0) >= 0) {
 137                 printf("Error: function accepted null parameter!\n");
 138                 return -1;
 139         }
 140
 141         /* void functions */
 142         vt100_init(NULL);
 143
 144         return 0;
 145 }
 146
 147 static int
 148 test_cmdline_socket_fns(void)
 149 {
 150         cmdline_parse_ctx_t ctx;
 151         struct cmdline *cl;
 152
 153         cl = cmdline_stdin_new(NULL, "prompt");
 154         if (cl != NULL)
 155                 goto error;
 156         cl = cmdline_stdin_new(&ctx, NULL);
 157         if (cl != NULL)
 158                 goto error;
 159         cl = cmdline_file_new(NULL, "prompt", "/dev/null");
 160         if (cl != NULL)
 161                 goto error;
 162         cl = cmdline_file_new(&ctx, NULL, "/dev/null");
 163         if (cl != NULL)
 164                 goto error;
 165         cl = cmdline_file_new(&ctx, "prompt", NULL);
 166         if (cl != NULL)
 167                 goto error;
 168         cl = cmdline_file_new(&ctx, "prompt", "-/invalid/~/path");
 169         if (cl != NULL) {
 170                 printf("Error: succeeded in opening invalid file for reading!");
 171                 cmdline_free(cl);
 172                 return -1;
 173         }
 174         cl = cmdline_file_new(&ctx, "prompt", "/dev/null");
 175         if (cl == NULL) {
 176                 printf("Error: failed to open /dev/null for reading!");
 177                 return -1;
 178         }
 179         cmdline_free(cl);
 180         cl = NULL;
 181
 182         /* void functions */
 183         cmdline_stdin_exit(NULL);
 184
 185         return 0;
 186 error:
 187         printf("Error: function accepted null parameter!\n");
 188         cmdline_free(cl);
 189         return -1;
 190 }
 191
 192 static int
 193 test_cmdline_fns(void)
 194 {
 195         cmdline_parse_ctx_t ctx;
 196         struct cmdline *cl;
 197
 198         memset(&ctx, 0, sizeof(ctx));
 199         cl = cmdline_new(NULL, "prompt", 0, 0);
 200         if (cl != NULL)
 201                 goto error;
 202         cl = cmdline_new(&ctx, NULL, 0, 0);
 203         if (cl != NULL)
 204                 goto error;
 205         cl = cmdline_new(&ctx, "test", -1, -1);
 206         if (cl == NULL)
 207                 goto error;
 208         if (cmdline_in(NULL, "buffer", CMDLINE_TEST_BUFSIZE) >= 0)
 209                 goto error;
 210         if (cmdline_in(cl, NULL, CMDLINE_TEST_BUFSIZE) >= 0)
 211                 goto error;
 212         if (cmdline_write_char(NULL, 0) >= 0)
 213                 goto error;
 214
 215         /* void functions */
 216         cmdline_set_prompt(NULL, "prompt");
 217         cmdline_free(NULL);
 218         cmdline_printf(NULL, "format");
 219         cmdline_interact(NULL);
 220         cmdline_quit(NULL);
 221
 222         cmdline_free(cl);
 223         return 0;
 224
 225 error:
 226         printf("Error: function accepted null parameter!\n");
 227         if (cl != NULL)
 228                 cmdline_free(cl);
 229         return -1;
 230 }
 231
 232 /* test library functions. the point of these tests is not so much to test
 233  * functions' behaviour as it is to make sure there are no segfaults if
 234  * they are called with invalid parameters.
 235  */
 236 int
 237 test_cmdline_lib(void)
 238 {
 239         if (test_cmdline_parse_fns() < 0)
 240                 return -1;
 241         if (test_cmdline_rdline_fns() < 0)
 242                 return -1;
 243         if (test_cmdline_vt100_fns() < 0)
 244                 return -1;
 245         if (test_cmdline_socket_fns() < 0)
 246                 return -1;
 247         if (test_cmdline_fns() < 0)
 248                 return -1;
 249         return 0;
 250 }