feat(esp_commands): Add tests to the esp_commands component

Author: SoucheSouche

esp_commands/CMakeLists.txt

@@ -1,10 +1,11 @@
 idf_build_get_property(target IDF_TARGET)
 
 set(srcs "esp_commands.c"
-         "eps_commands_helpers.c")
+         "esp_commands_helpers.c")
 
 idf_component_register(
-                    SRCS "esp_commands.c" "eps_commands_helpers.c"
+                    SRCS ${srcs}
                     INCLUDE_DIRS include
                     PRIV_INCLUDE_DIRS private_include
+                    REQUIRES heap
                     LDFRAGMENTS linker.lf)

esp_commands/esp_commands.c

@@ -3,28 +3,14 @@
 #include "esp_heap_caps.h"
 #include "esp_err.h"
 
-#define ANSI_COLOR_DEFAULT      39      /** Default foreground color */
+/* Default foreground color */
+#define ANSI_COLOR_DEFAULT 39
 
 /* Pointers to the first and last command in the dedicated section.
  * See linker.lf for detailed information about the section */
 extern esp_command_t _esp_commands_start;
 extern esp_command_t _esp_commands_end;
 
-/**
- * @brief go through all commands registered in the
- * memory section starting at _esp_commands_start
- * and ending at _esp_commands_end
- */
-#define FOR_EACH_COMMAND_IN_SECTION(cmd) \
-    for ((cmd) = &_esp_commands_start; \
-        (cmd) < &_esp_commands_end; \
-        (esp_command_t*)(cmd)++)
-
-#define FOR_EACH_COMMAND_IN_SET(cmd, cmd_set) \
-    for ((cmd) = cmd_set->cmd_ptr_set[0]; \
-        (cmd) < cmd_set->cmd_ptr_set[cmd_set->cmd_prt_set_size - 1]; \
-        (esp_command_t*)(cmd)++)
-
 /**
  * @brief Array of pointers to command defining
  * a set of command. Created while calling
@@ -36,12 +22,10 @@ typedef struct esp_command_set {
 } esp_command_set_t;
 
 /**
- * @brief find a command by its name in the list of registered
- * commands
- *
- * @param name name of the command to find
- * @return esp_command_t* pointer to the command matching the command
- * name, NULL if the command is not found
+ * @brief go through all commands registered in the
+ * memory section starting at _esp_commands_start
+ * and ending at _esp_commands_end OR go through all
+ * the commands listed in cmd_set if not NULL
  */
 #define FOR_EACH_COMMAND(cmd_set, cmd)                                              \
     for (size_t _i = 0;                                                             \
@@ -52,44 +36,50 @@ typedef struct esp_command_set {
                  _i < (cmd_set)->cmd_set_size));                                    \
          ++_i)
 
+/**
+ * @brief returns the number of commands registered
+ * in the .esp_commands section
+ */
+#define ESP_COMMANDS_COUNT (size_t)(&_esp_commands_end - &_esp_commands_start)
+
 /**
  * @brief find a command by its name in the list of registered
- * commands
+ * commands or in a command set if the parameter cmd_set is set.
+ *
+ * @note If cmd_set is set to NULL by the caller, then the function
+ * will try to find a command by name from the list of registered
+ * commands in the .esp_commands section
  *
+ * @param cmd_set command set to find a command from
  * @param name name of the command to find
  * @return esp_command_t* pointer to the command matching the command
  * name, NULL if the command is not found
  */
