first working version

.vscode/tasks.json

@@ -0,0 +1,17 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"type": "shell",
+			"label": "build",
+			"command": "C:/Apps/mingw64/bin/ninja.exe",
+			"options": {
+				"cwd": "${workspaceFolder}/build"
+			},
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			}
+		}
+	]
+}

cmd_parser/cmd_parser.c

@@ -1,6 +1,89 @@
+#include "string.h"
+#include "stdint.h"
+
 #include "cmd_parser.h"
 
-void cmd_parse(char* msg)
+static const cmd_t **cmd_array;
-{
+static uint8_t cmd_array_size;
 
+void cmd_parser_init(const cmd_t *commands[], uint8_t size)
+{
+    cmd_array = commands;
+    cmd_array_size = size;
+}
+
+void msg_parse(char *msg)
+{
+    char *msgptr, *submsgptr;
+    parser_t parser = NULL;
+    result_t result = CMD_OK;
+    char key = 0;
+
+    char *token = strtok_r(msg, " ", &msgptr);
+    if (token[0] == '?')
+    {
+        // help message
+    }
+
+    for (uint8_t i = 0; i < cmd_array_size; i++)
+    {
+        if (strcmp(token, cmd_array[i]->name) == 0)
+        {
+            parser = cmd_array[i]->parser;
+            break;
+        }
+    }
+
+    if (parser == NULL)
+    {
+        return;
+    }
+
+    for (token = strtok_r(NULL, " ", &msgptr); token != NULL; token = strtok_r(NULL, " ", &msgptr))
+    {
+        if (token[0] == '-')
+        {
+            key = token[1];
+            result = parser(key, NULL);
+            if (strlen(token) > 2)
+            {
+                token = token + 2;
+            }
+        }
+
+        if (token[0] != '-')
+        {
+            switch (result)
+            {
+            case CMD_VALUE_REQ:
+                result = parser(key, token);
+                break;
+            case CMD_MULTIVAL_REQ:
+                for (char *subtoken = strtok_r(token, ", ", &submsgptr); subtoken != NULL; subtoken = strtok_r(NULL, ",", &submsgptr))
+                {
+                    if (parser(key, subtoken) == CMD_UNKNOWN)
+                    {
+                        result = parser(CMDP_KEY_ARG, subtoken);
+                    }
+                }
+                break;
+            default:
+                result = parser(CMDP_KEY_ARG, token);
+                break;
+            }
+        }
+        if (result == CMD_UNKNOWN)
+        {
+            break;
+        }
+    }
+
+    if (result != CMD_UNKNOWN)
+    {
+        parser(CMDP_KEY_DONE, NULL);
+    }
+    else
+    {
+        parser(CMDP_KEY_STOP, NULL);
+    }
 }

cmd_parser/cmd_parser.h

@@ -1,6 +1,24 @@
 #pragma once
 
-typedef void(*help_filter)(char key, const char *text);
+#define CMDP_KEY_DONE 1
-// void parser (int key, char *arg, struct argp_state *state);
+#define CMDP_KEY_ARG 2
+#define CMDP_KEY_STOP 3
 
-void cmd_parse(char* msg);
+typedef enum
+{
+    CMD_OK,
+    CMD_VALUE_REQ,
+    CMD_MULTIVAL_REQ,
+    CMD_UNKNOWN,
+} result_t;
+
+typedef result_t (*parser_t)(char key, char *arg);
+
+typedef struct
+{
+    char *name;
+    parser_t parser;
+} cmd_t;
+
+void cmd_parser_init(const cmd_t *commands[], uint8_t size);
+void msg_parse(char *msg);

cmd_parser/cmd_parser2.h

@@ -0,0 +1,59 @@
+#pragma once
+#include "main.h"
+
+#define CMDP_KEY_ARG 1
+
+typedef void (*help_filter)(char key, const char *text);
+// key = opt_id, arg = value or NULL
+// key = CMDP_KEY_ARG, arg = id_arg or token
+typedef enum
+{
+	CMD_NULL,
+    CMD_OK,
+    CMD_VALUE_REQ,
+    CMD_MULTIVAL_REQ,
+    CMD_UNKNOWN,
+} result_t;
+
+typedef result_t (*parser)(char key, char *arg);
+
+typedef enum
+{
+	NO_VALUE = 0,
+	SINGLE_VALE = 1,
+	MULTI_VALUE = 2,
+	NOT_OPTIONAL = 4,
+} option_flags_t;
+
+typedef const struct
+{
+	uint8_t opt_id;
+	char *name;
+	char *description;
+	option_flags_t flags;
+} option_t;
+
+typedef const struct
+{
+	char *name;
+	uint8_t arg_id;
+	char *description;
+	option_t *options;
+	uint8_t opt_num;
+	// parser arg_parser;
+} argument_t;
+
+typedef const struct
+{
+	char *name;
+	char *description;
+	argument_t *arguments;
+	uint8_t arg_num;
+	option_t *options;
+	uint8_t opt_num;
+	parser cmd_parser;
+} cmd_parser_t;
+
+void cmd_parser_init(cmd_parser_t* commands[], uint8_t size);
+// void cmd_parse(char *msg, parser parser);
+void cmd_parse(char *msg);

test/cmd_parser/CMakeLists.txt

@@ -5,12 +5,13 @@ set(TEST_NAME cmd_parser_test)
 set(INCLUDE_DIRS
     ../../cmd_parser
     helpers/inc
+    ../../utility/fff
 )
 
 set(SRCS
-    ../../cmd_parser/cmd_parser.c
+    ../../cmd_parser/cmd_parser2.c
 
-    # helpers/src/
+    # helpers/src/led_cmd.c
     cmd_parser_test.c
 )
 

test/cmd_parser/cmd_parser_test.c

@@ -1,29 +1,283 @@
-#include "stdlib.h"
-#include "string.h"
 #include "unity.h"
+#include "fff.h"
 #include "cmd_parser.h"
 
+DEFINE_FFF_GLOBALS;
+FAKE_VALUE_FUNC(result_t, parse_callback, char, char *);
+
+cmd_t led_cmd = {.name = "led", .parser = parse_callback};
 
 void setUp(void)
 {
+    RESET_FAKE(parse_callback);
+    FFF_RESET_HISTORY();
 }
 
 void tearDown(void)
 {
 }
 
-
+void test_splittoken1(void)
-void test_CommandDetetection(void)
 {
-    TEST_ASSERT(1==1);
+    char msg[] = "led";
+    parse_callback_fake.return_val = CMD_OK;
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(1, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken2(void)
+{
+    char msg[] = "led set";
+    parse_callback_fake.return_val = CMD_OK;
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(2, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_ARG, parse_callback_fake.arg0_history[0]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("set", parse_callback_fake.arg1_history[0], 3);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken3(void)
+{
+    char msg[] = "led set -p";
+    parse_callback_fake.return_val = CMD_OK;
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(3, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('p', parse_callback_fake.arg0_history[1]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[1]);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken4(void)
+{
+    char msg[] = "led set -p 50";
+    result_t returnValue[] = {CMD_OK, CMD_VALUE_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(4, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('p', parse_callback_fake.arg0_history[1]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[1]);
+    TEST_ASSERT_EQUAL_CHAR('p', parse_callback_fake.arg0_history[2]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("50", parse_callback_fake.arg1_history[2], 2);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken5(void)
+{
+    char msg[] = "led set -p 50 -l";
+    result_t returnValue[] = {CMD_OK, CMD_VALUE_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(5, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[3]);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken6(void)
+{
+    char msg[] = "led set -p 50 -l Atop, Btop, Ctop";
+    result_t returnValue[] = {CMD_OK, CMD_VALUE_REQ, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(8, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[3]);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[4]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Atop", parse_callback_fake.arg1_history[4], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[5]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Btop", parse_callback_fake.arg1_history[5], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[6]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Ctop", parse_callback_fake.arg1_history[6], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken7(void)
+{
+    char msg[] = "led set -p -l Atop, Btop, Ctop";
+    result_t returnValue[] = {CMD_OK, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(7, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[2]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[2]);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Atop", parse_callback_fake.arg1_history[3], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[4]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Btop", parse_callback_fake.arg1_history[4], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[5]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Ctop", parse_callback_fake.arg1_history[5], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken8(void)
+{
+    char msg[] = "led set -p -l Atop, Btop, Ctop test";
+    result_t returnValue[] = {CMD_OK, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK, CMD_OK, CMD_OK, CMD_UNKNOWN, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(9, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_ARG, parse_callback_fake.arg0_history[7]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("test", parse_callback_fake.arg1_history[7], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken9(void)
+{
+    char msg[] = "led set -p -l Atop, Btop, Wrong test";
+    result_t returnValue[] = {CMD_OK, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK, CMD_OK, CMD_UNKNOWN, CMD_UNKNOWN, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(8, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_STOP, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken10(void)
+{
+    char msg[] = "led set -p50";
+    result_t returnValue[] = {CMD_OK, CMD_VALUE_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(4, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('p', parse_callback_fake.arg0_history[1]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[1]);
+    TEST_ASSERT_EQUAL_CHAR('p', parse_callback_fake.arg0_history[2]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("50", parse_callback_fake.arg1_history[2], 2);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken11(void)
+{
+    char msg[] = "led set -p50 -l Atop,Btop,Ctop";
+    result_t returnValue[] = {CMD_OK, CMD_VALUE_REQ, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(8, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[3]);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[4]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Atop", parse_callback_fake.arg1_history[4], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[5]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Btop", parse_callback_fake.arg1_history[5], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[6]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Ctop", parse_callback_fake.arg1_history[6], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken12(void)
+{
+    char msg[] = "led set -p50 -lAtop,Btop,Ctop";
+    result_t returnValue[] = {CMD_OK, CMD_VALUE_REQ, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(8, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[3]);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[4]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Atop", parse_callback_fake.arg1_history[4], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[5]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Btop", parse_callback_fake.arg1_history[5], 4);
+    TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[6]);
+    TEST_ASSERT_EQUAL_CHAR_ARRAY("Ctop", parse_callback_fake.arg1_history[6], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_DONE, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
+
+void test_splittoken13(void)
+{
+    char msg[] = "led wrong";
+    result_t returnValue[] = {CMD_UNKNOWN, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, 5);
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(2, parse_callback_fake.call_count);
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_STOP, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+
+}
+
+void test_splittoken14(void)
+{
+    char msg[] = "led wrong -p 50 -l Atop,Btop,Ctop";
+    result_t returnValue[] = {CMD_UNKNOWN, CMD_VALUE_REQ, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(2, parse_callback_fake.call_count);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    // TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[3]);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[4]);
+    // TEST_ASSERT_EQUAL_CHAR_ARRAY("Atop", parse_callback_fake.arg1_history[4], 4);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[5]);
+    // TEST_ASSERT_EQUAL_CHAR_ARRAY("Btop", parse_callback_fake.arg1_history[5], 4);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[6]);
+    // TEST_ASSERT_EQUAL_CHAR_ARRAY("Ctop", parse_callback_fake.arg1_history[6], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_STOP, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
 }
 
 
+void test_splittoken15(void)
+{
+    char msg[] = "led set -X 50 -l Atop,Btop,Ctop";
+    result_t returnValue[] = {CMD_OK, CMD_UNKNOWN, CMD_OK, CMD_MULTIVAL_REQ, CMD_OK};
+    SET_RETURN_SEQ(parse_callback, returnValue, sizeof(returnValue) / sizeof(returnValue[0]));
+    msg_parse(msg);
+    TEST_ASSERT_EQUAL(3, parse_callback_fake.call_count);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[3]);
+    // TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_history[3]);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[4]);
+    // TEST_ASSERT_EQUAL_CHAR_ARRAY("Atop", parse_callback_fake.arg1_history[4], 4);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[5]);
+    // TEST_ASSERT_EQUAL_CHAR_ARRAY("Btop", parse_callback_fake.arg1_history[5], 4);
+    // TEST_ASSERT_EQUAL_CHAR('l', parse_callback_fake.arg0_history[6]);
+    // TEST_ASSERT_EQUAL_CHAR_ARRAY("Ctop", parse_callback_fake.arg1_history[6], 4);
+
+    TEST_ASSERT_EQUAL_UINT8(CMDP_KEY_STOP, parse_callback_fake.arg0_val);
+    TEST_ASSERT_EQUAL_PTR(NULL, parse_callback_fake.arg1_val);
+}
 
 int main(void)
 {
+    cmd_t led_cmd = {.name = "led", .parser = parse_callback};
+    const cmd_t *cmd_list[] = {&led_cmd};
+    cmd_parser_init(cmd_list, sizeof(cmd_list)/sizeof(cmd_list[0]) );
     UNITY_BEGIN();
-    RUN_TEST(test_CommandDetetection);
+    RUN_TEST(test_splittoken1);
-
+    RUN_TEST(test_splittoken2);
+    RUN_TEST(test_splittoken3);
+    RUN_TEST(test_splittoken4);
+    RUN_TEST(test_splittoken5);
+    RUN_TEST(test_splittoken6);
+    RUN_TEST(test_splittoken7);
+    RUN_TEST(test_splittoken8);
+    RUN_TEST(test_splittoken9);
+    RUN_TEST(test_splittoken10);
+    RUN_TEST(test_splittoken11);
+    RUN_TEST(test_splittoken12);
+    RUN_TEST(test_splittoken13);
+    RUN_TEST(test_splittoken14);
+    RUN_TEST(test_splittoken15);
     return UNITY_END();
 }

test/cmd_parser/helpers/inc/led_cmd.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "main.h"
+#include "cmd_parser.h"
+
+/*
+Usage: led set|get [-p PNUM | --power=PNUM] [-w CHOICES | --which=CHOICES] [-m COICES | --mode=CHOICES]
+    -p, --power     set or get power 0-100
+    -w, --which     set or get specific leds [Atop, Abot, Btop, Bbot, Ctop, Cbot, all]
+    -m, --mode      set or get mode of operation [allways_on, scan]
+*/
+// cmd_parser_t led_cmd;
+
+result_t parse_callback(char key, char *arg);

test/cmd_parser/helpers/inc/pwm_cmd.h

@@ -1,42 +0,0 @@
-#include "main.h"
-#include "cmd_parser.h"
-
-/*
-Usage: led set|get [-p PNUM | --power=PNUM] [-w CHOICES | --which=CHOICES] [-m COICES | --mode=CHOICES]
-    -p, --power     set or get power 0-100
-    -w, --which     set or get specific leds [Atop, Abot, Btop, Bbot, Ctop, Cbot, all]
-    -m, --mode      set or get mode of operation [allways_on, scan]
-*/
-
-typedef enum
-{
-    get,
-    set,
-} led_action_t;
-
-typedef enum
-{
-    Atop = (1 << 0),
-    Abot = (1 << 1),
-    Btop = (1 << 2),
-    Bbot = (1 << 3),
-    Ctop = (1 << 4),
-    Cbot = (1 << 5),
-    all = 0xFF,
-} led_leds_t;
-
-typedef enum
-{
-    allways_on,
-    scan,
-} led_mode_t;
-
-typedef struct
-{
-    led_action_t action;
-    uint8_t power;
-    led_leds_t leds;
-    led_mode_t mode;
-} led_option_t;
-
-void led_parse_callback(char key, const char *text);

test/cmd_parser/helpers/src/led_cmd.c

@@ -0,0 +1,62 @@
+#include "led_cmd.h"
+
+enum {set, get};
+
+option_t set_options[] = {
+    {
+        .opt_id = 'p',
+        .name = "power",
+        .flags = SINGLE_VALE,
+        .description = "sets the power of the light",
+    },
+
+    {
+        .opt_id = 'l',
+        .name = "led",
+        .flags = MULTI_VALUE,
+        .description = "diode selection. OPTIONS = [Atop, Abot, Btop, Bbot, Ctop, Cbot, all]",
+    }
+
+};
+
+option_t get_options[] = {
+    {
+        .opt_id = 'p',
+        .name = "power",
+        .flags = NO_VALUE,
+        .description = "gets the power of the light",
+    },
+
+    {
+        .opt_id = 'l',
+        .name = "led",
+        .flags = MULTI_VALUE,
+        .description = "diode selection. OPTIONS = [Atop, Abot, Btop, Bbot, Ctop, Cbot, all]",
+    }
+
+};
+
+argument_t arguments[] = {
+    {
+        .name = "set",
+        .arg_id = set,
+        .options = set_options,
+        .opt_num = sizeof(set_options) / (sizeof(set_options[0])),
+        .description = "allows to set operating parameters",
+    },
+    {
+        .name = "get",
+        .arg_id = get,
+        .options = get_options,
+        .opt_num = sizeof(get_options) / (sizeof(get_options[0])),
+        .description = "allows to get operating parameters",
+    },
+};
+
+cmd_parser_t led_cmd = {
+    .name = "led",
+    .arguments = arguments,
+    .arg_num = sizeof(arguments) / sizeof(arguments[0]),
+    .description = "allows to controll and check leds",
+    .cmd_parser = parse_callback,
+};