Interactive command line
M: Olivier Matz <olivier.matz@6wind.com>
F: lib/librte_cmdline/
-F: test/cmdline_test/
+F: app/test-cmdline/
F: test/test/test_cmdline*
F: examples/cmdline/
F: doc/guides/sample_app_ug/cmd_line.rst
DIRS-$(CONFIG_RTE_TEST_PMD) += test-pmd
DIRS-$(CONFIG_RTE_PROC_INFO) += proc-info
DIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += pdump
+DIRS-$(CONFIG_RTE_LIBRTE_CMDLINE) += test-cmdline
ifeq ($(CONFIG_RTE_LIBRTE_BBDEV),y)
DIRS-$(CONFIG_RTE_TEST_BBDEV) += test-bbdev
# SPDX-License-Identifier: BSD-3-Clause
# Copyright(c) 2017 Intel Corporation
-apps = ['pdump',
+apps = [
+ 'pdump',
'proc-info',
'test-bbdev',
+ 'test-cmdline',
'test-compress-perf',
'test-crypto-perf',
'test-eventdev',
--- /dev/null
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2010-2014 Intel Corporation
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+ifeq ($(CONFIG_RTE_LIBRTE_CMDLINE),y)
+
+#
+# library name
+#
+APP = cmdline_test
+
+#
+# all sources are stored in SRCS-y
+#
+SRCS-y += cmdline_test.c
+SRCS-y += commands.c
+
+CFLAGS += -O3
+CFLAGS += $(WERROR_FLAGS)
+
+include $(RTE_SDK)/mk/rte.app.mk
+
+endif
--- /dev/null
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <termios.h>
+#include <ctype.h>
+#include <sys/queue.h>
+
+#include <cmdline_rdline.h>
+#include <cmdline_parse.h>
+#include <cmdline_socket.h>
+#include <cmdline.h>
+
+#include "cmdline_test.h"
+
+int
+main(int __attribute__((unused)) argc, char __attribute__((unused)) ** argv)
+{
+ struct cmdline *cl;
+
+ cl = cmdline_stdin_new(main_ctx, "CMDLINE_TEST>>");
+ if (cl == NULL) {
+ return -1;
+ }
+ cmdline_interact(cl);
+ cmdline_stdin_exit(cl);
+
+ return 0;
+}
--- /dev/null
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
+ */
+
+#ifndef _CMDLINE_TEST_H_
+#define _CMDLINE_TEST_H_
+
+extern cmdline_parse_ctx_t main_ctx[];
+
+#endif
--- /dev/null
+#!/usr/bin/env python
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2010-2014 Intel Corporation
+
+# Script that runs cmdline_test app and feeds keystrokes into it.
+from __future__ import print_function
+import cmdline_test_data
+import os
+import pexpect
+import sys
+
+
+#
+# function to run test
+#
+def runTest(child, test):
+ child.send(test["Sequence"])
+ if test["Result"] is None:
+ return 0
+ child.expect(test["Result"], 1)
+
+
+#
+# history test is a special case
+#
+# This test does the following:
+# 1) fills the history with garbage up to its full capacity
+# (just enough to remove last entry)
+# 2) scrolls back history to the very beginning
+# 3) checks if the output is as expected, that is, the first
+# number in the sequence (not the last entry before it)
+#
+# This is a self-contained test, it needs only a pexpect child
+#
+def runHistoryTest(child):
+ # find out history size
+ child.sendline(cmdline_test_data.CMD_GET_BUFSIZE)
+ child.expect("History buffer size: \\d+", timeout=1)
+ history_size = int(child.after[len(cmdline_test_data.BUFSIZE_TEMPLATE):])
+ i = 0
+
+ # fill the history with numbers
+ while i < history_size / 10:
+ # add 1 to prevent from parsing as octals
+ child.send("1" + str(i).zfill(8) + cmdline_test_data.ENTER)
+ # the app will simply print out the number
+ child.expect(str(i + 100000000), timeout=1)
+ i += 1
+ # scroll back history
+ child.send(cmdline_test_data.UP * (i + 2) + cmdline_test_data.ENTER)
+ child.expect("100000000", timeout=1)
+
+# the path to cmdline_test executable is supplied via command-line.
+if len(sys.argv) < 2:
+ print("Error: please supply cmdline_test app path")
+ sys.exit(1)
+
+test_app_path = sys.argv[1]
+
+if not os.path.exists(test_app_path):
+ print("Error: please supply cmdline_test app path")
+ sys.exit(1)
+
+child = pexpect.spawn(test_app_path)
+
+print("Running command-line tests...")
+for test in cmdline_test_data.tests:
+ testname = (test["Name"] + ":").ljust(30)
+ try:
+ runTest(child, test)
+ print(testname, "PASS")
+ except:
+ print(testname, "FAIL")
+ print(child)
+ sys.exit(1)
+
+# since last test quits the app, run new instance
+child = pexpect.spawn(test_app_path)
+
+testname = ("History fill test:").ljust(30)
+try:
+ runHistoryTest(child)
+ print(testname, "PASS")
+except:
+ print(testname, "FAIL")
+ print(child)
+ sys.exit(1)
+child.close()
+sys.exit(0)
--- /dev/null
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2010-2014 Intel Corporation
+
+# collection of static data
+
+# keycode constants
+CTRL_A = chr(1)
+CTRL_B = chr(2)
+CTRL_C = chr(3)
+CTRL_D = chr(4)
+CTRL_E = chr(5)
+CTRL_F = chr(6)
+CTRL_K = chr(11)
+CTRL_L = chr(12)
+CTRL_N = chr(14)
+CTRL_P = chr(16)
+CTRL_W = chr(23)
+CTRL_Y = chr(25)
+ALT_B = chr(27) + chr(98)
+ALT_D = chr(27) + chr(100)
+ALT_F = chr(27) + chr(102)
+ALT_BKSPACE = chr(27) + chr(127)
+DEL = chr(27) + chr(91) + chr(51) + chr(126)
+TAB = chr(9)
+HELP = chr(63)
+BKSPACE = chr(127)
+RIGHT = chr(27) + chr(91) + chr(67)
+DOWN = chr(27) + chr(91) + chr(66)
+LEFT = chr(27) + chr(91) + chr(68)
+UP = chr(27) + chr(91) + chr(65)
+ENTER2 = '\r'
+ENTER = '\n'
+
+# expected result constants
+NOT_FOUND = "Command not found"
+BAD_ARG = "Bad arguments"
+AMBIG = "Ambiguous command"
+CMD1 = "Command 1 parsed!"
+CMD2 = "Command 2 parsed!"
+SINGLE = "Single word command parsed!"
+SINGLE_LONG = "Single long word command parsed!"
+AUTO1 = "Autocomplete command 1 parsed!"
+AUTO2 = "Autocomplete command 2 parsed!"
+
+# misc defines
+CMD_QUIT = "quit"
+CMD_GET_BUFSIZE = "get_history_bufsize"
+BUFSIZE_TEMPLATE = "History buffer size: "
+PROMPT = "CMDLINE_TEST>>"
+
+# test defines
+# each test tests progressively diverse set of keys. this way for example
+# if we want to use some key sequence in the test, we first need to test
+# that it itself does what it is expected to do. Most of the tests are
+# designed that way.
+#
+# example: "arrows & delete test 1". we enter a partially valid command,
+# then move 3 chars left and use delete three times. this way we get to
+# know that "delete", "left" and "ctrl+B" all work (because if any of
+# them fails, the whole test will fail and next tests won't be run).
+#
+# each test consists of name, character sequence to send to child,
+# and expected output (if any).
+
+tests = [
+ # test basic commands
+ {"Name": "command test 1",
+ "Sequence": "ambiguous first" + ENTER,
+ "Result": CMD1},
+ {"Name": "command test 2",
+ "Sequence": "ambiguous second" + ENTER,
+ "Result": CMD2},
+ {"Name": "command test 3",
+ "Sequence": "ambiguous ambiguous" + ENTER,
+ "Result": AMBIG},
+ {"Name": "command test 4",
+ "Sequence": "ambiguous ambiguous2" + ENTER,
+ "Result": AMBIG},
+
+ {"Name": "invalid command test 1",
+ "Sequence": "ambiguous invalid" + ENTER,
+ "Result": BAD_ARG},
+ # test invalid commands
+ {"Name": "invalid command test 2",
+ "Sequence": "invalid" + ENTER,
+ "Result": NOT_FOUND},
+ {"Name": "invalid command test 3",
+ "Sequence": "ambiguousinvalid" + ENTER2,
+ "Result": NOT_FOUND},
+
+ # test arrows and deletes
+ {"Name": "arrows & delete test 1",
+ "Sequence": "singlebad" + LEFT*2 + CTRL_B + DEL*3 + ENTER,
+ "Result": SINGLE},
+ {"Name": "arrows & delete test 2",
+ "Sequence": "singlebad" + LEFT*5 + RIGHT + CTRL_F + DEL*3 + ENTER,
+ "Result": SINGLE},
+
+ # test backspace
+ {"Name": "backspace test",
+ "Sequence": "singlebad" + BKSPACE*3 + ENTER,
+ "Result": SINGLE},
+
+ # test goto left and goto right
+ {"Name": "goto left test",
+ "Sequence": "biguous first" + CTRL_A + "am" + ENTER,
+ "Result": CMD1},
+ {"Name": "goto right test",
+ "Sequence": "biguous fir" + CTRL_A + "am" + CTRL_E + "st" + ENTER,
+ "Result": CMD1},
+
+ # test goto words
+ {"Name": "goto left word test",
+ "Sequence": "ambiguous st" + ALT_B + "fir" + ENTER,
+ "Result": CMD1},
+ {"Name": "goto right word test",
+ "Sequence": "ambig first" + CTRL_A + ALT_F + "uous" + ENTER,
+ "Result": CMD1},
+
+ # test removing words
+ {"Name": "remove left word 1",
+ "Sequence": "single invalid" + CTRL_W + ENTER,
+ "Result": SINGLE},
+ {"Name": "remove left word 2",
+ "Sequence": "single invalid" + ALT_BKSPACE + ENTER,
+ "Result": SINGLE},
+ {"Name": "remove right word",
+ "Sequence": "single invalid" + ALT_B + ALT_D + ENTER,
+ "Result": SINGLE},
+
+ # test kill buffer (copy and paste)
+ {"Name": "killbuffer test 1",
+ "Sequence": "ambiguous" + CTRL_A + CTRL_K + " first" + CTRL_A +
+ CTRL_Y + ENTER,
+ "Result": CMD1},
+ {"Name": "killbuffer test 2",
+ "Sequence": "ambiguous" + CTRL_A + CTRL_K + CTRL_Y*26 + ENTER,
+ "Result": NOT_FOUND},
+
+ # test newline
+ {"Name": "newline test",
+ "Sequence": "invalid" + CTRL_C + "single" + ENTER,
+ "Result": SINGLE},
+
+ # test redisplay (nothing should really happen)
+ {"Name": "redisplay test",
+ "Sequence": "single" + CTRL_L + ENTER,
+ "Result": SINGLE},
+
+ # test autocomplete
+ {"Name": "autocomplete test 1",
+ "Sequence": "si" + TAB + ENTER,
+ "Result": SINGLE},
+ {"Name": "autocomplete test 2",
+ "Sequence": "si" + TAB + "_" + TAB + ENTER,
+ "Result": SINGLE_LONG},
+ {"Name": "autocomplete test 3",
+ "Sequence": "in" + TAB + ENTER,
+ "Result": NOT_FOUND},
+ {"Name": "autocomplete test 4",
+ "Sequence": "am" + TAB + ENTER,
+ "Result": BAD_ARG},
+ {"Name": "autocomplete test 5",
+ "Sequence": "am" + TAB + "fir" + TAB + ENTER,
+ "Result": CMD1},
+ {"Name": "autocomplete test 6",
+ "Sequence": "am" + TAB + "fir" + TAB + TAB + ENTER,
+ "Result": CMD1},
+ {"Name": "autocomplete test 7",
+ "Sequence": "am" + TAB + "fir" + TAB + " " + TAB + ENTER,
+ "Result": CMD1},
+ {"Name": "autocomplete test 8",
+ "Sequence": "am" + TAB + " am" + TAB + " " + ENTER,
+ "Result": AMBIG},
+ {"Name": "autocomplete test 9",
+ "Sequence": "am" + TAB + "inv" + TAB + ENTER,
+ "Result": BAD_ARG},
+ {"Name": "autocomplete test 10",
+ "Sequence": "au" + TAB + ENTER,
+ "Result": NOT_FOUND},
+ {"Name": "autocomplete test 11",
+ "Sequence": "au" + TAB + "1" + ENTER,
+ "Result": AUTO1},
+ {"Name": "autocomplete test 12",
+ "Sequence": "au" + TAB + "2" + ENTER,
+ "Result": AUTO2},
+ {"Name": "autocomplete test 13",
+ "Sequence": "au" + TAB + "2" + TAB + ENTER,
+ "Result": AUTO2},
+ {"Name": "autocomplete test 14",
+ "Sequence": "au" + TAB + "2 " + TAB + ENTER,
+ "Result": AUTO2},
+ {"Name": "autocomplete test 15",
+ "Sequence": "24" + TAB + ENTER,
+ "Result": "24"},
+
+ # test history
+ {"Name": "history test 1",
+ "Sequence": "invalid" + ENTER + "single" + ENTER + "invalid" +
+ ENTER + UP + CTRL_P + ENTER,
+ "Result": SINGLE},
+ {"Name": "history test 2",
+ "Sequence": "invalid" + ENTER + "ambiguous first" + ENTER + "invalid" +
+ ENTER + "single" + ENTER + UP * 3 + CTRL_N + DOWN + ENTER,
+ "Result": SINGLE},
+
+ #
+ # tests that improve coverage
+ #
+
+ # empty space tests
+ {"Name": "empty space test 1",
+ "Sequence": RIGHT + LEFT + CTRL_B + CTRL_F + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 2",
+ "Sequence": BKSPACE + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 3",
+ "Sequence": CTRL_E*2 + CTRL_A*2 + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 4",
+ "Sequence": ALT_F*2 + ALT_B*2 + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 5",
+ "Sequence": " " + CTRL_E*2 + CTRL_A*2 + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 6",
+ "Sequence": " " + CTRL_A + ALT_F*2 + ALT_B*2 + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 7",
+ "Sequence": " " + CTRL_A + CTRL_D + CTRL_E + CTRL_D + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 8",
+ "Sequence": " space" + CTRL_W*2 + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 9",
+ "Sequence": " space" + ALT_BKSPACE*2 + ENTER,
+ "Result": PROMPT},
+ {"Name": "empty space test 10",
+ "Sequence": " space " + CTRL_A + ALT_D*3 + ENTER,
+ "Result": PROMPT},
+
+ # non-printable char tests
+ {"Name": "non-printable test 1",
+ "Sequence": chr(27) + chr(47) + ENTER,
+ "Result": PROMPT},
+ {"Name": "non-printable test 2",
+ "Sequence": chr(27) + chr(128) + ENTER*7,
+ "Result": PROMPT},
+ {"Name": "non-printable test 3",
+ "Sequence": chr(27) + chr(91) + chr(127) + ENTER*6,
+ "Result": PROMPT},
+
+ # miscellaneous tests
+ {"Name": "misc test 1",
+ "Sequence": ENTER,
+ "Result": PROMPT},
+ {"Name": "misc test 2",
+ "Sequence": "single #comment" + ENTER,
+ "Result": SINGLE},
+ {"Name": "misc test 3",
+ "Sequence": "#empty line" + ENTER,
+ "Result": PROMPT},
+ {"Name": "misc test 4",
+ "Sequence": " single " + ENTER,
+ "Result": SINGLE},
+ {"Name": "misc test 5",
+ "Sequence": "single#" + ENTER,
+ "Result": SINGLE},
+ {"Name": "misc test 6",
+ "Sequence": 'a' * 257 + ENTER,
+ "Result": NOT_FOUND},
+ {"Name": "misc test 7",
+ "Sequence": "clear_history" + UP*5 + DOWN*5 + ENTER,
+ "Result": PROMPT},
+ {"Name": "misc test 8",
+ "Sequence": "a" + HELP + CTRL_C,
+ "Result": PROMPT},
+ {"Name": "misc test 9",
+ "Sequence": CTRL_D*3,
+ "Result": None},
+]
--- /dev/null
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <inttypes.h>
+
+#include <cmdline_rdline.h>
+#include <cmdline_parse.h>
+#include <cmdline_parse_string.h>
+#include <cmdline_parse_num.h>
+#include <cmdline.h>
+
+#include "cmdline_test.h"
+
+/*** quit ***/
+/* exit application */
+
+struct cmd_quit_result {
+ cmdline_fixed_string_t quit;
+};
+
+static void
+cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_quit(cl);
+}
+
+cmdline_parse_token_string_t cmd_quit_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit,
+ "quit");
+
+cmdline_parse_inst_t cmd_quit = {
+ .f = cmd_quit_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "exit application",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_quit_tok,
+ NULL,
+ },
+};
+
+
+
+/*** single ***/
+/* a simple single-word command */
+
+struct cmd_single_result {
+ cmdline_fixed_string_t single;
+};
+
+static void
+cmd_single_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "Single word command parsed!\n");
+}
+
+cmdline_parse_token_string_t cmd_single_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_single_result, single,
+ "single");
+
+cmdline_parse_inst_t cmd_single = {
+ .f = cmd_single_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "a simple single-word command",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_single_tok,
+ NULL,
+ },
+};
+
+
+
+/*** single_long ***/
+/* a variant of "single" command. useful to test autocomplete */
+
+struct cmd_single_long_result {
+ cmdline_fixed_string_t single_long;
+};
+
+static void
+cmd_single_long_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "Single long word command parsed!\n");
+}
+
+cmdline_parse_token_string_t cmd_single_long_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_single_long_result, single_long,
+ "single_long");
+
+cmdline_parse_inst_t cmd_single_long = {
+ .f = cmd_single_long_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "a variant of \"single\" command, useful to test autocomplete",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_single_long_tok,
+ NULL,
+ },
+};
+
+
+
+/*** autocomplete_1 ***/
+/* first command to test autocomplete when multiple commands have chars
+ * in common but none should complete due to ambiguity
+ */
+
+struct cmd_autocomplete_1_result {
+ cmdline_fixed_string_t token;
+};
+
+static void
+cmd_autocomplete_1_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "Autocomplete command 1 parsed!\n");
+}
+
+cmdline_parse_token_string_t cmd_autocomplete_1_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_autocomplete_1_result, token,
+ "autocomplete_1");
+
+cmdline_parse_inst_t cmd_autocomplete_1 = {
+ .f = cmd_autocomplete_1_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "first ambiguous autocomplete command",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_autocomplete_1_tok,
+ NULL,
+ },
+};
+
+
+
+/*** autocomplete_2 ***/
+/* second command to test autocomplete when multiple commands have chars
+ * in common but none should complete due to ambiguity
+ */
+
+struct cmd_autocomplete_2_result {
+ cmdline_fixed_string_t token;
+};
+
+static void
+cmd_autocomplete_2_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "Autocomplete command 2 parsed!\n");
+}
+
+cmdline_parse_token_string_t cmd_autocomplete_2_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_autocomplete_2_result, token,
+ "autocomplete_2");
+
+cmdline_parse_inst_t cmd_autocomplete_2 = {
+ .f = cmd_autocomplete_2_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "second ambiguous autocomplete command",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_autocomplete_2_tok,
+ NULL,
+ },
+};
+
+
+
+/*** number command ***/
+/* a command that simply returns whatever (uint32) number is supplied to it */
+
+struct cmd_num_result {
+ unsigned num;
+};
+
+static void
+cmd_num_parsed(void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ unsigned result = ((struct cmd_num_result*)parsed_result)->num;
+ cmdline_printf(cl, "%u\n", result);
+}
+
+cmdline_parse_token_num_t cmd_num_tok =
+ TOKEN_NUM_INITIALIZER(struct cmd_num_result, num, UINT32);
+
+cmdline_parse_inst_t cmd_num = {
+ .f = cmd_num_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "a command that simply returns whatever number is entered",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_num_tok,
+ NULL,
+ },
+};
+
+
+
+/*** ambiguous first|ambiguous ***/
+/* first command used to test command ambiguity */
+
+struct cmd_ambig_result_1 {
+ cmdline_fixed_string_t common_part;
+ cmdline_fixed_string_t ambig_part;
+};
+
+static void
+cmd_ambig_1_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "Command 1 parsed!\n");
+}
+
+cmdline_parse_token_string_t cmd_ambig_common_1 =
+ TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_1, common_part,
+ "ambiguous");
+cmdline_parse_token_string_t cmd_ambig_ambig_1 =
+ TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_1, ambig_part,
+ "first#ambiguous#ambiguous2");
+
+cmdline_parse_inst_t cmd_ambig_1 = {
+ .f = cmd_ambig_1_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "first command used to test command ambiguity",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_ambig_common_1,
+ (void*)&cmd_ambig_ambig_1,
+ NULL,
+ },
+};
+
+
+
+/*** ambiguous second|ambiguous ***/
+/* second command used to test command ambiguity */
+
+struct cmd_ambig_result_2 {
+ cmdline_fixed_string_t common_part;
+ cmdline_fixed_string_t ambig_part;
+};
+
+static void
+cmd_ambig_2_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "Command 2 parsed!\n");
+}
+
+cmdline_parse_token_string_t cmd_ambig_common_2 =
+ TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_2, common_part,
+ "ambiguous");
+cmdline_parse_token_string_t cmd_ambig_ambig_2 =
+ TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_2, ambig_part,
+ "second#ambiguous#ambiguous2");
+
+cmdline_parse_inst_t cmd_ambig_2 = {
+ .f = cmd_ambig_2_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "second command used to test command ambiguity",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_ambig_common_2,
+ (void*)&cmd_ambig_ambig_2,
+ NULL,
+ },
+};
+
+
+
+/*** get_history_bufsize ***/
+/* command that displays total space in history buffer
+ * this will be useful for testing history (to fill it up just enough to
+ * remove the last entry, we need to know how big it is).
+ */
+
+struct cmd_get_history_bufsize_result {
+ cmdline_fixed_string_t str;
+};
+
+static void
+cmd_get_history_bufsize_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ cmdline_printf(cl, "History buffer size: %zu\n",
+ sizeof(cl->rdl.history_buf));
+}
+
+cmdline_parse_token_string_t cmd_get_history_bufsize_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_get_history_bufsize_result, str,
+ "get_history_bufsize");
+
+cmdline_parse_inst_t cmd_get_history_bufsize = {
+ .f = cmd_get_history_bufsize_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "command that displays total space in history buffer",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_get_history_bufsize_tok,
+ NULL,
+ },
+};
+
+
+
+/*** clear_history ***/
+/* clears history buffer */
+
+struct cmd_clear_history_result {
+ cmdline_fixed_string_t str;
+};
+
+static void
+cmd_clear_history_parsed(__attribute__((unused)) void *parsed_result,
+ struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ rdline_clear_history(&cl->rdl);
+}
+
+cmdline_parse_token_string_t cmd_clear_history_tok =
+ TOKEN_STRING_INITIALIZER(struct cmd_clear_history_result, str,
+ "clear_history");
+
+cmdline_parse_inst_t cmd_clear_history = {
+ .f = cmd_clear_history_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = "clear command history",
+ .tokens = { /* token list, NULL terminated */
+ (void *)&cmd_clear_history_tok,
+ NULL,
+ },
+};
+
+
+
+/****************/
+
+cmdline_parse_ctx_t main_ctx[] = {
+ (cmdline_parse_inst_t *)&cmd_quit,
+ (cmdline_parse_inst_t *)&cmd_ambig_1,
+ (cmdline_parse_inst_t *)&cmd_ambig_2,
+ (cmdline_parse_inst_t *)&cmd_single,
+ (cmdline_parse_inst_t *)&cmd_single_long,
+ (cmdline_parse_inst_t *)&cmd_num,
+ (cmdline_parse_inst_t *)&cmd_get_history_bufsize,
+ (cmdline_parse_inst_t *)&cmd_clear_history,
+ (cmdline_parse_inst_t *)&cmd_autocomplete_1,
+ (cmdline_parse_inst_t *)&cmd_autocomplete_2,
+ NULL,
+};
--- /dev/null
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2019 Intel Corporation
+
+sources = files('commands.c', 'cmdline_test.c')
+deps += 'cmdline'
DIRS-$(CONFIG_RTE_APP_TEST) += test
DIRS-$(CONFIG_RTE_LIBRTE_ACL) += test-acl
DIRS-$(CONFIG_RTE_LIBRTE_PIPELINE) += test-pipeline
-DIRS-$(CONFIG_RTE_LIBRTE_CMDLINE) += cmdline_test
include $(RTE_SDK)/mk/rte.subdir.mk
+++ /dev/null
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright(c) 2010-2014 Intel Corporation
-
-include $(RTE_SDK)/mk/rte.vars.mk
-
-ifeq ($(CONFIG_RTE_LIBRTE_CMDLINE),y)
-
-#
-# library name
-#
-APP = cmdline_test
-
-#
-# all sources are stored in SRCS-y
-#
-SRCS-y += cmdline_test.c
-SRCS-y += commands.c
-
-CFLAGS += -O3
-CFLAGS += $(WERROR_FLAGS)
-
-include $(RTE_SDK)/mk/rte.app.mk
-
-endif
+++ /dev/null
-/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2010-2014 Intel Corporation
- */
-
-#include <string.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <termios.h>
-#include <ctype.h>
-#include <sys/queue.h>
-
-#include <cmdline_rdline.h>
-#include <cmdline_parse.h>
-#include <cmdline_socket.h>
-#include <cmdline.h>
-
-#include "cmdline_test.h"
-
-int
-main(int __attribute__((unused)) argc, char __attribute__((unused)) ** argv)
-{
- struct cmdline *cl;
-
- cl = cmdline_stdin_new(main_ctx, "CMDLINE_TEST>>");
- if (cl == NULL) {
- return -1;
- }
- cmdline_interact(cl);
- cmdline_stdin_exit(cl);
-
- return 0;
-}
+++ /dev/null
-/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2010-2014 Intel Corporation
- */
-
-#ifndef _CMDLINE_TEST_H_
-#define _CMDLINE_TEST_H_
-
-extern cmdline_parse_ctx_t main_ctx[];
-
-#endif
+++ /dev/null
-#!/usr/bin/env python
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright(c) 2010-2014 Intel Corporation
-
-# Script that runs cmdline_test app and feeds keystrokes into it.
-from __future__ import print_function
-import cmdline_test_data
-import os
-import pexpect
-import sys
-
-
-#
-# function to run test
-#
-def runTest(child, test):
- child.send(test["Sequence"])
- if test["Result"] is None:
- return 0
- child.expect(test["Result"], 1)
-
-
-#
-# history test is a special case
-#
-# This test does the following:
-# 1) fills the history with garbage up to its full capacity
-# (just enough to remove last entry)
-# 2) scrolls back history to the very beginning
-# 3) checks if the output is as expected, that is, the first
-# number in the sequence (not the last entry before it)
-#
-# This is a self-contained test, it needs only a pexpect child
-#
-def runHistoryTest(child):
- # find out history size
- child.sendline(cmdline_test_data.CMD_GET_BUFSIZE)
- child.expect("History buffer size: \\d+", timeout=1)
- history_size = int(child.after[len(cmdline_test_data.BUFSIZE_TEMPLATE):])
- i = 0
-
- # fill the history with numbers
- while i < history_size / 10:
- # add 1 to prevent from parsing as octals
- child.send("1" + str(i).zfill(8) + cmdline_test_data.ENTER)
- # the app will simply print out the number
- child.expect(str(i + 100000000), timeout=1)
- i += 1
- # scroll back history
- child.send(cmdline_test_data.UP * (i + 2) + cmdline_test_data.ENTER)
- child.expect("100000000", timeout=1)
-
-# the path to cmdline_test executable is supplied via command-line.
-if len(sys.argv) < 2:
- print("Error: please supply cmdline_test app path")
- sys.exit(1)
-
-test_app_path = sys.argv[1]
-
-if not os.path.exists(test_app_path):
- print("Error: please supply cmdline_test app path")
- sys.exit(1)
-
-child = pexpect.spawn(test_app_path)
-
-print("Running command-line tests...")
-for test in cmdline_test_data.tests:
- testname = (test["Name"] + ":").ljust(30)
- try:
- runTest(child, test)
- print(testname, "PASS")
- except:
- print(testname, "FAIL")
- print(child)
- sys.exit(1)
-
-# since last test quits the app, run new instance
-child = pexpect.spawn(test_app_path)
-
-testname = ("History fill test:").ljust(30)
-try:
- runHistoryTest(child)
- print(testname, "PASS")
-except:
- print(testname, "FAIL")
- print(child)
- sys.exit(1)
-child.close()
-sys.exit(0)
+++ /dev/null
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright(c) 2010-2014 Intel Corporation
-
-# collection of static data
-
-# keycode constants
-CTRL_A = chr(1)
-CTRL_B = chr(2)
-CTRL_C = chr(3)
-CTRL_D = chr(4)
-CTRL_E = chr(5)
-CTRL_F = chr(6)
-CTRL_K = chr(11)
-CTRL_L = chr(12)
-CTRL_N = chr(14)
-CTRL_P = chr(16)
-CTRL_W = chr(23)
-CTRL_Y = chr(25)
-ALT_B = chr(27) + chr(98)
-ALT_D = chr(27) + chr(100)
-ALT_F = chr(27) + chr(102)
-ALT_BKSPACE = chr(27) + chr(127)
-DEL = chr(27) + chr(91) + chr(51) + chr(126)
-TAB = chr(9)
-HELP = chr(63)
-BKSPACE = chr(127)
-RIGHT = chr(27) + chr(91) + chr(67)
-DOWN = chr(27) + chr(91) + chr(66)
-LEFT = chr(27) + chr(91) + chr(68)
-UP = chr(27) + chr(91) + chr(65)
-ENTER2 = '\r'
-ENTER = '\n'
-
-# expected result constants
-NOT_FOUND = "Command not found"
-BAD_ARG = "Bad arguments"
-AMBIG = "Ambiguous command"
-CMD1 = "Command 1 parsed!"
-CMD2 = "Command 2 parsed!"
-SINGLE = "Single word command parsed!"
-SINGLE_LONG = "Single long word command parsed!"
-AUTO1 = "Autocomplete command 1 parsed!"
-AUTO2 = "Autocomplete command 2 parsed!"
-
-# misc defines
-CMD_QUIT = "quit"
-CMD_GET_BUFSIZE = "get_history_bufsize"
-BUFSIZE_TEMPLATE = "History buffer size: "
-PROMPT = "CMDLINE_TEST>>"
-
-# test defines
-# each test tests progressively diverse set of keys. this way for example
-# if we want to use some key sequence in the test, we first need to test
-# that it itself does what it is expected to do. Most of the tests are
-# designed that way.
-#
-# example: "arrows & delete test 1". we enter a partially valid command,
-# then move 3 chars left and use delete three times. this way we get to
-# know that "delete", "left" and "ctrl+B" all work (because if any of
-# them fails, the whole test will fail and next tests won't be run).
-#
-# each test consists of name, character sequence to send to child,
-# and expected output (if any).
-
-tests = [
- # test basic commands
- {"Name": "command test 1",
- "Sequence": "ambiguous first" + ENTER,
- "Result": CMD1},
- {"Name": "command test 2",
- "Sequence": "ambiguous second" + ENTER,
- "Result": CMD2},
- {"Name": "command test 3",
- "Sequence": "ambiguous ambiguous" + ENTER,
- "Result": AMBIG},
- {"Name": "command test 4",
- "Sequence": "ambiguous ambiguous2" + ENTER,
- "Result": AMBIG},
-
- {"Name": "invalid command test 1",
- "Sequence": "ambiguous invalid" + ENTER,
- "Result": BAD_ARG},
- # test invalid commands
- {"Name": "invalid command test 2",
- "Sequence": "invalid" + ENTER,
- "Result": NOT_FOUND},
- {"Name": "invalid command test 3",
- "Sequence": "ambiguousinvalid" + ENTER2,
- "Result": NOT_FOUND},
-
- # test arrows and deletes
- {"Name": "arrows & delete test 1",
- "Sequence": "singlebad" + LEFT*2 + CTRL_B + DEL*3 + ENTER,
- "Result": SINGLE},
- {"Name": "arrows & delete test 2",
- "Sequence": "singlebad" + LEFT*5 + RIGHT + CTRL_F + DEL*3 + ENTER,
- "Result": SINGLE},
-
- # test backspace
- {"Name": "backspace test",
- "Sequence": "singlebad" + BKSPACE*3 + ENTER,
- "Result": SINGLE},
-
- # test goto left and goto right
- {"Name": "goto left test",
- "Sequence": "biguous first" + CTRL_A + "am" + ENTER,
- "Result": CMD1},
- {"Name": "goto right test",
- "Sequence": "biguous fir" + CTRL_A + "am" + CTRL_E + "st" + ENTER,
- "Result": CMD1},
-
- # test goto words
- {"Name": "goto left word test",
- "Sequence": "ambiguous st" + ALT_B + "fir" + ENTER,
- "Result": CMD1},
- {"Name": "goto right word test",
- "Sequence": "ambig first" + CTRL_A + ALT_F + "uous" + ENTER,
- "Result": CMD1},
-
- # test removing words
- {"Name": "remove left word 1",
- "Sequence": "single invalid" + CTRL_W + ENTER,
- "Result": SINGLE},
- {"Name": "remove left word 2",
- "Sequence": "single invalid" + ALT_BKSPACE + ENTER,
- "Result": SINGLE},
- {"Name": "remove right word",
- "Sequence": "single invalid" + ALT_B + ALT_D + ENTER,
- "Result": SINGLE},
-
- # test kill buffer (copy and paste)
- {"Name": "killbuffer test 1",
- "Sequence": "ambiguous" + CTRL_A + CTRL_K + " first" + CTRL_A +
- CTRL_Y + ENTER,
- "Result": CMD1},
- {"Name": "killbuffer test 2",
- "Sequence": "ambiguous" + CTRL_A + CTRL_K + CTRL_Y*26 + ENTER,
- "Result": NOT_FOUND},
-
- # test newline
- {"Name": "newline test",
- "Sequence": "invalid" + CTRL_C + "single" + ENTER,
- "Result": SINGLE},
-
- # test redisplay (nothing should really happen)
- {"Name": "redisplay test",
- "Sequence": "single" + CTRL_L + ENTER,
- "Result": SINGLE},
-
- # test autocomplete
- {"Name": "autocomplete test 1",
- "Sequence": "si" + TAB + ENTER,
- "Result": SINGLE},
- {"Name": "autocomplete test 2",
- "Sequence": "si" + TAB + "_" + TAB + ENTER,
- "Result": SINGLE_LONG},
- {"Name": "autocomplete test 3",
- "Sequence": "in" + TAB + ENTER,
- "Result": NOT_FOUND},
- {"Name": "autocomplete test 4",
- "Sequence": "am" + TAB + ENTER,
- "Result": BAD_ARG},
- {"Name": "autocomplete test 5",
- "Sequence": "am" + TAB + "fir" + TAB + ENTER,
- "Result": CMD1},
- {"Name": "autocomplete test 6",
- "Sequence": "am" + TAB + "fir" + TAB + TAB + ENTER,
- "Result": CMD1},
- {"Name": "autocomplete test 7",
- "Sequence": "am" + TAB + "fir" + TAB + " " + TAB + ENTER,
- "Result": CMD1},
- {"Name": "autocomplete test 8",
- "Sequence": "am" + TAB + " am" + TAB + " " + ENTER,
- "Result": AMBIG},
- {"Name": "autocomplete test 9",
- "Sequence": "am" + TAB + "inv" + TAB + ENTER,
- "Result": BAD_ARG},
- {"Name": "autocomplete test 10",
- "Sequence": "au" + TAB + ENTER,
- "Result": NOT_FOUND},
- {"Name": "autocomplete test 11",
- "Sequence": "au" + TAB + "1" + ENTER,
- "Result": AUTO1},
- {"Name": "autocomplete test 12",
- "Sequence": "au" + TAB + "2" + ENTER,
- "Result": AUTO2},
- {"Name": "autocomplete test 13",
- "Sequence": "au" + TAB + "2" + TAB + ENTER,
- "Result": AUTO2},
- {"Name": "autocomplete test 14",
- "Sequence": "au" + TAB + "2 " + TAB + ENTER,
- "Result": AUTO2},
- {"Name": "autocomplete test 15",
- "Sequence": "24" + TAB + ENTER,
- "Result": "24"},
-
- # test history
- {"Name": "history test 1",
- "Sequence": "invalid" + ENTER + "single" + ENTER + "invalid" +
- ENTER + UP + CTRL_P + ENTER,
- "Result": SINGLE},
- {"Name": "history test 2",
- "Sequence": "invalid" + ENTER + "ambiguous first" + ENTER + "invalid" +
- ENTER + "single" + ENTER + UP * 3 + CTRL_N + DOWN + ENTER,
- "Result": SINGLE},
-
- #
- # tests that improve coverage
- #
-
- # empty space tests
- {"Name": "empty space test 1",
- "Sequence": RIGHT + LEFT + CTRL_B + CTRL_F + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 2",
- "Sequence": BKSPACE + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 3",
- "Sequence": CTRL_E*2 + CTRL_A*2 + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 4",
- "Sequence": ALT_F*2 + ALT_B*2 + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 5",
- "Sequence": " " + CTRL_E*2 + CTRL_A*2 + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 6",
- "Sequence": " " + CTRL_A + ALT_F*2 + ALT_B*2 + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 7",
- "Sequence": " " + CTRL_A + CTRL_D + CTRL_E + CTRL_D + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 8",
- "Sequence": " space" + CTRL_W*2 + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 9",
- "Sequence": " space" + ALT_BKSPACE*2 + ENTER,
- "Result": PROMPT},
- {"Name": "empty space test 10",
- "Sequence": " space " + CTRL_A + ALT_D*3 + ENTER,
- "Result": PROMPT},
-
- # non-printable char tests
- {"Name": "non-printable test 1",
- "Sequence": chr(27) + chr(47) + ENTER,
- "Result": PROMPT},
- {"Name": "non-printable test 2",
- "Sequence": chr(27) + chr(128) + ENTER*7,
- "Result": PROMPT},
- {"Name": "non-printable test 3",
- "Sequence": chr(27) + chr(91) + chr(127) + ENTER*6,
- "Result": PROMPT},
-
- # miscellaneous tests
- {"Name": "misc test 1",
- "Sequence": ENTER,
- "Result": PROMPT},
- {"Name": "misc test 2",
- "Sequence": "single #comment" + ENTER,
- "Result": SINGLE},
- {"Name": "misc test 3",
- "Sequence": "#empty line" + ENTER,
- "Result": PROMPT},
- {"Name": "misc test 4",
- "Sequence": " single " + ENTER,
- "Result": SINGLE},
- {"Name": "misc test 5",
- "Sequence": "single#" + ENTER,
- "Result": SINGLE},
- {"Name": "misc test 6",
- "Sequence": 'a' * 257 + ENTER,
- "Result": NOT_FOUND},
- {"Name": "misc test 7",
- "Sequence": "clear_history" + UP*5 + DOWN*5 + ENTER,
- "Result": PROMPT},
- {"Name": "misc test 8",
- "Sequence": "a" + HELP + CTRL_C,
- "Result": PROMPT},
- {"Name": "misc test 9",
- "Sequence": CTRL_D*3,
- "Result": None},
-]
+++ /dev/null
-/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2010-2014 Intel Corporation
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <termios.h>
-#include <inttypes.h>
-
-#include <cmdline_rdline.h>
-#include <cmdline_parse.h>
-#include <cmdline_parse_string.h>
-#include <cmdline_parse_num.h>
-#include <cmdline.h>
-
-#include "cmdline_test.h"
-
-/*** quit ***/
-/* exit application */
-
-struct cmd_quit_result {
- cmdline_fixed_string_t quit;
-};
-
-static void
-cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_quit(cl);
-}
-
-cmdline_parse_token_string_t cmd_quit_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit,
- "quit");
-
-cmdline_parse_inst_t cmd_quit = {
- .f = cmd_quit_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "exit application",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_quit_tok,
- NULL,
- },
-};
-
-
-
-/*** single ***/
-/* a simple single-word command */
-
-struct cmd_single_result {
- cmdline_fixed_string_t single;
-};
-
-static void
-cmd_single_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "Single word command parsed!\n");
-}
-
-cmdline_parse_token_string_t cmd_single_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_single_result, single,
- "single");
-
-cmdline_parse_inst_t cmd_single = {
- .f = cmd_single_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "a simple single-word command",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_single_tok,
- NULL,
- },
-};
-
-
-
-/*** single_long ***/
-/* a variant of "single" command. useful to test autocomplete */
-
-struct cmd_single_long_result {
- cmdline_fixed_string_t single_long;
-};
-
-static void
-cmd_single_long_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "Single long word command parsed!\n");
-}
-
-cmdline_parse_token_string_t cmd_single_long_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_single_long_result, single_long,
- "single_long");
-
-cmdline_parse_inst_t cmd_single_long = {
- .f = cmd_single_long_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "a variant of \"single\" command, useful to test autocomplete",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_single_long_tok,
- NULL,
- },
-};
-
-
-
-/*** autocomplete_1 ***/
-/* first command to test autocomplete when multiple commands have chars
- * in common but none should complete due to ambiguity
- */
-
-struct cmd_autocomplete_1_result {
- cmdline_fixed_string_t token;
-};
-
-static void
-cmd_autocomplete_1_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "Autocomplete command 1 parsed!\n");
-}
-
-cmdline_parse_token_string_t cmd_autocomplete_1_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_autocomplete_1_result, token,
- "autocomplete_1");
-
-cmdline_parse_inst_t cmd_autocomplete_1 = {
- .f = cmd_autocomplete_1_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "first ambiguous autocomplete command",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_autocomplete_1_tok,
- NULL,
- },
-};
-
-
-
-/*** autocomplete_2 ***/
-/* second command to test autocomplete when multiple commands have chars
- * in common but none should complete due to ambiguity
- */
-
-struct cmd_autocomplete_2_result {
- cmdline_fixed_string_t token;
-};
-
-static void
-cmd_autocomplete_2_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "Autocomplete command 2 parsed!\n");
-}
-
-cmdline_parse_token_string_t cmd_autocomplete_2_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_autocomplete_2_result, token,
- "autocomplete_2");
-
-cmdline_parse_inst_t cmd_autocomplete_2 = {
- .f = cmd_autocomplete_2_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "second ambiguous autocomplete command",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_autocomplete_2_tok,
- NULL,
- },
-};
-
-
-
-/*** number command ***/
-/* a command that simply returns whatever (uint32) number is supplied to it */
-
-struct cmd_num_result {
- unsigned num;
-};
-
-static void
-cmd_num_parsed(void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- unsigned result = ((struct cmd_num_result*)parsed_result)->num;
- cmdline_printf(cl, "%u\n", result);
-}
-
-cmdline_parse_token_num_t cmd_num_tok =
- TOKEN_NUM_INITIALIZER(struct cmd_num_result, num, UINT32);
-
-cmdline_parse_inst_t cmd_num = {
- .f = cmd_num_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "a command that simply returns whatever number is entered",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_num_tok,
- NULL,
- },
-};
-
-
-
-/*** ambiguous first|ambiguous ***/
-/* first command used to test command ambiguity */
-
-struct cmd_ambig_result_1 {
- cmdline_fixed_string_t common_part;
- cmdline_fixed_string_t ambig_part;
-};
-
-static void
-cmd_ambig_1_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "Command 1 parsed!\n");
-}
-
-cmdline_parse_token_string_t cmd_ambig_common_1 =
- TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_1, common_part,
- "ambiguous");
-cmdline_parse_token_string_t cmd_ambig_ambig_1 =
- TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_1, ambig_part,
- "first#ambiguous#ambiguous2");
-
-cmdline_parse_inst_t cmd_ambig_1 = {
- .f = cmd_ambig_1_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "first command used to test command ambiguity",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_ambig_common_1,
- (void*)&cmd_ambig_ambig_1,
- NULL,
- },
-};
-
-
-
-/*** ambiguous second|ambiguous ***/
-/* second command used to test command ambiguity */
-
-struct cmd_ambig_result_2 {
- cmdline_fixed_string_t common_part;
- cmdline_fixed_string_t ambig_part;
-};
-
-static void
-cmd_ambig_2_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "Command 2 parsed!\n");
-}
-
-cmdline_parse_token_string_t cmd_ambig_common_2 =
- TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_2, common_part,
- "ambiguous");
-cmdline_parse_token_string_t cmd_ambig_ambig_2 =
- TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_2, ambig_part,
- "second#ambiguous#ambiguous2");
-
-cmdline_parse_inst_t cmd_ambig_2 = {
- .f = cmd_ambig_2_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "second command used to test command ambiguity",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_ambig_common_2,
- (void*)&cmd_ambig_ambig_2,
- NULL,
- },
-};
-
-
-
-/*** get_history_bufsize ***/
-/* command that displays total space in history buffer
- * this will be useful for testing history (to fill it up just enough to
- * remove the last entry, we need to know how big it is).
- */
-
-struct cmd_get_history_bufsize_result {
- cmdline_fixed_string_t str;
-};
-
-static void
-cmd_get_history_bufsize_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- cmdline_printf(cl, "History buffer size: %zu\n",
- sizeof(cl->rdl.history_buf));
-}
-
-cmdline_parse_token_string_t cmd_get_history_bufsize_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_get_history_bufsize_result, str,
- "get_history_bufsize");
-
-cmdline_parse_inst_t cmd_get_history_bufsize = {
- .f = cmd_get_history_bufsize_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "command that displays total space in history buffer",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_get_history_bufsize_tok,
- NULL,
- },
-};
-
-
-
-/*** clear_history ***/
-/* clears history buffer */
-
-struct cmd_clear_history_result {
- cmdline_fixed_string_t str;
-};
-
-static void
-cmd_clear_history_parsed(__attribute__((unused)) void *parsed_result,
- struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- rdline_clear_history(&cl->rdl);
-}
-
-cmdline_parse_token_string_t cmd_clear_history_tok =
- TOKEN_STRING_INITIALIZER(struct cmd_clear_history_result, str,
- "clear_history");
-
-cmdline_parse_inst_t cmd_clear_history = {
- .f = cmd_clear_history_parsed, /* function to call */
- .data = NULL, /* 2nd arg of func */
- .help_str = "clear command history",
- .tokens = { /* token list, NULL terminated */
- (void *)&cmd_clear_history_tok,
- NULL,
- },
-};
-
-
-
-/****************/
-
-cmdline_parse_ctx_t main_ctx[] = {
- (cmdline_parse_inst_t *)&cmd_quit,
- (cmdline_parse_inst_t *)&cmd_ambig_1,
- (cmdline_parse_inst_t *)&cmd_ambig_2,
- (cmdline_parse_inst_t *)&cmd_single,
- (cmdline_parse_inst_t *)&cmd_single_long,
- (cmdline_parse_inst_t *)&cmd_num,
- (cmdline_parse_inst_t *)&cmd_get_history_bufsize,
- (cmdline_parse_inst_t *)&cmd_clear_history,
- (cmdline_parse_inst_t *)&cmd_autocomplete_1,
- (cmdline_parse_inst_t *)&cmd_autocomplete_2,
- NULL,
-};
git.droids-corp.org / dpdk.git / commitdiff