-static esp_command_t *find_command_by_name_in_set(esp_command_set_t *cmd_set, const char *name)
+static esp_command_t *find_command_by_name(esp_command_set_t *cmd_set, const char *name)
 {
     /* no need to check that cmd_set is NULL, if it is, then FOR_EACH_COMMAND will go through
      * the commands registered in the .esp_commands section */
     if (!name) {
         return NULL;
     }
     esp_command_t *cmd = NULL;
-    FOR_EACH_COMMAND_IN_SET(cmd, cmd_set) {
-        if (!cmd) {
-            /* this happens if a command name passed in a set was not found,
-             * the pointer to command is set to NULL */
-            continue;
-        }
-        if (strcmp(cmd->command, name) == 0) {
+    FOR_EACH_COMMAND(cmd_set, cmd) {
+        if (strcmp(cmd->name, name) == 0) {
             return cmd;
         }
     }
     return NULL;
 }
 
 /** run-time configuration options */
-static esp_console_config_t s_config = {
+static esp_commands_config_t s_config = {
     .heap_alloc_caps = MALLOC_CAP_DEFAULT
 };
 
 /** temporary buffer used for command line parsing */
 static char *s_tmp_line_buf;
 
-esp_err_t esp_console_init(const esp_console_config_t *config)
+esp_err_t esp_commands_init(const esp_commands_config_t *config)
 {
     if (!config) {
         return ESP_ERR_INVALID_ARG;
@@ -111,7 +101,7 @@ esp_err_t esp_console_init(const esp_console_config_t *config)
     return ESP_OK;
 }
 
-esp_err_t esp_console_deinit(void)
+esp_err_t esp_commands_deinit(void)
 {
     if (!s_tmp_line_buf) {
         return ESP_ERR_INVALID_STATE;
@@ -133,8 +123,8 @@ esp_err_t esp_commands_execute(esp_command_set_handle_t cmd_set, const char *cmd
     }
     strlcpy(s_tmp_line_buf, cmdline, s_config.max_cmdline_length);
 
-    size_t argc = esp_console_split_argv(s_tmp_line_buf, argv,
-                                         s_config.max_cmdline_args);
+    size_t argc = esp_commands_split_argv(s_tmp_line_buf, argv,
+                                          s_config.max_cmdline_args);
     if (argc == 0) {
         free(argv);
         return ESP_ERR_INVALID_ARG;
@@ -163,14 +153,14 @@ esp_err_t esp_commands_execute(esp_command_set_handle_t cmd_set, const char *cmd
             // executing help command, pass the cmd_set as context
             *cmd_ret = (*cmd->func_w_ctx)(cmd_set, argc, argv);
         } else {
-            *cmd_ret = (*cmd->func_w_context)(cmd->context, argc, argv);
+            *cmd_ret = (*cmd->func_w_ctx)(cmd->func_ctx, argc, argv);
         }
     }
     free(argv);
     return ESP_OK;
 }
 
-esp_command_set_handle_t esp_commands_create_cmd_set(const char **cmd_name_set, const size_t cmd_name_set_size, esp_commands_get_field_t get_field)
+esp_command_set_handle_t esp_commands_create_cmd_set(const char **cmd_set, const size_t cmd_set_size, esp_commands_get_field_t get_field)
 {
     if (!cmd_set || cmd_set_size == 0) {
         return NULL;
@@ -190,8 +180,8 @@ esp_command_set_handle_t esp_commands_create_cmd_set(const char **cmd_name_set,
         FOR_EACH_COMMAND((esp_command_set_t*)NULL, it) {
             if (strcmp(get_field(it), cmd_set[i]) == 0) {
                 // it's a match, add the pointer to command to the cmd ptr set
-                cmd_ptrs[i] = it;
-                command_found = true;
+                cmd_ptrs_temp[cmd_ptr_count] = it;
+                cmd_ptr_count++;
                 continue;
             }
         }
@@ -257,7 +247,7 @@ esp_command_set_handle_t esp_commands_concat_cmd_set(esp_command_set_handle_t cm
     esp_commands_destroy_cmd_set(&cmd_set_a);
     esp_commands_destroy_cmd_set(&cmd_set_b);
 
-    return (esp_command_set_t)cmd_set;
+    return (esp_command_set_handle_t)concat_cmd_set;
 }
 
 void esp_commands_destroy_cmd_set(esp_command_set_handle_t *cmd_set)
@@ -283,8 +273,8 @@ void esp_commands_get_completion(const char *buf, esp_command_get_completion_t c
     esp_command_t *it;
     FOR_EACH_COMMAND((esp_command_set_t*)NULL, it) {
         /* Check if command starts with buf */
-        if (strncmp(buf, it->command, len) == 0) {
-            completion_cb(it->command);
+        if (strncmp(buf, it->name, len) == 0) {
+            completion_cb(it->name);
         }
     }
 }
@@ -301,7 +291,7 @@ const char *esp_commands_get_hint(const char *buf, int *color, int *bold)
             }
             *color = s_config.hint_color;
             *bold = s_config.hint_bold;
-            return it->get_hint_cb();
+            return it->hint_cb();
         }
     }
     return NULL;
@@ -317,25 +307,25 @@ static void print_arg_help(esp_command_t *it)
     /* First line: command name and hint
      * Pad all the hints to the same column
      */
-    printf("%-s",  it->command);
-    if (it->get_hint_cb) {
-        printf(" %s\n", it->get_hint_cb());
+    printf("%-s",  it->name);
+    if (it->hint_cb) {
+        printf(" %s\n", it->hint_cb());
     } else {
         printf("\n");
     }
 
     /* Second line: print help */
     /* TODO: replace the simple print with a function that
      * replaces arg_print_formatted */
-    if (it->get_help_cb) {
-        printf("  %s\n", it->get_help_cb());
+    if (it->help) {
+        printf("  %s\n", it->help);
     } else {
         printf("  -\n");
     }
 
     /* Third line: print the glossary*/
-    if (it->get_glossary_cb) {
-        printf("%s\n", it->get_glossary_cb());
+    if (it->glossary_cb) {
+        printf("%s\n", it->glossary_cb());
     } else {
         printf("  -\n");
     }
@@ -345,9 +335,9 @@ static void print_arg_help(esp_command_t *it)
 
 static void print_arg_command(esp_command_t *it)
 {
-    printf("%-s",  it->command);
-    if (it->get_hint_cb) {
-        printf(" %s\n", it->get_hint_cb());
+    printf("%-s",  it->name);
+    if (it->hint_cb) {
+        printf(" %s\n", it->hint_cb());
     }
 }
 
@@ -417,21 +407,21 @@ static int help_command(void *context, int argc, char **argv)
      * is not NULL, find the command and only print the help for this command. if the
      * command is not found, return with error */
     bool command_found = false;
-    for (size_t i = 0; i < cmd_set->cmd_set_size; i++) {
-
-        if (!cmd_set->cmd_ptr_set[i]) {
+    esp_command_t *it = NULL;
+    FOR_EACH_COMMAND(cmd_set, it) {
+        if (!it) {
             /* this happens if a command name passed in a set was not found,
              * the pointer to command is set to NULL */
             continue;
         }
 
         if (!command_name) {
             /* command_name is empty, print all commands */
-            print_verbose_level_arr[verbose_level](cmd_set->cmd_ptr_set[i]);
+            print_verbose_level_arr[verbose_level](it);
         } else if (command_name &&
-                   (strcmp(command_name, cmd_set->cmd_ptr_set[i]->command) == 0)) {
+                   (strcmp(command_name, it->name) == 0)) {
             /* we found the command name, print the help and return */
-            print_verbose_level_arr[verbose_level](cmd_set->cmd_ptr_set[i]);
+            print_verbose_level_arr[verbose_level](it);
             command_found = true;
             break;
         }
@@ -456,11 +446,14 @@ static const char *get_help_glossary(void)
            "  -v, --verbose <0|1>  If specified, list console commands with given verbose level";;
 }
 
-ESP_COMMAND_REGISTER(help,
-                     NULL, /* the help should be a part of all set, it does not need a group name */
-                     "Print the summary of all registered commands if no arguments "
-                     "are given, otherwise print summary of given command.",
-                     &help_command,
+static const char help_str[] = "Print the summary of all registered commands if no arguments "
+                               "are given, otherwise print summary of given command.";
+
+ESP_COMMAND_REGISTER(help, /* name of the heap command */
+                     help, /* group of the help command */
+                     help_str, /* help string of the help command */
+                     NULL, /* func (null since func with context is used) */
+                     help_command, /* func_w_ctx */
                      NULL, /* the context is null here, it will provided by the exec function */
-                     get_help_hint,
-                     get_help_glossary);
+                     get_help_hint, /* hint callback */
+                     get_help_glossary); /* glossary callback */

esp_commands/esp_commands_helpers.c

@@ -32,7 +32,7 @@ typedef enum {
     state = SS_SPACE; \
 } while(0)
 
-size_t esp_console_split_argv(char *line, char **argv, size_t argv_size)
+size_t esp_commands_split_argv(char *line, char **argv, size_t argv_size)
 {
     const int QUOTE = '"';
     const int ESCAPE = '\\';