From: Bruce Richardson Date: Tue, 26 Feb 2019 12:18:59 +0000 (+0000) Subject: app/cmdline: move from test directory X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=0c36081db2b0994c6e5cde3c07c358bbc092c3a3;p=dpdk.git app/cmdline: move from test directory Move app to "app" directory and enable with meson build. For consistency of naming, the subdirectory is also renamed from cmdline_test to test-cmdline. Signed-off-by: Bruce Richardson --- diff --git a/MAINTAINERS b/MAINTAINERS index 3b39bc65d7..293bf6aa49 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1167,7 +1167,7 @@ F: test/test/test_cfgfiles/ Interactive command line M: Olivier Matz 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 diff --git a/app/Makefile b/app/Makefile index d6641ef1c1..51237d0f4a 100644 --- a/app/Makefile +++ b/app/Makefile @@ -6,6 +6,7 @@ include $(RTE_SDK)/mk/rte.vars.mk 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 diff --git a/app/meson.build b/app/meson.build index 47a2a86151..8bdf4f5812 100644 --- a/app/meson.build +++ b/app/meson.build @@ -1,9 +1,11 @@ # 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', diff --git a/app/test-cmdline/Makefile b/app/test-cmdline/Makefile new file mode 100644 index 0000000000..3e7421906b --- /dev/null +++ b/app/test-cmdline/Makefile @@ -0,0 +1,24 @@ +# 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 diff --git a/app/test-cmdline/cmdline_test.c b/app/test-cmdline/cmdline_test.c new file mode 100644 index 0000000000..3e406331a0 --- /dev/null +++ b/app/test-cmdline/cmdline_test.c @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2014 Intel Corporation + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#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; +} diff --git a/app/test-cmdline/cmdline_test.h b/app/test-cmdline/cmdline_test.h new file mode 100644 index 0000000000..13af4f3dcf --- /dev/null +++ b/app/test-cmdline/cmdline_test.h @@ -0,0 +1,10 @@ +/* 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 diff --git a/app/test-cmdline/cmdline_test.py b/app/test-cmdline/cmdline_test.py new file mode 100755 index 0000000000..3a8fac4261 --- /dev/null +++ b/app/test-cmdline/cmdline_test.py @@ -0,0 +1,89 @@ +#!/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) diff --git a/app/test-cmdline/cmdline_test_data.py b/app/test-cmdline/cmdline_test_data.py new file mode 100644 index 0000000000..114d2cb6a0 --- /dev/null +++ b/app/test-cmdline/cmdline_test_data.py @@ -0,0 +1,282 @@ +# 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}, +] diff --git a/app/test-cmdline/commands.c b/app/test-cmdline/commands.c new file mode 100644 index 0000000000..d81da9665a --- /dev/null +++ b/app/test-cmdline/commands.c @@ -0,0 +1,360 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2014 Intel Corporation + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#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, +}; diff --git a/app/test-cmdline/meson.build b/app/test-cmdline/meson.build new file mode 100644 index 0000000000..9d0a9aeb6e --- /dev/null +++ b/app/test-cmdline/meson.build @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2019 Intel Corporation + +sources = files('commands.c', 'cmdline_test.c') +deps += 'cmdline' diff --git a/test/Makefile b/test/Makefile index 6656374fc3..4ffc087a09 100644 --- a/test/Makefile +++ b/test/Makefile @@ -6,6 +6,5 @@ include $(RTE_SDK)/mk/rte.vars.mk 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 diff --git a/test/cmdline_test/Makefile b/test/cmdline_test/Makefile deleted file mode 100644 index 3e7421906b..0000000000 --- a/test/cmdline_test/Makefile +++ /dev/null @@ -1,24 +0,0 @@ -# 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 diff --git a/test/cmdline_test/cmdline_test.c b/test/cmdline_test/cmdline_test.c deleted file mode 100644 index 3e406331a0..0000000000 --- a/test/cmdline_test/cmdline_test.c +++ /dev/null @@ -1,35 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2010-2014 Intel Corporation - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#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; -} diff --git a/test/cmdline_test/cmdline_test.h b/test/cmdline_test/cmdline_test.h deleted file mode 100644 index 13af4f3dcf..0000000000 --- a/test/cmdline_test/cmdline_test.h +++ /dev/null @@ -1,10 +0,0 @@ -/* 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 diff --git a/test/cmdline_test/cmdline_test.py b/test/cmdline_test/cmdline_test.py deleted file mode 100755 index 3a8fac4261..0000000000 --- a/test/cmdline_test/cmdline_test.py +++ /dev/null @@ -1,89 +0,0 @@ -#!/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) diff --git a/test/cmdline_test/cmdline_test_data.py b/test/cmdline_test/cmdline_test_data.py deleted file mode 100644 index 114d2cb6a0..0000000000 --- a/test/cmdline_test/cmdline_test_data.py +++ /dev/null @@ -1,282 +0,0 @@ -# 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}, -] diff --git a/test/cmdline_test/commands.c b/test/cmdline_test/commands.c deleted file mode 100644 index d81da9665a..0000000000 --- a/test/cmdline_test/commands.c +++ /dev/null @@ -1,360 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2010-2014 Intel Corporation - */ - -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#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, -};