feat(esp_commands): Add tests to the esp_commands component

Author: SoucheSouche

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -30,6 +30,7 @@ body:
         - dhara
         - eigen
         - esp_delta_ota
+        - esp_commands
         - esp_encrypted_img
         - esp_jpeg
         - esp_lcd_qemu_rgb

.github/workflows/upload_component.yml

@@ -42,6 +42,7 @@ jobs:
             dhara;
             eigen;
             esp_delta_ota;
+            esp_commands;
             esp_encrypted_img;
             esp_lcd_qemu_rgb;
             esp_jpeg;

.idf_build_apps.toml

@@ -7,6 +7,7 @@ manifest_file = [
     "bdc_motor/.build-test-rules.yml",
     "ccomp_timer/.build-test-rules.yml",
     "coremark/.build-test-rules.yml",
+    "esp_commands/.build-test-rules.yml",
     "esp_encrypted_img/.build-test-rules.yml",
     "esp_jpeg/.build-test-rules.yml",
     "esp_serial_slave_link/.build-test-rules.yml",

esp_commands/CMakeLists.txt

@@ -1,10 +1,10 @@
 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
                     LDFRAGMENTS linker.lf)

esp_commands/esp_commands.c

@@ -8,28 +8,14 @@
 #include "esp_commands_helpers.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
@@ -47,12 +33,10 @@ static esp_commands_config_t s_config;
 static char *s_tmp_line_buf;
 
 /**
- * @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;                                                             \
@@ -63,29 +47,35 @@ static char *s_tmp_line_buf;
                  _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;
         }
     }
@@ -131,8 +121,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;
@@ -143,7 +133,7 @@ esp_err_t esp_commands_execute(esp_command_set_handle_t cmd_set, const char *cmd
     bool is_cmd_help = false;
     if (strcmp("help", argv[0]) == 0) {
         /* find the help command in the list in .esp_commands section */
-        cmd = find_command_by_name((esp_command_set_t*)NULL, "help");
+        cmd = find_command_by_name((esp_command_set_t *)NULL, "help");
         is_cmd_help = true;
     } else {
         cmd = find_command_by_name(cmd_set, argv[0]);
@@ -161,13 +151,115 @@ 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_set, const size_t cmd_set_size, esp_commands_get_field_t get_field)
+{
+    if (!cmd_set || cmd_set_size == 0) {
+        return NULL;
+    }
+
+    esp_command_set_t *cmd_ptr_set = heap_caps_malloc(sizeof(esp_command_set_t), s_config.heap_alloc_caps);
+    if (!cmd_ptr_set) {
+        return NULL;
+    }
+
+    esp_command_t *cmd_ptrs_temp[ESP_COMMANDS_COUNT];
+    size_t cmd_ptr_count = 0;
+
+    /* populate the temporary cmd pointer set */
+    for (size_t i = 0; i < cmd_set_size; i++) {
+        esp_command_t *it = NULL;
+        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_temp[cmd_ptr_count] = it;
+                cmd_ptr_count++;
+                continue;
+            }
+        }
+    }
+
+    /* if no command was found, return a set with 0 items in it */
+    if (cmd_ptr_count == 0) {
+        cmd_ptr_set->cmd_ptr_set = NULL;
+        cmd_ptr_set->cmd_set_size = 0;
+    } else {
+        const size_t alloc_cmd_ptrs_size = sizeof(esp_command_t *) * cmd_ptr_count;
+        cmd_ptr_set->cmd_ptr_set = heap_caps_malloc(alloc_cmd_ptrs_size, s_config.heap_alloc_caps);
+        if (!cmd_ptr_set->cmd_ptr_set) {
+            heap_caps_free(cmd_ptr_set);
+            cmd_ptr_set = NULL;
+        } else {
+            /* copy the temp set of pointer in to the final destination */
+            memcpy(cmd_ptr_set->cmd_ptr_set, cmd_ptrs_temp, alloc_cmd_ptrs_size);
+            cmd_ptr_set->cmd_set_size = cmd_ptr_count;
+        }
+    }
+
+    return (esp_command_set_handle_t)cmd_ptr_set;
+}
+
+esp_command_set_handle_t esp_commands_concat_cmd_set(esp_command_set_handle_t cmd_set_a, esp_command_set_handle_t cmd_set_b)
+{
+    if (!cmd_set_a && !cmd_set_b) {
+        return NULL;
+    } else if (cmd_set_a && !cmd_set_b) {
+        return cmd_set_a;
+    } else if (!cmd_set_a && cmd_set_b) {
+        return cmd_set_b;
+    }
+
+    /* Reaching this point, both cmd_set_a and cmd_set_b are set.
+     * Create a new cmd_set that can host the items from both sets,
+     * assign the items to the new set and free the input sets */
+    const size_t new_set_size = cmd_set_a->cmd_set_size + cmd_set_b->cmd_set_size;
+    esp_command_set_t *concat_cmd_set = heap_caps_malloc(sizeof(esp_command_set_t), s_config.heap_alloc_caps);
+    if (!concat_cmd_set) {
+        return NULL;
+    }
+    concat_cmd_set->cmd_ptr_set = heap_caps_calloc(new_set_size, sizeof(esp_command_t *), s_config.heap_alloc_caps);
+    if (!concat_cmd_set->cmd_ptr_set) {
+        heap_caps_free(concat_cmd_set);
+        return NULL;
+    }
+
+    /* update the new cmd set size*/
+    concat_cmd_set->cmd_set_size = new_set_size;
+
+    /* fill the list of command pointers */
+    memcpy(concat_cmd_set->cmd_ptr_set,
+           cmd_set_a->cmd_ptr_set,
+           sizeof(esp_command_t *) * cmd_set_a->cmd_set_size);
+    memcpy(concat_cmd_set->cmd_ptr_set + cmd_set_a->cmd_set_size,
+           cmd_set_b->cmd_ptr_set,
+           sizeof(esp_command_t *) * cmd_set_b->cmd_set_size);
+
+    esp_commands_destroy_cmd_set(&cmd_set_a);
+    esp_commands_destroy_cmd_set(&cmd_set_b);
+
+    return (esp_command_set_handle_t)concat_cmd_set;
+}
+
+void esp_commands_destroy_cmd_set(esp_command_set_handle_t *cmd_set)
+{
+    if (!cmd_set || !*cmd_set) {
+        return;
+    }
+
+    if ((*cmd_set)->cmd_ptr_set) {
+        heap_caps_free((*cmd_set)->cmd_ptr_set);
+    }
+
+    heap_caps_free(*cmd_set);
+    *cmd_set = NULL;
+}
+
 void esp_commands_get_completion(esp_command_set_handle_t cmd_set, const char *buf, esp_command_get_completion_t completion_cb)
 {
     size_t len = strlen(buf);
@@ -201,6 +293,7 @@ const char *esp_commands_get_hint(esp_command_set_handle_t cmd_set, const char *
     return NULL;
 }
 
+<<<<<<< HEAD
 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) {
@@ -304,6 +397,8 @@ void esp_commands_destroy_cmd_set(esp_command_set_handle_t *cmd_set)
     free(*cmd_set);
     *cmd_set = NULL;
 }
+=======
+>>>>>>> 7bb19c4 (feat(esp_commands): Add tests to the esp_commands component)
 
 /* -------------------------------------------------------------- */
 /* help command related code */
@@ -314,25 +409,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");
     }
@@ -342,9 +437,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());
     }
 }
 
@@ -414,21 +509,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;
         }
@@ -453,11 +548,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 = '\\';