From cba6bef80929ab01d87fb14e82022420c7068fb5 Mon Sep 17 00:00:00 2001 From: Leandro Lanzieri Date: Thu, 28 Mar 2019 11:46:03 +0100 Subject: [PATCH] sys: Rename Link Format to clif --- sys/Makefile.include | 4 +- sys/{link_format => clif}/Makefile | 2 +- .../link_format.c => clif/clif.c} | 81 ++++++------- .../include/clif_internal.h} | 10 +- sys/include/{link_format.h => clif.h} | 98 +++++++-------- .../Makefile | 0 tests/unittests/tests-clif/Makefile.include | 1 + .../tests-clif.c} | 112 +++++++++--------- .../tests-clif.h} | 12 +- .../tests-link_format/Makefile.include | 1 - 10 files changed, 159 insertions(+), 162 deletions(-) rename sys/{link_format => clif}/Makefile (62%) rename sys/{link_format/link_format.c => clif/clif.c} (75%) rename sys/{link_format/include/link_format_internal.h => clif/include/clif_internal.h} (93%) rename sys/include/{link_format.h => clif.h} (62%) rename tests/unittests/{tests-link_format => tests-clif}/Makefile (100%) create mode 100644 tests/unittests/tests-clif/Makefile.include rename tests/unittests/{tests-link_format/tests-link_format.c => tests-clif/tests-clif.c} (63%) rename tests/unittests/{tests-link_format/tests-link_format.h => tests-clif/tests-clif.h} (74%) delete mode 100644 tests/unittests/tests-link_format/Makefile.include diff --git a/sys/Makefile.include b/sys/Makefile.include index 7cf01563378b6..9f7fbd4e440b5 100644 --- a/sys/Makefile.include +++ b/sys/Makefile.include @@ -100,6 +100,6 @@ ifneq (native,$(BOARD)) INCLUDES += -I$(RIOTBASE)/sys/libc/include endif -ifneq (,$(filter link_format, $(USEMODULE))) - INCLUDES += -I$(RIOTBASE)/sys/link_format/include +ifneq (,$(filter clif, $(USEMODULE))) + INCLUDES += -I$(RIOTBASE)/sys/clif/include endif diff --git a/sys/link_format/Makefile b/sys/clif/Makefile similarity index 62% rename from sys/link_format/Makefile rename to sys/clif/Makefile index f72b62ace1cd7..94c3002967fd2 100644 --- a/sys/link_format/Makefile +++ b/sys/clif/Makefile @@ -1,3 +1,3 @@ -MODULE = link_format +MODULE = clif include $(RIOTBASE)/Makefile.base diff --git a/sys/link_format/link_format.c b/sys/clif/clif.c similarity index 75% rename from sys/link_format/link_format.c rename to sys/clif/clif.c index d8161b1fcef52..a4a7c1e95fde6 100644 --- a/sys/link_format/link_format.c +++ b/sys/clif/clif.c @@ -7,11 +7,11 @@ */ /** - * @ingroup sys_link_format + * @ingroup sys_clif * @{ * * @file - * @brief Link format encoding and decoding library implementation + * @brief CoRE Link format encoding and decoding library implementation * * @author Leandro Lanzieri * @} @@ -21,8 +21,8 @@ #include #include -#include "link_format.h" -#include "link_format_internal.h" +#include "clif.h" +#include "clif_internal.h" #define ENABLE_DEBUG (0) #include "debug.h" @@ -44,9 +44,9 @@ static const unsigned _param_to_size[] = { /* do not count extension param type */ #define PARAMS_NUMOF (sizeof(_param_to_str) / sizeof(_param_to_str[0]) - 1) -unsigned link_format_decode_links(link_format_t *links, unsigned links_len, - link_format_param_t *params, - unsigned params_len, char *buf, size_t maxlen) +unsigned clif_decode_links(clif_t *links, unsigned links_len, + clif_param_t *params, unsigned params_len, + char *buf, size_t maxlen) { assert(buf); char *pos = buf; @@ -61,22 +61,21 @@ unsigned link_format_decode_links(link_format_t *links, unsigned links_len, links[links_numof].params_len = 0; /* first determine where the next link is and how long it is */ - ssize_t size = link_format_get_link(pos, end - pos, &link); + ssize_t size = clif_get_link(pos, end - pos, &link); if (size < 0) { goto out; } pos = link + size; /* now get the target and params of the link */ - size = link_format_get_target(link, size, &links[links_numof].target); + size = clif_get_target(link, size, &links[links_numof].target); if (size < 0) { - return LINK_FORMAT_NOT_FOUND; + return CLIF_NOT_FOUND; } char *pos_in_link = links[links_numof].target + size; while (params_numof < params_len) { - ssize_t param_size = link_format_get_param(pos_in_link, - pos - pos_in_link, - ¶ms[params_numof]); + ssize_t param_size = clif_get_param(pos_in_link, pos - pos_in_link, + ¶ms[params_numof]); if (param_size < 0) { break; } @@ -92,21 +91,21 @@ unsigned link_format_decode_links(link_format_t *links, unsigned links_len, return links_numof; } -ssize_t link_format_encode_link(link_format_t *link, char *buf, size_t maxlen) +ssize_t clif_encode_link(clif_t *link, char *buf, size_t maxlen) { assert(link); size_t pos = 0; ssize_t res = 0; - res = link_format_add_target(link->target, buf, maxlen); + res = clif_add_target(link->target, buf, maxlen); if (res <= 0) { return res; } pos += res; for (unsigned i = 0; i < link->params_len; i++) { - res = link_format_add_param(&link->params[i], buf ? &buf[pos] : NULL, - maxlen - pos); + res = clif_add_param(&link->params[i], buf ? &buf[pos] : NULL, + maxlen - pos); if (res <= 0) { return res; } @@ -115,7 +114,7 @@ ssize_t link_format_encode_link(link_format_t *link, char *buf, size_t maxlen) return pos; } -ssize_t link_format_add_target(const char *target, char *buf, size_t maxlen) +ssize_t clif_add_target(const char *target, char *buf, size_t maxlen) { assert(target); @@ -127,7 +126,7 @@ ssize_t link_format_add_target(const char *target, char *buf, size_t maxlen) } if ((target_len + 2) > maxlen) { - return LINK_FORMAT_NO_SPACE; + return CLIF_NO_SPACE; } buf[pos++] = LF_PATH_BEGIN_C; @@ -140,31 +139,31 @@ ssize_t link_format_add_target(const char *target, char *buf, size_t maxlen) return pos; } -ssize_t link_format_add_link_separator(char *buf, size_t maxlen) +ssize_t clif_add_link_separator(char *buf, size_t maxlen) { if (!buf) { return 1; } if (maxlen < 1) { - return LINK_FORMAT_NO_SPACE; + return CLIF_NO_SPACE; } *buf = LF_LINK_SEPARATOR_C; return 1; } -ssize_t link_format_add_param(link_format_param_t *param, char *buf, +ssize_t clif_add_param(clif_param_t *param, char *buf, size_t maxlen) { assert(param); /* if it is an extension the 'ext' field should be provided */ - assert(!(param->type == LINK_FORMAT_PARAM_EXT && !param->ext)); + assert(!(param->type == CLIF_PARAM_EXT && !param->ext)); /* count param name size and separator ';' */ size_t req_space = _param_to_size[param->type] + 1; size_t pos = 0; - int quoted = (param->type == LINK_FORMAT_PARAM_SZ) ? 0 : 1; + int quoted = (param->type == CLIF_PARAM_SZ) ? 0 : 1; if (param->value) { if (!param->value_len) { @@ -174,7 +173,7 @@ ssize_t link_format_add_param(link_format_param_t *param, char *buf, req_space += param->value_len + 1; } - if (param->type == LINK_FORMAT_PARAM_EXT && !param->ext_len) { + if (param->type == CLIF_PARAM_EXT && !param->ext_len) { param->ext_len = strlen(param->ext); req_space += param->ext_len; } @@ -188,14 +187,14 @@ ssize_t link_format_add_param(link_format_param_t *param, char *buf, } if (req_space > maxlen) { - return LINK_FORMAT_NO_SPACE; + return CLIF_NO_SPACE; } /* add parameter separator ';' */ buf[pos++] = LF_PARAM_SEPARATOR_C; /* add parameter name */ - if (param->type == LINK_FORMAT_PARAM_EXT) { + if (param->type == CLIF_PARAM_EXT) { memcpy(&buf[pos], param->ext, param->ext_len); pos += param->ext_len; } @@ -223,15 +222,15 @@ ssize_t link_format_add_param(link_format_param_t *param, char *buf, return pos; } -ssize_t link_format_get_link(const char *input, size_t input_len, char **output) +ssize_t clif_get_link(const char *input, size_t input_len, char **output) { assert(input); char *link_end; - ssize_t path_size = link_format_get_target(input, input_len, output); + ssize_t path_size = clif_get_target(input, input_len, output); if (path_size < 0) { DEBUG("Path not found\n"); - return LINK_FORMAT_NOT_FOUND; + return CLIF_NOT_FOUND; } (*output)--; @@ -248,8 +247,7 @@ ssize_t link_format_get_link(const char *input, size_t input_len, char **output) } } -ssize_t link_format_get_target(const char *input, size_t input_len, - char **output) +ssize_t clif_get_target(const char *input, size_t input_len, char **output) { assert(input); char *target_end; @@ -257,21 +255,20 @@ ssize_t link_format_get_target(const char *input, size_t input_len, *output = memchr(input, LF_PATH_BEGIN_C, input_len); if (!*output) { DEBUG("Path start not found\n"); - return LINK_FORMAT_NOT_FOUND; + return CLIF_NOT_FOUND; } *output += 1; target_end = memchr(*output, LF_PATH_END_C, (input + input_len) - *output); if (!target_end) { DEBUG("Path end not found\n"); - return LINK_FORMAT_NOT_FOUND; + return CLIF_NOT_FOUND; } ssize_t res = target_end - *output; return res; } -ssize_t link_format_get_param(char *input, size_t input_len, - link_format_param_t *param) +ssize_t clif_get_param(char *input, size_t input_len, clif_param_t *param) { assert(input && param); char *param_start; @@ -286,7 +283,7 @@ ssize_t link_format_get_param(char *input, size_t input_len, param_start = memchr(input, LF_PARAM_SEPARATOR_C, input_len); if (!param_start) { DEBUG("Attribute separator not found\n"); - return LINK_FORMAT_NOT_FOUND; + return CLIF_NOT_FOUND; } param_start++; @@ -303,7 +300,7 @@ ssize_t link_format_get_param(char *input, size_t input_len, if (!param->value) { DEBUG("Attribute name / value separator not found: assuming extension\n"); /* if there is no name / value separator it is considered an extension */ - param->type = LINK_FORMAT_PARAM_EXT; + param->type = CLIF_PARAM_EXT; param->ext = param_start; param->ext_len = input_end - param->ext; param->value_len = 0; @@ -323,7 +320,7 @@ ssize_t link_format_get_param(char *input, size_t input_len, end = memchr(param->value, '"', input_end - param->value + 1); if (!end) { DEBUG("Closing quotes not found\n"); - return LINK_FORMAT_NOT_FOUND; + return CLIF_NOT_FOUND; } else { param->value_len = end - param->value; @@ -346,7 +343,7 @@ ssize_t link_format_get_param(char *input, size_t input_len, } /* try to determine the parameter type */ - param->type = LINK_FORMAT_PARAM_EXT; + param->type = CLIF_PARAM_EXT; for (unsigned i = 0; i < PARAMS_NUMOF; i++) { if (!strncmp(param_start, _param_to_str[i], param_length)) { param->type = i; @@ -355,7 +352,7 @@ ssize_t link_format_get_param(char *input, size_t input_len, } /* if it is an extension add the extra information */ - if (param->type == LINK_FORMAT_PARAM_EXT) { + if (param->type == CLIF_PARAM_EXT) { param->ext = param_start; param->ext_len = param_length; } @@ -363,6 +360,6 @@ ssize_t link_format_get_param(char *input, size_t input_len, return input_end - input; } -const char *link_format_param_type_to_str(link_format_param_type_t type) { +const char *clif_param_type_to_str(clif_param_type_t type) { return _param_to_str[type]; } diff --git a/sys/link_format/include/link_format_internal.h b/sys/clif/include/clif_internal.h similarity index 93% rename from sys/link_format/include/link_format_internal.h rename to sys/clif/include/clif_internal.h index 0b524ebdb98d0..402ef427b835f 100644 --- a/sys/link_format/include/link_format_internal.h +++ b/sys/clif/include/clif_internal.h @@ -7,17 +7,17 @@ */ /** - * @ingroup sys_link_format + * @ingroup sys_clif * * @{ * * @file - * @brief Internal definitions for Link format module + * @brief Internal definitions for CoRE Link format module * * @author Leandro Lanzieri */ -#ifndef LINK_FORMAT_INTERNAL_H -#define LINK_FORMAT_INTERNAL_H +#ifndef CLIF_INTERNAL_H +#define CLIF_INTERNAL_H #ifdef __cplusplus extern "C" { @@ -141,5 +141,5 @@ extern "C" { } #endif -#endif /* LINK_FORMAT_INTERNAL_H */ +#endif /* CLIF_INTERNAL_H */ /** @} */ diff --git a/sys/include/link_format.h b/sys/include/clif.h similarity index 62% rename from sys/include/link_format.h rename to sys/include/clif.h index 5262a76b62eba..5181a512853f6 100644 --- a/sys/include/link_format.h +++ b/sys/include/clif.h @@ -7,68 +7,68 @@ */ /** - * @defgroup sys_link_format Link Format + * @defgroup sys_clif CoRE Link Format * @ingroup sys_serialization - * @brief Simple encoding and decoding of Link Format strings + * @brief Simple encoding and decoding of CoRE Link Format strings * * @{ * * @file - * @brief Link format encoding and decoding library public definitions + * @brief CoRE Link Format encoding and decoding library public + * definitions * * @author Leandro Lanzieri */ -#ifndef LINK_FORMAT_H -#define LINK_FORMAT_H +#ifndef CLIF_H +#define CLIF_H #include -#include "link_format_internal.h" +#include "clif_internal.h" #ifdef __cplusplus extern "C" { #endif /** - * @brief Return types for the @ref sys_link_format API + * @brief Return types for the @ref sys_clif API */ enum { - LINK_FORMAT_OK = 0, /**< success */ - LINK_FORMAT_NO_SPACE = -1, /**< not enough space in the buffer */ - LINK_FORMAT_NOT_FOUND = -2 /**< could not find a component in a - buffer */ + CLIF_OK = 0, /**< success */ + CLIF_NO_SPACE = -1, /**< not enough space in the buffer */ + CLIF_NOT_FOUND = -2 /**< could not find a component in a buffer */ }; /** * @brief Types of link format parameters */ typedef enum { - LINK_FORMAT_PARAM_ANCHOR = 0, /**< anchor */ - LINK_FORMAT_PARAM_REL = 1, /**< rel */ - LINK_FORMAT_PARAM_LANG = 2, /**< hreflang */ - LINK_FORMAT_PARAM_MEDIA = 3, /**< media */ - LINK_FORMAT_PARAM_TITLE = 4, /**< title */ - LINK_FORMAT_PARAM_TITLE_EXT = 5, /**< title* */ - LINK_FORMAT_PARAM_TYPE = 6, /**< type */ - LINK_FORMAT_PARAM_RT = 7, /**< rt */ - LINK_FORMAT_PARAM_IF = 8, /**< if */ - LINK_FORMAT_PARAM_SZ = 9, /**< sz */ - LINK_FORMAT_PARAM_CT = 10, /**< ct */ - LINK_FORMAT_PARAM_EXT = 11 /**< extensions */ -} link_format_param_type_t; + CLIF_PARAM_ANCHOR = 0, /**< anchor */ + CLIF_PARAM_REL = 1, /**< rel */ + CLIF_PARAM_LANG = 2, /**< hreflang */ + CLIF_PARAM_MEDIA = 3, /**< media */ + CLIF_PARAM_TITLE = 4, /**< title */ + CLIF_PARAM_TITLE_EXT = 5, /**< title* */ + CLIF_PARAM_TYPE = 6, /**< type */ + CLIF_PARAM_RT = 7, /**< rt */ + CLIF_PARAM_IF = 8, /**< if */ + CLIF_PARAM_SZ = 9, /**< sz */ + CLIF_PARAM_CT = 10, /**< ct */ + CLIF_PARAM_EXT = 11 /**< extensions */ +} clif_param_type_t; /** * @brief Link format parameter descriptor */ typedef struct { - link_format_param_type_t type; /**< type of parameter */ + clif_param_type_t type; /**< type of parameter */ char *value; /**< string with the value */ unsigned value_len; /**< length of the value */ char *ext; /**< parameter name in case of extension */ unsigned ext_len; /**< length of the parameter name in case of extension */ -} link_format_param_t; +} clif_param_t; /** * @brief Link format descriptor @@ -76,9 +76,9 @@ typedef struct { typedef struct { char *target; /**< target string */ unsigned target_len; /**< length of target string */ - link_format_param_t *params; /**< array of parameters */ + clif_param_t *params; /**< array of parameters */ unsigned params_len; /**< size of array of parameters */ -} link_format_t; +} clif_t; /** * @brief Encodes a given link in link format into a given buffer @@ -91,9 +91,9 @@ typedef struct { * needed * * @return amount of bytes used from @p buf in success - * @return LINK_FORMAT_NO_SPACE if there is not enough space in the buffer + * @return CLIF_NO_SPACE if there is not enough space in the buffer */ -ssize_t link_format_encode_link(link_format_t *link, char *buf, size_t maxlen); +ssize_t clif_encode_link(clif_t *link, char *buf, size_t maxlen); /** * @brief Decodes a string of link format @@ -106,11 +106,11 @@ ssize_t link_format_encode_link(link_format_t *link, char *buf, size_t maxlen); * @param[in] maxlen size of @p buf * * @return amount of decoded links in success - * @return LINK_FORMAT_NOT_FOUND if the string is malformed + * @return CLIF_NOT_FOUND if the string is malformed */ -unsigned link_format_decode_links(link_format_t *links, unsigned links_len, - link_format_param_t *params, - unsigned params_len, char *buf, size_t maxlen); +unsigned clif_decode_links(clif_t *links, unsigned links_len, + clif_param_t *params, unsigned params_len, + char *buf, size_t maxlen); /** * @brief Adds a given @p target to a given buffer @p buf using link format @@ -123,9 +123,9 @@ unsigned link_format_decode_links(link_format_t *links, unsigned links_len, * needed * * @return in success the amount of bytes used in the buffer - * @return LINK_FORMAT_NO_SPACE if there is not enough space in the buffer + * @return CLIF_NO_SPACE if there is not enough space in the buffer */ -ssize_t link_format_add_target(const char *target, char *buf, size_t maxlen); +ssize_t clif_add_target(const char *target, char *buf, size_t maxlen); /** * @brief Adds a given @p parameter to a given buffer @p buf using link format @@ -138,9 +138,9 @@ ssize_t link_format_add_target(const char *target, char *buf, size_t maxlen); * needed * * @return amount of bytes used from the buffer if successful - * @return LINK_FORMAT_NO_SPACE if there is not enough space in the buffer + * @return CLIF_NO_SPACE if there is not enough space in the buffer */ -ssize_t link_format_add_param(link_format_param_t *param, char *buf, +ssize_t clif_add_param(clif_param_t *param, char *buf, size_t maxlen); /** @@ -154,9 +154,9 @@ ssize_t link_format_add_param(link_format_param_t *param, char *buf, * needed * * @return amount of bytes used from buffer if successful - * @return LINK_FORMAT_NO_SPACE if there is not enough space in the buffer + * @return CLIF_NO_SPACE if there is not enough space in the buffer */ -ssize_t link_format_add_link_separator(char *buf, size_t maxlen); +ssize_t clif_add_link_separator(char *buf, size_t maxlen); /** * @brief Looks for a link in a given string @p input. If multiple link are @@ -168,9 +168,9 @@ ssize_t link_format_add_link_separator(char *buf, size_t maxlen); * of it * * @return length of the link if found - * @return LINK_FORMAT_NOT_FOUND if no valid link is found + * @return CLIF_NOT_FOUND if no valid link is found */ -ssize_t link_format_get_link(const char *input, size_t input_len, +ssize_t clif_get_link(const char *input, size_t input_len, char **output); /** @@ -183,9 +183,9 @@ ssize_t link_format_get_link(const char *input, size_t input_len, * beginning of it * * @return length of the target if found - * @return LINK_FORMAT_NOT_FOUND if no valid target is found + * @return CLIF_NOT_FOUND if no valid target is found */ -ssize_t link_format_get_target(const char *input, size_t input_len, +ssize_t clif_get_target(const char *input, size_t input_len, char **output); /** * @brief Looks for the first parameter in a given link. @@ -196,10 +196,10 @@ ssize_t link_format_get_target(const char *input, size_t input_len, * @param[out] param pointer to store the found parameter information * * @return length of the parameter in the buffer if found - * @return LINK_FORMAT_NOT_FOUND if no valid parameter is found + * @return CLIF_NOT_FOUND if no valid parameter is found */ -ssize_t link_format_get_param(char *input, size_t input_len, - link_format_param_t *param); +ssize_t clif_get_param(char *input, size_t input_len, + clif_param_t *param); /** * @brief Returns the string of a given parameter type @@ -208,11 +208,11 @@ ssize_t link_format_get_param(char *input, size_t input_len, * * @return string that represents the type */ -const char *link_format_param_type_to_str(link_format_param_type_t type); +const char *clif_param_type_to_str(clif_param_type_t type); #ifdef __cplusplus } #endif -#endif /* LINK_FORMAT_H */ +#endif /* CLIF_H */ /** @} */ diff --git a/tests/unittests/tests-link_format/Makefile b/tests/unittests/tests-clif/Makefile similarity index 100% rename from tests/unittests/tests-link_format/Makefile rename to tests/unittests/tests-clif/Makefile diff --git a/tests/unittests/tests-clif/Makefile.include b/tests/unittests/tests-clif/Makefile.include new file mode 100644 index 0000000000000..fdeca4902bc22 --- /dev/null +++ b/tests/unittests/tests-clif/Makefile.include @@ -0,0 +1 @@ +USEMODULE += clif diff --git a/tests/unittests/tests-link_format/tests-link_format.c b/tests/unittests/tests-clif/tests-clif.c similarity index 63% rename from tests/unittests/tests-link_format/tests-link_format.c rename to tests/unittests/tests-clif/tests-clif.c index 72d29d1faf75a..d3f8401046e75 100644 --- a/tests/unittests/tests-link_format/tests-link_format.c +++ b/tests/unittests/tests-clif/tests-clif.c @@ -8,16 +8,16 @@ #include #include "embUnit.h" -#include "tests-link_format.h" +#include "tests-clif.h" -#include "link_format.h" +#include "clif.h" -#ifdef TESTS_LINK_FORMAT_PRINT +#ifdef TESTS_CLIF_PRINT #include -static void _print_param(link_format_param_t *param) +static void _print_param(clif_param_t *param) { printf("-- Param: "); - if (param->type == LINK_FORMAT_PARAM_EXT) { + if (param->type == CLIF_PARAM_EXT) { printf("%.*s", param->ext_len, param->ext); if (param->value) { printf(" = %.*s\n", param->value_len, param->value); @@ -27,11 +27,11 @@ static void _print_param(link_format_param_t *param) } } else { - printf("%s = %.*s\n", link_format_param_type_to_str(param->type), + printf("%s = %.*s\n", clif_param_type_to_str(param->type), param->value_len, param->value); } } -#endif /* TESTS_LINK_FORMAT_PRINT */ +#endif /* TESTS_CLIF_PRINT */ /** * @brief Compares two link format parameters @@ -42,7 +42,7 @@ static void _print_param(link_format_param_t *param) * @return 0 if parameters are equal * @return 1 otherwise */ -static unsigned _compare_params(link_format_param_t *p1, link_format_param_t *p2) +static unsigned _compare_params(clif_param_t *p1, clif_param_t *p2) { unsigned result = 1; int res; @@ -50,7 +50,7 @@ static unsigned _compare_params(link_format_param_t *p1, link_format_param_t *p2 if (p1->type != p2->type) { goto out; } - if (p1->type == LINK_FORMAT_PARAM_EXT) { + if (p1->type == CLIF_PARAM_EXT) { if (!p1->ext || !p2->ext || (p1->ext_len != p2->ext_len)) { goto out; } @@ -79,19 +79,19 @@ static unsigned _compare_params(link_format_param_t *p1, link_format_param_t *p2 return result; } -/* This also tests the functions `link_format_add_target` and - * `link_format_add_param`. */ -static void test_link_format_encode_links(void) +/* This also tests the functions `clif_add_target` and + * `clif_add_param`. */ +static void test_clif_encode_links(void) { const char exp_string[] = ";rt=\"temperature\";if=\"sensor\"," ",;ct=\"40\""; - link_format_param_t params[] = { - { .type = LINK_FORMAT_PARAM_RT, .value = "temperature" }, - { .type = LINK_FORMAT_PARAM_IF, .value = "sensor" }, - { .type = LINK_FORMAT_PARAM_CT, .value = "40" } + clif_param_t params[] = { + { .type = CLIF_PARAM_RT, .value = "temperature" }, + { .type = CLIF_PARAM_IF, .value = "sensor" }, + { .type = CLIF_PARAM_CT, .value = "40" } }; - link_format_t links[] = { + clif_t links[] = { { .target = "/sensor/temp", .params = params, .params_len = 2 }, { .target = "/node/info", .params_len = 0 }, { .target = "/node/ep", .params = ¶ms[2], .params_len = 1 } @@ -103,17 +103,17 @@ static void test_link_format_encode_links(void) ssize_t res = 0; /* first test with NULL output to check the needed bytes */ - res = link_format_encode_link(&links[0], NULL, 0); + res = clif_encode_link(&links[0], NULL, 0); pos += res; for (unsigned i = 1; i < sizeof(links) / sizeof(links[0]); i++) { - res = link_format_add_link_separator(NULL, 0); + res = clif_add_link_separator(NULL, 0); if (res <= 0) { break; } pos += res; - res = link_format_encode_link(&links[i],NULL, 0); + res = clif_encode_link(&links[i],NULL, 0); if (res <= 0) { break; } @@ -124,17 +124,17 @@ static void test_link_format_encode_links(void) /* now actually encode the links */ pos = 0; - res = link_format_encode_link(&links[0], output, sizeof(output)); + res = clif_encode_link(&links[0], output, sizeof(output)); pos += res; for (unsigned i = 1; i < sizeof(links) / sizeof(links[0]); i++) { - res = link_format_add_link_separator(&output[pos], sizeof(output) - pos); + res = clif_add_link_separator(&output[pos], sizeof(output) - pos); if (res <= 0) { break; } pos += res; - res = link_format_encode_link(&links[i], &output[pos], sizeof(output) - pos); + res = clif_encode_link(&links[i], &output[pos], sizeof(output) - pos); if (res <= 0) { break; } @@ -142,7 +142,7 @@ static void test_link_format_encode_links(void) } output[pos++] = '\0'; -#ifdef TESTS_LINK_FORMAT_PRINT +#ifdef TESTS_CLIF_PRINT puts("\n========================================"); puts("[Test: encode_links]"); puts("---------------------"); @@ -153,9 +153,9 @@ static void test_link_format_encode_links(void) TEST_ASSERT_EQUAL_INT(exp_size, pos - 1); /* do not count '\0' */ } -/* This also tests the functions `link_format_get_link`, - * `link_format_get_target` and `link_format_get_param` */ -static void test_link_format_decode_links(void) +/* This also tests the functions `clif_get_link`, + * `clif_get_target` and `clif_get_param` */ +static void test_clif_decode_links(void) { char input_string[] = ";ct=40;title=\"Sensor Index\"," ";rt=\"temperature-c\";if=\"sensor\"," @@ -165,30 +165,30 @@ static void test_link_format_decode_links(void) ";anchor=\"/sensors/temp\";rel=\"alternate\";s," ","; - link_format_param_t exp_params[] = { - { .type = LINK_FORMAT_PARAM_CT, .value = "40", + clif_param_t exp_params[] = { + { .type = CLIF_PARAM_CT, .value = "40", .value_len = sizeof("40") - 1 }, - { .type = LINK_FORMAT_PARAM_TITLE, .value = "Sensor Index", + { .type = CLIF_PARAM_TITLE, .value = "Sensor Index", .value_len = sizeof("Sensor Index") - 1 }, - { .type = LINK_FORMAT_PARAM_RT, .value = "temperature-c", + { .type = CLIF_PARAM_RT, .value = "temperature-c", .value_len = sizeof("temperature-c") - 1 }, - { .type = LINK_FORMAT_PARAM_IF, .value = "sensor", + { .type = CLIF_PARAM_IF, .value = "sensor", .value_len = sizeof("sensor") - 1 }, - { .type = LINK_FORMAT_PARAM_RT, .value = "light-lux", + { .type = CLIF_PARAM_RT, .value = "light-lux", .value_len = sizeof("light-lux") - 1 }, - { .type = LINK_FORMAT_PARAM_IF, .value = "sensor", + { .type = CLIF_PARAM_IF, .value = "sensor", .value_len = sizeof("sensor") - 1 }, - { .type = LINK_FORMAT_PARAM_ANCHOR, .value = "/sensors/temp", + { .type = CLIF_PARAM_ANCHOR, .value = "/sensors/temp", .value_len = sizeof("/sensors/temp") - 1}, - { .type = LINK_FORMAT_PARAM_REL, .value = "describedby", + { .type = CLIF_PARAM_REL, .value = "describedby", .value_len = sizeof("describedby") - 1 }, - { .type = LINK_FORMAT_PARAM_SZ, .value = "1234", + { .type = CLIF_PARAM_SZ, .value = "1234", .value_len = sizeof("1234") - 1 }, - { .type = LINK_FORMAT_PARAM_ANCHOR, .value = "/sensors/temp", + { .type = CLIF_PARAM_ANCHOR, .value = "/sensors/temp", .value_len = sizeof("/sensors/temp") - 1 }, - { .type = LINK_FORMAT_PARAM_REL, .value = "alternate", + { .type = CLIF_PARAM_REL, .value = "alternate", .value_len = sizeof("alternate") - 1 }, - { .type = LINK_FORMAT_PARAM_EXT, .ext = "s", .ext_len = 1, + { .type = CLIF_PARAM_EXT, .ext = "s", .ext_len = 1, .value_len = 0 } }; const char *exp_targets[] = { @@ -199,14 +199,14 @@ static void test_link_format_decode_links(void) const unsigned exp_links_numof = sizeof(exp_targets) / sizeof(exp_targets[0]); const unsigned exp_params_numof = sizeof(exp_params) / sizeof(exp_params[0]); - link_format_t out_links[exp_links_numof]; - link_format_param_t out_params[exp_params_numof]; + clif_t out_links[exp_links_numof]; + clif_param_t out_params[exp_params_numof]; - unsigned links_numof = link_format_decode_links(out_links, exp_links_numof, - out_params, exp_params_numof, - input_string, - strlen(input_string)); -#ifdef TESTS_LINK_FORMAT_PRINT + unsigned links_numof = clif_decode_links(out_links, exp_links_numof, + out_params, exp_params_numof, + input_string, + strlen(input_string)); +#ifdef TESTS_CLIF_PRINT puts("\n========================================"); puts("[Test: decode_links]"); printf("- Amount of decoded links: %u\n", links_numof); @@ -217,7 +217,7 @@ static void test_link_format_decode_links(void) for (unsigned i = 0; i < exp_links_numof; i++) { TEST_ASSERT(!strncmp(exp_targets[i], out_links[i].target, out_links[i].target_len)); -#ifdef TESTS_LINK_FORMAT_PRINT +#ifdef TESTS_CLIF_PRINT puts("---------------------"); puts("New link:"); printf("- Target: %.*s\n", out_links[i].target_len, out_links[i].target); @@ -227,26 +227,26 @@ static void test_link_format_decode_links(void) TEST_ASSERT(!_compare_params(&out_links[i].params[j], &exp_params[params_numof])); params_numof++; -#ifdef TESTS_LINK_FORMAT_PRINT +#ifdef TESTS_CLIF_PRINT _print_param(&out_links[i].params[j]); #endif } } } -Test *tests_link_format_tests(void) +Test *tests_clif_tests(void) { EMB_UNIT_TESTFIXTURES(fixtures) { - new_TestFixture(test_link_format_encode_links), - new_TestFixture(test_link_format_decode_links) + new_TestFixture(test_clif_encode_links), + new_TestFixture(test_clif_decode_links) }; - EMB_UNIT_TESTCALLER(link_format_tests, NULL, NULL, fixtures); + EMB_UNIT_TESTCALLER(clif_tests, NULL, NULL, fixtures); - return (Test *)&link_format_tests; + return (Test *)&clif_tests; } -void tests_link_format(void) +void tests_clif(void) { - TESTS_RUN(tests_link_format_tests()); + TESTS_RUN(tests_clif_tests()); } diff --git a/tests/unittests/tests-link_format/tests-link_format.h b/tests/unittests/tests-clif/tests-clif.h similarity index 74% rename from tests/unittests/tests-link_format/tests-link_format.h rename to tests/unittests/tests-clif/tests-clif.h index 2c2a3a3a967f5..55dc45ee794af 100644 --- a/tests/unittests/tests-link_format/tests-link_format.h +++ b/tests/unittests/tests-clif/tests-clif.h @@ -11,12 +11,12 @@ * @{ * * @file - * @brief Unittests for the ``link format`` module + * @brief Unittests for the ``clif`` module * * @author Leandro Lanzieri */ -#ifndef TESTS_LINK_FORMAT_H -#define TESTS_LINK_FORMAT_H +#ifndef TESTS_CLIF_H +#define TESTS_CLIF_H #include "embUnit/embUnit.h" #ifdef __cplusplus @@ -26,18 +26,18 @@ extern "C" { /** * @brief The entry point of this test suite. */ -void tests_link_format(void); +void tests_clif(void); /** * @brief Generates tests for link format * * @return embUnit tests if successful, NULL if not. */ -Test *tests_link_format_tests(void); +Test *tests_clif_tests(void); #ifdef __cplusplus } #endif -#endif /* TESTS_LINK_FORMAT_H */ +#endif /* TESTS_CLIF_H */ /** @} */ diff --git a/tests/unittests/tests-link_format/Makefile.include b/tests/unittests/tests-link_format/Makefile.include deleted file mode 100644 index 9fdc3bb588e55..0000000000000 --- a/tests/unittests/tests-link_format/Makefile.include +++ /dev/null @@ -1 +0,0 @@ -USEMODULE += link_format