From 4d705a206a4141c0ddfd035790c28f42c080544d Mon Sep 17 00:00:00 2001 From: Thecarisma Date: Fri, 23 Jul 2021 20:00:47 +0100 Subject: [PATCH 1/8] update the allocator pos in xtd params --- include/exotic/cline/cliarg.h | 124 +++++++++++++++++----------------- 1 file changed, 62 insertions(+), 62 deletions(-) diff --git a/include/exotic/cline/cliarg.h b/include/exotic/cline/cliarg.h index 9b9d1fc..aef5665 100644 --- a/include/exotic/cline/cliarg.h +++ b/include/exotic/cline/cliarg.h @@ -174,10 +174,10 @@ static void destroy_cline_arg(ClineArgs *cline_arg) { sub_iterator = XITERATOR_INIT2(xhashtable, cstr, ClineArgsOption, entry->value->cliopts); XFOREACH(const xhashtable_entry(cstr, ClineArgsOption) *sub_entry, sub_iterator, { if (sub_entry->value->splited_option_keys != XTD_NULL) { - xfreep2p(sub_entry->value->splited_option_keys, cline_arg->allocator); + xfreep2p(cline_arg->allocator, sub_entry->value->splited_option_keys); } if (sub_entry->value->choices != XTD_NULL) { - xfreep2p(sub_entry->value->choices, cline_arg->allocator); + xfreep2p(cline_arg->allocator, sub_entry->value->choices); } if (sub_entry->value->values != XTD_NULL) { cline_arg->allocator.memory_free(sub_entry->value->values); @@ -461,8 +461,8 @@ static enum x_stat cline_arg_add_cli_args_option(ClineArgs *cline_arg, if (!cline_arg_option) { return XTD_ALLOC_ERR; } - cline_arg_option->splited_option_keys = xstring_cstr_split(option_str, cline_arg->option_delimiter, cline_arg->allocator); - cline_arg_option->choices = xstring_cstr_split(choices_str, "|", cline_arg->allocator); + cline_arg_option->splited_option_keys = xstring_cstr_split(cline_arg->allocator, (char *) option_str, cline_arg->option_delimiter); + cline_arg_option->choices = xstring_cstr_split(cline_arg->allocator, (char *) choices_str, "|"); cline_arg_option->description = description; cline_arg_option->epilog = XTD_NULL; cline_arg_option->values = default_value; @@ -477,11 +477,11 @@ static enum x_stat cline_arg_add_cli_args_option(ClineArgs *cline_arg, cline_arg_option->found_value_count = 0; cline_arg_option->is_present = FALSE; cline_arg_option->ignored = ignored; - status = xhashtable_get(cstr, ClineArgsGroup)(cline_arg->cli_groups, (section == XTD_NULL || xstring_cstr_is_empty(section) ? "" : section), &cli_group); + status = xhashtable_get(cstr, ClineArgsGroup)(cline_arg->cli_groups, (section == XTD_NULL || xstring_cstr_is_empty((char *) section) ? "" : section), &cli_group); if (status != XTD_OK) { goto cline_arg_add_option_free_after_failure; } - status = xhashtable_put(cstr, ClineArgsOption)(cli_group->cliopts, option_str, cline_arg_option); + status = xhashtable_put(cstr, ClineArgsOption)(cli_group->cliopts, (char *) option_str, cline_arg_option); if (status != XTD_OK) { goto cline_arg_add_option_free_after_failure; } @@ -491,7 +491,7 @@ static enum x_stat cline_arg_add_cli_args_option(ClineArgs *cline_arg, return XTD_OK; cline_arg_add_option_free_after_failure: - xfreep2p(cline_arg_option->splited_option_keys, cline_arg->allocator); + xfreep2p(cline_arg->allocator, cline_arg_option->splited_option_keys); cline_arg->allocator.memory_free(cline_arg_option); return XTD_ERR; } @@ -686,7 +686,7 @@ static enum x_stat cline_arg_parse_in_range(ClineArgs *cline_arg, size_t from, s /*! */ -char *cline_arg_get_section_description(ClineArgs *cline_arg, const char *section) { +static char *cline_arg_get_section_description(ClineArgs *cline_arg, const char *section) { ClineArgsOption cli_opt; if (section == XTD_NULL) { return cline_arg->description; } if (!cline_arg_find_arg_option(cline_arg, section, EXOTIC_CLINE_SECTION_DESCRIPTION, &cli_opt, XTD_NULL, FALSE, FALSE)) { @@ -714,7 +714,7 @@ static enum x_stat cline_arg_set_section_description(ClineArgs *cline_arg, const /*! */ -char *cline_arg_get_section_epilog(ClineArgs *cline_arg, const char *section) { +static char *cline_arg_get_section_epilog(ClineArgs *cline_arg, const char *section) { ClineArgsOption cli_opt; if (section == XTD_NULL) { return cline_arg->epilog; } if (!cline_arg_find_arg_option(cline_arg, section, EXOTIC_CLINE_SECTION_DESCRIPTION, &cli_opt, XTD_NULL, FALSE, FALSE)) { @@ -776,93 +776,93 @@ static enum x_stat cline_arg_section_help(ClineArgs *cline_arg, const char *sect XIterator *iterator; XIterator *sub_iterator; - options_text = xstring_cstr_concat_cstr(options_text, "\n", cline_arg->allocator); + options_text = xstring_cstr_concat_cstr(cline_arg->allocator, options_text, "\n"); if (section == XTD_NULL) { if (cline_arg->usage != XTD_NULL) { - //xstring_cstr_replace(usage, "${name}", cline_arg->name, cline_arg->allocator) - usage_text = xstring_cstr_concat_cstr(usage_text, cline_arg_get_usage(cline_arg), cline_arg->allocator); + //xstring_cstr_replace(cline_arg->allocator, usage, "${name}", cline_arg->name) + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, cline_arg_get_usage(cline_arg)); } else { - usage_text = xstring_cstr_concat_cstr(usage_text, CLINE_ARG_TRANSLATE__INTERNAL__("usage"), cline_arg->allocator); - usage_text = xstring_cstr_concat_cstr(usage_text, ": ", cline_arg->allocator); - usage_text = xstring_cstr_concat_cstr(usage_text, cline_arg_get_name(cline_arg), cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, CLINE_ARG_TRANSLATE__INTERNAL__("usage")); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, ": "); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, cline_arg_get_name(cline_arg)); iterator = XITERATOR_INIT2(xhashtable, cstr, ClineArgsGroup, cline_arg->cli_groups); XFOREACH(const xhashtable_entry(cstr, ClineArgsGroup) *entry, iterator, { sub_iterator = XITERATOR_INIT2(xhashtable, cstr, ClineArgsOption, entry->value->cliopts); XFOREACH(const xhashtable_entry(cstr, ClineArgsOption) *sub_entry, sub_iterator, { if (sub_entry->value->help_var != XTD_NULL) { - if (!sub_entry->value->is_prefix && !sub_entry->value->is_suffix) { - help_var_text = xstring_cstr_concat_cstr(help_var_text, (sub_entry->value->prefix_delimeter != XTD_NULL ? sub_entry->value->prefix_delimeter : " "), cline_arg->allocator); + if (sub_entry->value->min_value_count > 0) { + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, (sub_entry->value->prefix_delimeter != XTD_NULL ? sub_entry->value->prefix_delimeter : " ")); } - help_var_text = xstring_cstr_concat_cstr(help_var_text, "<", cline_arg->allocator); - help_var_text = xstring_cstr_concat_cstr(help_var_text, sub_entry->value->help_var, cline_arg->allocator); - help_var_text = xstring_cstr_concat_cstr(help_var_text, ">", cline_arg->allocator); + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, "<"); + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, sub_entry->value->help_var); + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, ">"); } - usage_text = xstring_cstr_concat_cstr(usage_text, " ", cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, " "); if (!sub_entry->value->mandatory) { - usage_text = xstring_cstr_concat_cstr(usage_text, "[", cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, "["); } - option_text = xstring_cstr_concat_cstr(option_text, " ", cline_arg->allocator); - if (help_var_text != XTD_NULL && sub_entry->value->is_suffix) { - usage_text = xstring_cstr_concat_cstr(usage_text, help_var_text, cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, help_var_text, cline_arg->allocator); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, " "); + if (help_var_text != XTD_NULL && sub_entry->value->is_suffix && !xstring_cstr_equals(sub_entry->key, EXOTIC_CLINE_ORPHAN_PARAM_KEY)) { + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, help_var_text); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, help_var_text); cline_arg->allocator.memory_free(help_var_text); help_var_text = XTD_NULL; } - usage_text = xstring_cstr_concat_cstr(usage_text, CLINE_ARG_ORPHAN_OR_OPTION__INTERNAL__(sub_entry), cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, CLINE_ARG_ORPHAN_OR_OPTION__INTERNAL__(sub_entry), cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, CLINE_ARG_ORPHAN_OR_OPTION__INTERNAL__(sub_entry)); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, CLINE_ARG_ORPHAN_OR_OPTION__INTERNAL__(sub_entry)); if (xstring_cstr_equals(sub_entry->key, EXOTIC_CLINE_ORPHAN_PARAM_KEY)) { cached_text = sub_entry->value->description; sub_entry->value->description = XTD_NULL; sub_entry->value->help_var = XTD_NULL; } - if (help_var_text != XTD_NULL && !sub_entry->value->is_suffix) { - usage_text = xstring_cstr_concat_cstr(usage_text, help_var_text, cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, help_var_text, cline_arg->allocator); + if (help_var_text != XTD_NULL && !sub_entry->value->is_suffix && !xstring_cstr_equals(sub_entry->key, EXOTIC_CLINE_ORPHAN_PARAM_KEY)) { + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, help_var_text); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, help_var_text); cline_arg->allocator.memory_free(help_var_text); help_var_text = XTD_NULL; } for (index = 1; sub_entry->value->splited_option_keys[index] != XTD_NULL; index++) { if (sub_entry->value->help_var != XTD_NULL) { - if (!sub_entry->value->is_prefix && !sub_entry->value->is_suffix) { - help_var_text = xstring_cstr_concat_cstr(help_var_text, " ", cline_arg->allocator); + if (sub_entry->value->min_value_count > 0) { + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, (sub_entry->value->prefix_delimeter != XTD_NULL ? sub_entry->value->prefix_delimeter : " ")); } - help_var_text = xstring_cstr_concat_cstr(help_var_text, "<", cline_arg->allocator); - help_var_text = xstring_cstr_concat_cstr(help_var_text, sub_entry->value->help_var, cline_arg->allocator); - help_var_text = xstring_cstr_concat_cstr(help_var_text, ">", cline_arg->allocator); + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, "<"); + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, sub_entry->value->help_var); + help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, ">"); } - usage_text = xstring_cstr_concat_char(usage_text, '|', cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, ", ", cline_arg->allocator); + usage_text = xstring_cstr_concat_char(cline_arg->allocator, usage_text, '|'); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, ", "); if (help_var_text != XTD_NULL && sub_entry->value->is_suffix) { - usage_text = xstring_cstr_concat_cstr(usage_text, help_var_text, cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, help_var_text, cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, help_var_text); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, help_var_text); cline_arg->allocator.memory_free(help_var_text); help_var_text = XTD_NULL; } - usage_text = xstring_cstr_concat_cstr(usage_text, sub_entry->value->splited_option_keys[index], cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, sub_entry->value->splited_option_keys[index], cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, sub_entry->value->splited_option_keys[index]); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, sub_entry->value->splited_option_keys[index]); if (help_var_text != XTD_NULL && !sub_entry->value->is_suffix) { - usage_text = xstring_cstr_concat_cstr(usage_text, help_var_text, cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, help_var_text, cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, help_var_text); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, help_var_text); cline_arg->allocator.memory_free(help_var_text); help_var_text = XTD_NULL; } } if (sub_entry->value->is_prefix || sub_entry->value->is_suffix || sub_entry->value->max_value_count > 1) { - usage_text = xstring_cstr_concat_cstr(usage_text, " ...", cline_arg->allocator); - option_text = xstring_cstr_concat_cstr(option_text, " ...", cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, " ..."); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, " ..."); } option_text_length = xstring_cstr_length(option_text); do { - option_text = xstring_cstr_concat_char(option_text, ' ', cline_arg->allocator); + option_text = xstring_cstr_concat_char(cline_arg->allocator, option_text, ' '); } while (option_text_length++ < CLINE_ARG_HELP_OPTION_PRE_SPACE_SIZE-1); if (!sub_entry->value->mandatory) { - usage_text = xstring_cstr_concat_char(usage_text, ']', cline_arg->allocator); + usage_text = xstring_cstr_concat_char(cline_arg->allocator, usage_text, ']'); } if (sub_entry->value->description != XTD_NULL) { - option_text = xstring_cstr_concat_cstr(option_text, sub_entry->value->description, cline_arg->allocator); - option_text = xstring_cstr_concat_char(option_text, '\n', cline_arg->allocator); - options_text = xstring_cstr_concat_cstr(options_text, option_text, cline_arg->allocator); + option_text = xstring_cstr_concat_cstr(cline_arg->allocator, option_text, sub_entry->value->description); + option_text = xstring_cstr_concat_char(cline_arg->allocator, option_text, '\n'); + options_text = xstring_cstr_concat_cstr(cline_arg->allocator, options_text, option_text); } cline_arg->allocator.memory_free(option_text); option_text = XTD_NULL; @@ -875,24 +875,24 @@ static enum x_stat cline_arg_section_help(ClineArgs *cline_arg, const char *sect }) XITERATOR_DESTROY(iterator); } - usage_text = xstring_cstr_concat_cstr(usage_text, "\n\n", cline_arg->allocator); + usage_text = xstring_cstr_concat_cstr(cline_arg->allocator, usage_text, "\n\n"); } - help_text = xstring_cstr_concat_cstr(help_text, usage_text, cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, usage_text); cline_arg->allocator.memory_free(usage_text); text = CLINE_ARG_TRANSLATE__INTERNAL__(cline_arg_get_section_description(cline_arg, section)); if (text != XTD_NULL) { - help_text = xstring_cstr_concat_cstr(help_text, text, cline_arg->allocator); - help_text = xstring_cstr_concat_cstr(help_text, "\n", cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, text); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, "\n"); } if (option_text_length > 0) { - help_text = xstring_cstr_concat_cstr(help_text, options_text, cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, options_text); cline_arg->allocator.memory_free(options_text); } text = CLINE_ARG_TRANSLATE__INTERNAL__(cline_arg_get_section_epilog(cline_arg, section)); if (text != XTD_NULL) { - help_text = xstring_cstr_concat_cstr(help_text, "\n", cline_arg->allocator); - help_text = xstring_cstr_concat_cstr(help_text, text, cline_arg->allocator); - help_text = xstring_cstr_concat_cstr(help_text, "\n", cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, "\n"); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, text); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, "\n"); } *out = help_text; @@ -912,7 +912,7 @@ static enum x_stat cline_arg_help(ClineArgs *cline_arg, char **selected_sections if (status != XTD_OK) { return status; } - help_text = xstring_cstr_concat_cstr(help_text, section_help, cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, XTD_NULL, section_help); cline_arg->allocator.memory_free(section_help); if (selected_sections != XTD_NULL) { for (index = 0; selected_sections[index] != XTD_NULL; index++) { @@ -920,11 +920,11 @@ static enum x_stat cline_arg_help(ClineArgs *cline_arg, char **selected_sections if (status != XTD_OK) { return status; } - help_text = xstring_cstr_concat_cstr(help_text, section_help, cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, section_help); cline_arg->allocator.memory_free(section_help); } } - help_text = xstring_cstr_concat_cstr(help_text, "\n", cline_arg->allocator); + help_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_text, "\n"); *out = help_text; return XTD_OK; From be9034b742b838c87b803bc70a308ae1f0fe8a8b Mon Sep 17 00:00:00 2001 From: Thecarisma Date: Sat, 24 Jul 2021 21:39:11 +0100 Subject: [PATCH 2/8] make some functions static --- include/exotic/cline/cline_common.h | 4 ++-- include/exotic/cline/font_effect.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/exotic/cline/cline_common.h b/include/exotic/cline/cline_common.h index 493965a..9a50938 100644 --- a/include/exotic/cline/cline_common.h +++ b/include/exotic/cline/cline_common.h @@ -63,7 +63,7 @@ extern "C" { /*! */ -void cline_platform_printnl_if() +static void cline_platform_printnl_if() { #ifndef _WIN32 printf("\n"); @@ -104,7 +104,7 @@ static unsigned already_change_mode = 0; /*! */ -char *cline_ansi_encoder(const char *file_name, const int line_number, const char ansi_code_terminator, const int argscount, ...) +static char *cline_ansi_encoder(const char *file_name, const int line_number, const char ansi_code_terminator, const int argscount, ...) { va_list ap; const char *p; diff --git a/include/exotic/cline/font_effect.h b/include/exotic/cline/font_effect.h index 77e6950..4d40e96 100644 --- a/include/exotic/cline/font_effect.h +++ b/include/exotic/cline/font_effect.h @@ -146,7 +146,7 @@ extern "C" { this can be used to quick disable the effects without having to delete the other font effect options. */ -const char *cline_fe_str_with_end_fe(const char *file_name, const int line_number, const char *text, const char *fe, const char *end_fe) +static const char *cline_fe_str_with_end_fe(const char *file_name, const int line_number, const char *text, const char *fe, const char *end_fe) { int fe_length = strlen(fe); int concatenated_length = strlen(text) + fe_length + (fe_length > 0 ? strlen(end_fe) : 0); From ede66d205ba5b60a26d282dbaf87ef27e31d1003 Mon Sep 17 00:00:00 2001 From: Thecarisma Date: Fri, 8 Oct 2021 10:40:02 +0100 Subject: [PATCH 3/8] creates the xtd containers printer macros --- .../xtd_printer/test_xtd_printer_xdeque.c | 158 ++++++++++++++++ .../xtd_printer/test_xtd_printer_xlist.c | 158 ++++++++++++++++ .../test_xtd_printer_xpriority_queue.c | 170 +++++++++++++++++ .../xtd_printer/test_xtd_printer_xqueue.c | 158 ++++++++++++++++ .../cline/xtd_printer/test_xtd_printer_xset.c | 178 ++++++++++++++++++ .../xtd_printer/test_xtd_printer_xslist.c | 158 ++++++++++++++++ .../xtd_printer/test_xtd_printer_xstack.c | 158 ++++++++++++++++ .../xtd_printer/test_xtd_printer_xvector.c | 158 ++++++++++++++++ 8 files changed, 1296 insertions(+) create mode 100644 test/cline/xtd_printer/test_xtd_printer_xdeque.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xlist.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xpriority_queue.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xqueue.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xset.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xslist.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xstack.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xvector.c diff --git a/test/cline/xtd_printer/test_xtd_printer_xdeque.c b/test/cline/xtd_printer/test_xtd_printer_xdeque.c new file mode 100644 index 0000000..23d6457 --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xdeque.c @@ -0,0 +1,158 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XDEQUE_FOR(str) + SETUP_XDEQUE_FOR(int) + SETUP_XDEQUE_FOR(User_ptr) +) + +CESTER_TEST(print_str, _, { + xdeque(str) *fruits; + + cester_assert_uint_eq(xdeque_new(str)(&fruits), XTD_OK); + cester_assert_uint_eq(xdeque_add(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xdeque_add(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xdeque_add(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xdeque_add(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xdeque, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XDEQUE(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xdeque_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xdeque_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xdeque, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xdeque(int) *numbers; + + cester_assert_uint_eq(xdeque_new(int)(&numbers), XTD_OK); + cester_assert_uint_eq(xdeque_add(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xdeque_add(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xdeque_add(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xdeque_add(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xdeque, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(int)(numbers, 2, XTD_NULL), XTD_OK); + CLINE_XPRINT_XDEQUE(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xdeque_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xdeque_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xdeque, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xdeque(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xdeque_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xdeque_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xdeque_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xdeque_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xdeque, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XDEQUE_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xdeque_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xdeque, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xdeque(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xdeque_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xdeque_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xdeque_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xdeque_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xdeque, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XDEQUE(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xdeque_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xdeque_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xdeque, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xlist.c b/test/cline/xtd_printer/test_xtd_printer_xlist.c new file mode 100644 index 0000000..f9b117e --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xlist.c @@ -0,0 +1,158 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XLIST_FOR(str) + SETUP_XLIST_FOR(int) + SETUP_XLIST_FOR(User_ptr) +) + +CESTER_TEST(print_str, _, { + xlist(str) *fruits; + + cester_assert_uint_eq(xlist_new(str)(&fruits), XTD_OK); + cester_assert_uint_eq(xlist_add(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xlist_add(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xlist_add(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xlist_add(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xlist, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(str)(fruits, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XLIST(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xlist_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xlist_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xlist, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xlist(int) *numbers; + + cester_assert_uint_eq(xlist_new(int)(&numbers), XTD_OK); + cester_assert_uint_eq(xlist_add(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xlist_add(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xlist_add(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xlist_add(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xlist, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(int)(numbers, 2, XTD_NULL), XTD_OK); + CLINE_XPRINT_XLIST(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xlist_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xlist_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xlist, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xlist(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xlist_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xlist_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xlist_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xlist_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xlist, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XLIST_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xlist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xlist, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xlist(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xlist_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xlist_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xlist_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xlist_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xlist, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XLIST(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xlist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xlist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xlist, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xpriority_queue.c b/test/cline/xtd_printer/test_xtd_printer_xpriority_queue.c new file mode 100644 index 0000000..9cbe1c6 --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xpriority_queue.c @@ -0,0 +1,170 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XPRIORITY_QUEUE_FOR(str) + SETUP_XPRIORITY_QUEUE_FOR(int) + SETUP_XPRIORITY_QUEUE_FOR(User_ptr) + + bool cmp_str(char *const a, char *const b) { + return *a < *b; + } + + bool cmp_int(int const a, int const b) { + return a < b; + } + + bool cmp_user(User *const a, User *const b) { + return *(a->name) < *(b->name); + } +) + +CESTER_TEST(print_str, _, { + xpriority_queue(str) *fruits; + + cester_assert_uint_eq(xpriority_queue_new(str)(&fruits, cmp_str), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + CLINE_XPRINT_XPRIORITY_QUEUE(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Pineapple\", \"Banana\", \"Mango\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xpriority_queue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xpriority_queue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xpriority_queue(int) *numbers; + + cester_assert_uint_eq(xpriority_queue_new(int)(&numbers, cmp_int), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + CLINE_XPRINT_XPRIORITY_QUEUE(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[40, 20, 30]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xpriority_queue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xpriority_queue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xpriority_queue(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xpriority_queue_new(User_ptr)(&users, cmp_user), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xpriority_queue, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=eccntriity, Email=the_eccen@user.com}, {Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XPRIORITY_QUEUE_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=vazrak, Email=vazrak@user.com}, {Name=thecarisma, Email=test@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xpriority_queue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xpriority_queue, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xpriority_queue(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xpriority_queue_new(User_ptr)(&users, cmp_user), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xpriority_queue_enqueue(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XPRIORITY_QUEUE(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xpriority_queue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xpriority_queue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xqueue.c b/test/cline/xtd_printer/test_xtd_printer_xqueue.c new file mode 100644 index 0000000..ba0a88b --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xqueue.c @@ -0,0 +1,158 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XQUEUE_FOR(str) + SETUP_XQUEUE_FOR(int) + SETUP_XQUEUE_FOR(User_ptr) +) + +CESTER_TEST(print_str, _, { + xqueue(str) *fruits; + + cester_assert_uint_eq(xqueue_new(str)(&fruits), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xqueue, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + CLINE_XPRINT_XQUEUE(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xqueue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xqueue_dequeue(str)(fruits, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xqueue, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xqueue(int) *numbers; + + cester_assert_uint_eq(xqueue_new(int)(&numbers), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xqueue, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + CLINE_XPRINT_XQUEUE(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 30]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xqueue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xqueue_dequeue(int)(numbers, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xqueue, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xqueue(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xqueue_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xqueue, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XQUEUE_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xqueue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xqueue, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xqueue(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xqueue_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xqueue_enqueue(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xqueue, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XQUEUE(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xqueue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xqueue_dequeue(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xqueue, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xset.c b/test/cline/xtd_printer/test_xtd_printer_xset.c new file mode 100644 index 0000000..7e32a72 --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xset.c @@ -0,0 +1,178 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XSET_FOR(str) + SETUP_XSET_FOR(int) + SETUP_XSET_FOR(User_ptr) + + bool string_greater_than(char *first, char *second) { + return first[0] > second[0]; + } + + bool int_equals(int first, int second) { + return first == second; + } + + bool int_greater_than(int first, int second) { + return first > second; + } + + bool user_equals(User *first, User *second) { + return first->name[0] == second->name[0]; + } + + bool user_greater_than(User *first, User *second) { + return first->name[0] > second->name[0]; + } +) + +CESTER_TEST(print_str, _, { + xset(str) *fruits; + + cester_assert_uint_eq(xset_new(str)(&fruits, cester_string_equals, string_greater_than), XTD_OK); + cester_assert_uint_eq(xset_add(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xset_add(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xset_add(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xset_add(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xset, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(str)(fruits, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSET(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xset_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xset_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xset, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xset(int) *numbers; + + cester_assert_uint_eq(xset_new(int)(&numbers, int_equals, int_greater_than), XTD_OK); + cester_assert_uint_eq(xset_add(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xset_add(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xset_add(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xset_add(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xset, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(int)(numbers, 2, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSET(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xset_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xset_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xset, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xset(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xset_new(User_ptr)(&users, user_equals, user_greater_than), XTD_OK); + cester_assert_uint_eq(xset_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xset_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xset_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xset, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSET_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xset_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xset, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xset(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xset_new(User_ptr)(&users, user_equals, user_greater_than), XTD_OK); + cester_assert_uint_eq(xset_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xset_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xset_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xset, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSET(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xset_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xset_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xset, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xslist.c b/test/cline/xtd_printer/test_xtd_printer_xslist.c new file mode 100644 index 0000000..930419d --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xslist.c @@ -0,0 +1,158 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XSLIST_FOR(str) + SETUP_XSLIST_FOR(int) + SETUP_XSLIST_FOR(User_ptr) +) + +CESTER_TEST(print_str, _, { + xslist(str) *fruits; + + cester_assert_uint_eq(xslist_new(str)(&fruits), XTD_OK); + cester_assert_uint_eq(xslist_add(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xslist_add(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xslist_add(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xslist_add(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xslist, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(str)(fruits, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSLIST(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xslist_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xslist_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xslist, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xslist(int) *numbers; + + cester_assert_uint_eq(xslist_new(int)(&numbers), XTD_OK); + cester_assert_uint_eq(xslist_add(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xslist_add(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xslist_add(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xslist_add(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xslist, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(int)(numbers, 2, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSLIST(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xslist_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xslist_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xslist, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xslist(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xslist_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xslist_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xslist_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xslist_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xslist, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSLIST_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xslist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xslist, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xslist(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xslist_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xslist_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xslist_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xslist_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xslist, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSLIST(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xslist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xslist_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xslist, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xstack.c b/test/cline/xtd_printer/test_xtd_printer_xstack.c new file mode 100644 index 0000000..e097447 --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xstack.c @@ -0,0 +1,158 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XSTACK_FOR(str) + SETUP_XSTACK_FOR(int) + SETUP_XSTACK_FOR(User_ptr) +) + +CESTER_TEST(print_str, _, { + xstack(str) *fruits; + + cester_assert_uint_eq(xstack_new(str)(&fruits), XTD_OK); + cester_assert_uint_eq(xstack_push(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xstack_push(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xstack_push(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xstack_push(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xstack, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(str)(fruits, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSTACK(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(str)(fruits, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xstack_pop(str)(fruits, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xstack_pop(str)(fruits, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xstack, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xstack(int) *numbers; + + cester_assert_uint_eq(xstack_new(int)(&numbers), XTD_OK); + cester_assert_uint_eq(xstack_push(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xstack_push(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xstack_push(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xstack_push(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xstack, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(int)(numbers, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSTACK(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 30]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(int)(numbers, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xstack_pop(int)(numbers, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xstack_pop(int)(numbers, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xstack, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xstack(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xstack_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xstack_push(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xstack_push(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xstack_push(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xstack, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSTACK_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(User_ptr)(users, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xstack_pop(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xstack, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xstack(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xstack_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xstack_push(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xstack_push(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xstack_push(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xstack, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XSTACK(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xstack_pop(User_ptr)(users, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xstack_pop(User_ptr)(users, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xstack, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xvector.c b/test/cline/xtd_printer/test_xtd_printer_xvector.c new file mode 100644 index 0000000..f57e6ee --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xvector.c @@ -0,0 +1,158 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XVECTOR_FOR(str) + SETUP_XVECTOR_FOR(int) + SETUP_XVECTOR_FOR(User_ptr) +) + +CESTER_TEST(print_str, _, { + xvector(str) *fruits; + + cester_assert_uint_eq(xvector_new(str)(&fruits), XTD_OK); + cester_assert_uint_eq(xvector_add(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xvector_add(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xvector_add(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xvector_add(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xvector, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(str)(fruits, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XVECTOR(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xvector_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xvector_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xvector, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xvector(int) *numbers; + + cester_assert_uint_eq(xvector_new(int)(&numbers), XTD_OK); + cester_assert_uint_eq(xvector_add(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xvector_add(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xvector_add(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xvector_add(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xvector, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(int)(numbers, 2, XTD_NULL), XTD_OK); + CLINE_XPRINT_XVECTOR(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xvector_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xvector_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xvector, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xvector(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xvector_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xvector_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xvector_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xvector_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xvector, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XVECTOR_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xvector_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xvector, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xvector(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xvector_new(User_ptr)(&users), XTD_OK); + cester_assert_uint_eq(xvector_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xvector_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xvector_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xvector, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XVECTOR(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xvector_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xvector_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xvector, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + From 91ae01b9725bfa361b3ecda9894ee06374f11856 Mon Sep 17 00:00:00 2001 From: Thecarisma Date: Fri, 8 Oct 2021 10:42:07 +0100 Subject: [PATCH 4/8] creates the xtd containers printer macros --- include/exotic/cline/xtd_printers.h | 150 ++++++++++++++++++ test/cline/{ => cliarg}/test_clinearg_basic.c | 0 test/cline/{ => cliarg}/test_clinearg_help.c | 0 test/cline/{ => cliarg}/test_clinearg_parse.c | 0 .../{ => term_effect_and_nav}/test_cline_fe.c | 0 .../test_cline_fe_print.c | 0 .../test_colorfulterm.c | 0 .../test_colorfulterm_fe_values.c | 0 .../test_cursor_nav.c | 0 test/crash_test.c | 34 +++- test/examples/{cline => }/256colormodechart.c | 0 test/examples/{cline => }/clicalc.c | 0 test/examples/{cline => }/cursormagics.c | 0 13 files changed, 181 insertions(+), 3 deletions(-) create mode 100644 include/exotic/cline/xtd_printers.h rename test/cline/{ => cliarg}/test_clinearg_basic.c (100%) rename test/cline/{ => cliarg}/test_clinearg_help.c (100%) rename test/cline/{ => cliarg}/test_clinearg_parse.c (100%) rename test/cline/{ => term_effect_and_nav}/test_cline_fe.c (100%) rename test/cline/{ => term_effect_and_nav}/test_cline_fe_print.c (100%) rename test/cline/{ => term_effect_and_nav}/test_colorfulterm.c (100%) rename test/cline/{ => term_effect_and_nav}/test_colorfulterm_fe_values.c (100%) rename test/cline/{ => term_effect_and_nav}/test_cursor_nav.c (100%) rename test/examples/{cline => }/256colormodechart.c (100%) rename test/examples/{cline => }/clicalc.c (100%) rename test/examples/{cline => }/cursormagics.c (100%) diff --git a/include/exotic/cline/xtd_printers.h b/include/exotic/cline/xtd_printers.h new file mode 100644 index 0000000..03fafd0 --- /dev/null +++ b/include/exotic/cline/xtd_printers.h @@ -0,0 +1,150 @@ + +/*! + \copyright MIT License Copyright (c) 2021, Adewale Azeez + \author Adewale Azeez + \date 07 October 2021 + \file xtd_printers.h + + xtd_printers.h is ... +*/ + +#ifndef EXOTIC_CLINE_FONT_EFFECT_H +#define EXOTIC_CLINE_FONT_EFFECT_H + +#ifdef __cplusplus +extern "C" { +#endif + +/*! + +*/ +#include "cline_common.h" +#include + +/*! + +*/ +#define CLINE_XTD_PRINTER_SELECT_QUOTE(value) _Generic(value,\ + char *: "\"",\ + default: ""\ + ) + + +/*! + +*/ +#define CLINE_XPRINT_XTD_CONTAINER(container_type, stream, type, container, var_suffix) XIterator *iterator##var_suffix = XITERATOR_INIT(container_type, type, container);\ + fprintf(stream, "["); size_t size##var_suffix = container_type##_size(container);\ + XFOREACH_INDEX(size_t index##var_suffix, type value##var_suffix, iterator##var_suffix, {\ + fprintf(stream, CLINE_XTD_PRINTER_SELECT_QUOTE(value##var_suffix));\ + fprintf(stream, METAREF_GENERIC_FORMAT_SPECIFIER(value##var_suffix), value##var_suffix);\ + fprintf(stream, CLINE_XTD_PRINTER_SELECT_QUOTE(value##var_suffix)); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ + }); fprintf(stream, "]"); XITERATOR_DESTROY(iterator##var_suffix); + +/*! + +*/ +#define CLINE_XPRINT_XDEQUE(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xdeque, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XLIST(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xlist, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XSLIST(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xslist, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XQUEUE(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xqueue, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XSTACK(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xstack, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XPRIORITY_QUEUE(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xpriority_queue, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XVECTOR(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xvector, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XSET(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xset, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XUNORDERED_SET(stream, type, container) CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stream, type, container, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XTD_CONTAINER_CUSTOM(container_type, stream, type, container, value_formatter, var_suffix) XIterator *iterator##var_suffix = XITERATOR_INIT(container_type, type, container);\ + fprintf(stream, "["); size_t size##var_suffix = container_type##_size(container);\ + XFOREACH_INDEX(size_t index##var_suffix, type value##var_suffix, iterator##var_suffix, {\ + fprintf(stream, value_formatter(value##var_suffix));\ + if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ + }); fprintf(stream, "]"); XITERATOR_DESTROY(iterator##var_suffix); + + +/*! + +*/ +#define CLINE_XPRINT_XDEQUE_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xdeque, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XLIST_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xlist, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XSLIST_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xslist, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XQUEUE_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xqueue, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XSTACK_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xstack, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XPRIORITY_QUEUE_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xpriority_queue, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XVECTOR_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xvector, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XSET_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xset, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XUNORDERED_SET_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunorderes_set, stream, type, container, value_formatter, __LINE__) + + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/test/cline/test_clinearg_basic.c b/test/cline/cliarg/test_clinearg_basic.c similarity index 100% rename from test/cline/test_clinearg_basic.c rename to test/cline/cliarg/test_clinearg_basic.c diff --git a/test/cline/test_clinearg_help.c b/test/cline/cliarg/test_clinearg_help.c similarity index 100% rename from test/cline/test_clinearg_help.c rename to test/cline/cliarg/test_clinearg_help.c diff --git a/test/cline/test_clinearg_parse.c b/test/cline/cliarg/test_clinearg_parse.c similarity index 100% rename from test/cline/test_clinearg_parse.c rename to test/cline/cliarg/test_clinearg_parse.c diff --git a/test/cline/test_cline_fe.c b/test/cline/term_effect_and_nav/test_cline_fe.c similarity index 100% rename from test/cline/test_cline_fe.c rename to test/cline/term_effect_and_nav/test_cline_fe.c diff --git a/test/cline/test_cline_fe_print.c b/test/cline/term_effect_and_nav/test_cline_fe_print.c similarity index 100% rename from test/cline/test_cline_fe_print.c rename to test/cline/term_effect_and_nav/test_cline_fe_print.c diff --git a/test/cline/test_colorfulterm.c b/test/cline/term_effect_and_nav/test_colorfulterm.c similarity index 100% rename from test/cline/test_colorfulterm.c rename to test/cline/term_effect_and_nav/test_colorfulterm.c diff --git a/test/cline/test_colorfulterm_fe_values.c b/test/cline/term_effect_and_nav/test_colorfulterm_fe_values.c similarity index 100% rename from test/cline/test_colorfulterm_fe_values.c rename to test/cline/term_effect_and_nav/test_colorfulterm_fe_values.c diff --git a/test/cline/test_cursor_nav.c b/test/cline/term_effect_and_nav/test_cursor_nav.c similarity index 100% rename from test/cline/test_cursor_nav.c rename to test/cline/term_effect_and_nav/test_cursor_nav.c diff --git a/test/crash_test.c b/test/crash_test.c index c127725..9a7ee65 100644 --- a/test/crash_test.c +++ b/test/crash_test.c @@ -1,6 +1,34 @@ -/*!gcc {0} -I. -I../include/ -o out; ./out --cester-verbose */ +/*!gcc {0} -I. -I../include/ -o out -Wno-int-conversion; ./out --cester-verbose */ #include +#include +#include +#include + +#define EXECUTE_OR_FAIL(func) if (func != XTD_OK) goto fails; +typedef char* str; +SETUP_XVECTOR_FOR(str) + +void to_string(int number) { + +} + +int main() { + xvector(str) *numbers; + + EXECUTE_OR_FAIL(xvector_new(str)(&numbers)) + EXECUTE_OR_FAIL(xvector_add(str)(numbers, "1")) + EXECUTE_OR_FAIL(xvector_add(str)(numbers, "2")) + EXECUTE_OR_FAIL(xvector_add(str)(numbers, "3")) + EXECUTE_OR_FAIL(xvector_add(str)(numbers, "4")) + CLINE_PRINT_XVECTOR(stdout, str, numbers); + + xvector_destroy(numbers); + return 0; + fails: + printf("Error"); + return 1; +} void spaces(int count) { @@ -10,7 +38,7 @@ void spaces(int count) putchar(' '); } -int main() +int main1() { int x; @@ -33,4 +61,4 @@ int main() puts("/"); return(0); -} \ No newline at end of file +} diff --git a/test/examples/cline/256colormodechart.c b/test/examples/256colormodechart.c similarity index 100% rename from test/examples/cline/256colormodechart.c rename to test/examples/256colormodechart.c diff --git a/test/examples/cline/clicalc.c b/test/examples/clicalc.c similarity index 100% rename from test/examples/cline/clicalc.c rename to test/examples/clicalc.c diff --git a/test/examples/cline/cursormagics.c b/test/examples/cursormagics.c similarity index 100% rename from test/examples/cline/cursormagics.c rename to test/examples/cursormagics.c From 3855a0993d0840e28e76361f0545a3b59215c115 Mon Sep 17 00:00:00 2001 From: Thecarisma Date: Sun, 10 Oct 2021 11:26:08 +0100 Subject: [PATCH 5/8] add the printer for xhashtable --- include/exotic/cline/xtd_printers.h | 51 ++++- .../xtd_printer/test_xtd_printer_xhashtable.c | 171 +++++++++++++++++ .../test_xtd_printer_xunordered_set.c | 178 ++++++++++++++++++ 3 files changed, 396 insertions(+), 4 deletions(-) create mode 100644 test/cline/xtd_printer/test_xtd_printer_xhashtable.c create mode 100644 test/cline/xtd_printer/test_xtd_printer_xunordered_set.c diff --git a/include/exotic/cline/xtd_printers.h b/include/exotic/cline/xtd_printers.h index 03fafd0..49a6255 100644 --- a/include/exotic/cline/xtd_printers.h +++ b/include/exotic/cline/xtd_printers.h @@ -21,14 +21,26 @@ extern "C" { #include "cline_common.h" #include +/* LIBXTD FILLER */ +#ifndef xpair +#define xpair xhashtable_entry +#endif + /*! */ #define CLINE_XTD_PRINTER_SELECT_QUOTE(value) _Generic(value,\ + char: "'",\ char *: "\"",\ default: ""\ ) +/*! + +*/ +#define CLINE_XTD_PRINTER_FPRINT_VALUE(stream, value) fprintf(stream, CLINE_XTD_PRINTER_SELECT_QUOTE(value));\ + fprintf(stream, METAREF_GENERIC_FORMAT_SPECIFIER(value), value);\ + fprintf(stream, CLINE_XTD_PRINTER_SELECT_QUOTE(value));\ /*! @@ -36,11 +48,21 @@ extern "C" { #define CLINE_XPRINT_XTD_CONTAINER(container_type, stream, type, container, var_suffix) XIterator *iterator##var_suffix = XITERATOR_INIT(container_type, type, container);\ fprintf(stream, "["); size_t size##var_suffix = container_type##_size(container);\ XFOREACH_INDEX(size_t index##var_suffix, type value##var_suffix, iterator##var_suffix, {\ - fprintf(stream, CLINE_XTD_PRINTER_SELECT_QUOTE(value##var_suffix));\ - fprintf(stream, METAREF_GENERIC_FORMAT_SPECIFIER(value##var_suffix), value##var_suffix);\ - fprintf(stream, CLINE_XTD_PRINTER_SELECT_QUOTE(value##var_suffix)); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ + CLINE_XTD_PRINTER_FPRINT_VALUE(stream, value##var_suffix); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ }); fprintf(stream, "]"); XITERATOR_DESTROY(iterator##var_suffix); + +/*! + +*/ +#define CLINE_XPRINT_XTD_CONTAINER_PAIR(container_type, stream, type1, type2, container, var_suffix) \ + XIterator *iterator##var_suffix = XITERATOR_INIT2(container_type, type1, type2, container);\ + fprintf(stream, "{"); size_t size##var_suffix = container_type##_size(container);\ + XFOREACH_INDEX(size_t index##var_suffix, const xpair(type1, type2) *value##var_suffix, iterator##var_suffix, {\ + CLINE_XTD_PRINTER_FPRINT_VALUE(stream, value##var_suffix->key); fprintf(stream, ": ");\ + CLINE_XTD_PRINTER_FPRINT_VALUE(stream, value##var_suffix->value); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ + }); fprintf(stream, "}"); XITERATOR_DESTROY(iterator##var_suffix); + /*! */ @@ -88,6 +110,11 @@ extern "C" { /*! +*/ +#define CLINE_XPRINT_XHASHTABLE(stream, type1, type2, container) CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stream, type1, type2, container, __LINE__) + +/*! + */ #define CLINE_XPRINT_XTD_CONTAINER_CUSTOM(container_type, stream, type, container, value_formatter, var_suffix) XIterator *iterator##var_suffix = XITERATOR_INIT(container_type, type, container);\ fprintf(stream, "["); size_t size##var_suffix = container_type##_size(container);\ @@ -96,6 +123,17 @@ extern "C" { if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ }); fprintf(stream, "]"); XITERATOR_DESTROY(iterator##var_suffix); +/*! + +*/ +#define CLINE_XPRINT_XTD_CONTAINER_CUSTOM_PAIR(container_type, stream, type1, type2, container, key_formatter, value_formatter, var_suffix)\ + XIterator *iterator##var_suffix = XITERATOR_INIT2(container_type, type1, type2, container);\ + fprintf(stream, "{"); size_t size##var_suffix = container_type##_size(container);\ + XFOREACH_INDEX(size_t index##var_suffix, const xpair(type1, type2) *value##var_suffix, iterator##var_suffix, {\ + fprintf(stream, key_formatter(value##var_suffix->key)); fprintf(stream, ": ");\ + fprintf(stream, value_formatter(value##var_suffix->value)); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ + }); fprintf(stream, "}"); XITERATOR_DESTROY(iterator##var_suffix); + /*! @@ -140,7 +178,12 @@ extern "C" { /*! */ -#define CLINE_XPRINT_XUNORDERED_SET_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunorderes_set, stream, type, container, value_formatter, __LINE__) +#define CLINE_XPRINT_XUNORDERED_SET_CUSTOM_PAIR(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunordered_set, stream, type, container, value_formatter, __LINE__) + +/*! + +*/ +#define CLINE_XPRINT_XHASHTABLE_CUSTOM(stream, type1, type2, container, key_formatter, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM_PAIR(xhashtable, stream, type1, type2, container, key_formatter, value_formatter, __LINE__) #ifdef __cplusplus diff --git a/test/cline/xtd_printer/test_xtd_printer_xhashtable.c b/test/cline/xtd_printer/test_xtd_printer_xhashtable.c new file mode 100644 index 0000000..cf684f2 --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xhashtable.c @@ -0,0 +1,171 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XHASHTABLE_FOR(str, int) + SETUP_XHASHTABLE_FOR(char, str) + SETUP_XHASHTABLE_FOR(str, User_ptr) + + bool compare_char(const char key1, const char key2) { + return key1 == key2; + } + + size_t hash_char(const char key, int length, uint32_t seed) { + return (size_t)key; + } +) + +CESTER_TEST(print_str, _, { + xhashtable(str, int) *fruits; + + cester_assert_uint_eq(xhashtable_new(str, int)(&fruits, cester_string_equals, xcrypto_hash_string), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, int)(fruits, "Apple", 10), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, int)(fruits, "Banana", 20), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, int)(fruits, "Mango", 30), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, int)(fruits, "Pineapple", 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stdout, str, int, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("{\"Apple\": 10, \"Banana\": 20, \"Pineapple\": 40, \"Mango\": 30}"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(str, int)(fruits, "Banana", XTD_NULL), XTD_OK); + CLINE_XPRINT_XHASHTABLE(stdout, str, int, fruits); + cester_assert_stdout_stream_content_equal("{\"Apple\": 10, \"Pineapple\": 40, \"Mango\": 30}"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(str, int)(fruits, "Apple", XTD_NULL), XTD_OK); + cester_assert_uint_eq(xhashtable_remove(str, int)(fruits, "Mango", XTD_NULL), XTD_OK); + cester_assert_uint_eq(xhashtable_remove(str, int)(fruits, "Pineapple", XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stdout, str, int, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("{}"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xhashtable(char, str) *numbers; + + cester_assert_uint_eq(xhashtable_new(char, str)(&numbers, compare_char, hash_char), XTD_OK); + cester_assert_uint_eq(xhashtable_put(char, str)(numbers, 'a', "Hay"), XTD_OK); + cester_assert_uint_eq(xhashtable_put(char, str)(numbers, 'b', "Bee"), XTD_OK); + cester_assert_uint_eq(xhashtable_put(char, str)(numbers, 'c', "Cee"), XTD_OK); + cester_assert_uint_eq(xhashtable_put(char, str)(numbers, 'd', "Dee"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stdout, char, str, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("{'a': \"Hay\", 'b': \"Bee\", 'c': \"Cee\", 'd': \"Dee\"}"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(char, str)(numbers, 'c', XTD_NULL), XTD_OK); + CLINE_XPRINT_XHASHTABLE(stdout, char, str, numbers); + cester_assert_stdout_stream_content_equal("{'a': \"Hay\", 'b': \"Bee\", 'd': \"Dee\"}"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(char, str)(numbers, 'a', XTD_NULL), XTD_OK); + cester_assert_uint_eq(xhashtable_remove(char, str)(numbers, 'b', XTD_NULL), XTD_OK); + cester_assert_uint_eq(xhashtable_remove(char, str)(numbers, 'd', XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stdout, char, str, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("{}"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *str_to_string(char *str) { + return str; +} + +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xhashtable(str, User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xhashtable_new(str, User_ptr)(&users, cester_string_equals, xcrypto_hash_string), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, User_ptr)(users, "THEC", &user1), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, User_ptr)(users, "ECCE", &user2), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, User_ptr)(users, "VAZR", &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM_PAIR(xhashtable, stdout, str, User_ptr, users, str_to_string, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("{ECCE: {Name=eccntriity, Email=the_eccen@user.com}, VAZR: {Name=vazrak, Email=vazrak@user.com}, THEC: {Name=thecarisma, Email=test@user.com}}"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(str, User_ptr)(users, "ECCE", XTD_NULL), XTD_OK); + CLINE_XPRINT_XHASHTABLE_CUSTOM(stdout, str, User_ptr, users, str_to_string, user_to_string); + cester_assert_stdout_stream_content_equal("{VAZR: {Name=vazrak, Email=vazrak@user.com}, THEC: {Name=thecarisma, Email=test@user.com}}"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(str, User_ptr)(users, "THEC", XTD_NULL), XTD_OK); + cester_assert_uint_eq(xhashtable_remove(str, User_ptr)(users, "VAZR", XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM_PAIR(xhashtable, stdout, str, User_ptr, users, str_to_string, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("{}"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xhashtable(str, User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xhashtable_new(str, User_ptr)(&users, cester_string_equals, xcrypto_hash_string), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, User_ptr)(users, "THEC", &user1), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, User_ptr)(users, "ECCE", &user2), XTD_OK); + cester_assert_uint_eq(xhashtable_put(str, User_ptr)(users, "VAZR", &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stdout, str, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(str, User_ptr)(users, "ECCE", XTD_NULL), XTD_OK); + CLINE_XPRINT_XHASHTABLE(stdout, str, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xhashtable_remove(str, User_ptr)(users, "THEC", XTD_NULL), XTD_OK); + cester_assert_uint_eq(xhashtable_remove(str, User_ptr)(users, "VAZR", XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_PAIR(xhashtable, stdout, str, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("{}"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + diff --git a/test/cline/xtd_printer/test_xtd_printer_xunordered_set.c b/test/cline/xtd_printer/test_xtd_printer_xunordered_set.c new file mode 100644 index 0000000..307e94b --- /dev/null +++ b/test/cline/xtd_printer/test_xtd_printer_xunordered_set.c @@ -0,0 +1,178 @@ +/*!gcc {0} -I. -I../../../include/ -o out -Wno-int-conversion; ./out */ + +#include +#include +#include +#include + +CESTER_BODY( + typedef struct user_s { + char *name; + char *email; + } User; + + typedef char* str; + typedef User* User_ptr; + SETUP_XUNORDERED_SET_FOR(str) + SETUP_XUNORDERED_SET_FOR(int) + SETUP_XUNORDERED_SET_FOR(User_ptr) + + bool string_greater_than(char *first, char *second) { + return first[0] > second[0]; + } + + bool int_equals(int first, int second) { + return first == second; + } + + bool int_greater_than(int first, int second) { + return first > second; + } + + bool user_equals(User *first, User *second) { + return first->name[0] == second->name[0]; + } + + bool user_greater_than(User *first, User *second) { + return first->name[0] > second->name[0]; + } +) + +CESTER_TEST(print_str, _, { + xunordered_set(str) *fruits; + + cester_assert_uint_eq(xunordered_set_new(str)(&fruits, cester_string_equals), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(str)(fruits, "Apple"), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(str)(fruits, "Banana"), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(str)(fruits, "Mango"), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(str)(fruits, "Pineapple"), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stdout, str, fruits, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Banana\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(str)(fruits, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XUNORDERED_SET(stdout, str, fruits); + cester_assert_stdout_stream_content_equal("[\"Apple\", \"Mango\", \"Pineapple\"]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xunordered_set_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xunordered_set_remove_at(str)(fruits, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stdout, str, fruits, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_int, _, { + xunordered_set(int) *numbers; + + cester_assert_uint_eq(xunordered_set_new(int)(&numbers, int_equals), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(int)(numbers, 10), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(int)(numbers, 20), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(int)(numbers, 30), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(int)(numbers, 40), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stdout, int, numbers, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[10, 20, 30, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(int)(numbers, 2, XTD_NULL), XTD_OK); + CLINE_XPRINT_XUNORDERED_SET(stdout, int, numbers); + cester_assert_stdout_stream_content_equal("[10, 20, 40]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xunordered_set_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xunordered_set_remove_at(int)(numbers, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stdout, int, numbers, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_BODY( +char *user_to_string(User *user) { + XAllocator xallocator; + + init_xallocator(&xallocator); + char *string_value = xstring_cstr_concat_cstr(xallocator, XTD_NULL, "{Name="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->name); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, ", Email="); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, user->email); + string_value = xstring_cstr_concat_cstr_free_old(xallocator, string_value, "}"); + return string_value; +} +) + +CESTER_TEST(print_struct, _, { + xunordered_set(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xunordered_set_new(User_ptr)(&users, user_equals), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunordered_set, stdout, User_ptr, users, user_to_string, SUFFIX_6251425454); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XUNORDERED_SET_CUSTOM(stdout, User_ptr, users, user_to_string); + cester_assert_stdout_stream_content_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xunordered_set_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunordered_set, stdout, User_ptr, users, user_to_string, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_TEST(print_pointer, _, { + xunordered_set(User_ptr) *users; + + User user1 = { .name = "thecarisma", .email = "test@user.com" }; + User user2 = { .name = "eccntriity", .email = "the_eccen@user.com" }; + User user3 = { .name = "vazrak", .email = "vazrak@user.com" }; + + cester_assert_uint_eq(xunordered_set_new(User_ptr)(&users, user_equals), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(User_ptr)(users, &user1), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(User_ptr)(users, &user2), XTD_OK); + cester_assert_uint_eq(xunordered_set_add(User_ptr)(users, &user3), XTD_OK); + + CESTER_CAPTURE_STDOUT(); + CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stdout, User_ptr, users, SUFFIX_6251425454); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=eccntriity, Email=the_eccen@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(User_ptr)(users, 1, XTD_NULL), XTD_OK); + CLINE_XPRINT_XUNORDERED_SET(stdout, User_ptr, users); + cester_assert_stdout_stream_content_not_equal("[{Name=thecarisma, Email=test@user.com}, {Name=vazrak, Email=vazrak@user.com}]"); + + CESTER_RESET_STDOUT(); + cester_assert_uint_eq(xunordered_set_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + cester_assert_uint_eq(xunordered_set_remove_at(User_ptr)(users, 0, XTD_NULL), XTD_OK); + CLINE_XPRINT_XTD_CONTAINER(xunordered_set, stdout, User_ptr, users, SUFFIX_656890909); + cester_assert_stdout_stream_content_equal("[]"); + + CESTER_RELEASE_STDOUT(); + +}) + +CESTER_OPTIONS( + CESTER_VERBOSE_LEVEL(2); +) + From 7a234935ee9d24a055a125973597bb84f8e1f1a4 Mon Sep 17 00:00:00 2001 From: Thecarisma Date: Sat, 4 Dec 2021 00:15:39 +0100 Subject: [PATCH 6/8] update cliarg with xtx xstring breaking api change --- .github/workflows/main.yml | 4 +-- include/exotic/cline/cliarg.h | 26 +++++++++-------- include/exotic/cline/cline_common.h | 2 +- include/exotic/cline/cursor_nav.h | 2 +- include/exotic/cline/font_effect.h | 2 +- include/exotic/cline/term_input.h | 2 +- include/exotic/cline/xtd_printers.h | 8 +++--- test/cline/cliarg/test_clinearg_basic.c | 2 +- test/cline/cliarg/test_clinearg_help.c | 28 +++++++++---------- test/cline/cliarg/test_clinearg_parse.c | 2 +- .../xtd_printer/test_xtd_printer_xhashtable.c | 2 +- .../cline/xtd_printer/test_xtd_printer_xset.c | 13 +++++++-- test/crash_test.c | 3 +- 13 files changed, 54 insertions(+), 42 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 3ef6aef..bd00939 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -21,7 +21,7 @@ jobs: uses: actions/checkout@v2 - name: Run Regression - uses: exoticlibraries/exotic-action@v1.3 + uses: exoticlibraries/exotic-action@v1.4 with: download-exotic-libraries: true run-regression: true @@ -51,7 +51,7 @@ jobs: uses: actions/checkout@v2 - name: Setup Exotic Libraries - uses: exoticlibraries/exotic-action@v1.3 + uses: exoticlibraries/exotic-action@v1.4 with: download-exotic-libraries: true run-regression: false diff --git a/include/exotic/cline/cliarg.h b/include/exotic/cline/cliarg.h index aef5665..8d544cb 100644 --- a/include/exotic/cline/cliarg.h +++ b/include/exotic/cline/cliarg.h @@ -1,7 +1,7 @@ /*! \copyright MIT License Copyright (c) 2021, Adewale Azeez - \author Adewale Azeez + \author Adewale Azeez \date 11 February 2021 \file cliarg.h @@ -46,9 +46,11 @@ struct cline_arg_option_s { bool case_sensitive; bool is_present; bool ignored; + size_t choices_size; size_t min_value_count; size_t max_value_count; size_t found_value_count; /*!< The number of the value gotten from the augument, also equivalent to the size of cline_arg_option_s::values */ + size_t splited_option_keys_size; char **splited_option_keys; char **choices; char *description; @@ -174,10 +176,10 @@ static void destroy_cline_arg(ClineArgs *cline_arg) { sub_iterator = XITERATOR_INIT2(xhashtable, cstr, ClineArgsOption, entry->value->cliopts); XFOREACH(const xhashtable_entry(cstr, ClineArgsOption) *sub_entry, sub_iterator, { if (sub_entry->value->splited_option_keys != XTD_NULL) { - xfreep2p(cline_arg->allocator, sub_entry->value->splited_option_keys); + xfreep2p_wl(cline_arg->allocator, sub_entry->value->splited_option_keys, sub_entry->value->splited_option_keys_size); } if (sub_entry->value->choices != XTD_NULL) { - xfreep2p(cline_arg->allocator, sub_entry->value->choices); + xfreep2p_wl(cline_arg->allocator, sub_entry->value->choices, sub_entry->value->choices_size); } if (sub_entry->value->values != XTD_NULL) { cline_arg->allocator.memory_free(sub_entry->value->values); @@ -314,7 +316,8 @@ static bool cline_arg_find_arg_option(ClineArgs *cline_arg, const char *section, } goto cline_arg_find_arg_option_return; } - for (index = 0; entry->value->splited_option_keys[index] != XTD_NULL; index++) { + for (index = 0; index < entry->value->splited_option_keys_size; index++) { + /*printf("Value::%s::%s::\n", entry->key, entry->value->splited_option_keys[index]);*/ if (xstring_cstr_equals(entry->value->splited_option_keys[index], flag) || ((entry->value->is_prefix || check_starts_with) && xstring_cstr_starts_with(flag, entry->value->splited_option_keys[index])) || ((entry->value->is_suffix || check_ends_with) && xstring_cstr_ends_with(flag, entry->value->splited_option_keys[index]))) { @@ -461,8 +464,8 @@ static enum x_stat cline_arg_add_cli_args_option(ClineArgs *cline_arg, if (!cline_arg_option) { return XTD_ALLOC_ERR; } - cline_arg_option->splited_option_keys = xstring_cstr_split(cline_arg->allocator, (char *) option_str, cline_arg->option_delimiter); - cline_arg_option->choices = xstring_cstr_split(cline_arg->allocator, (char *) choices_str, "|"); + cline_arg_option->splited_option_keys_size = xstring_cstr_split(cline_arg->allocator, (char *) option_str, cline_arg->option_delimiter, &cline_arg_option->splited_option_keys); + cline_arg_option->choices_size = xstring_cstr_split(cline_arg->allocator, (char *) choices_str, "|", &cline_arg_option->choices); cline_arg_option->description = description; cline_arg_option->epilog = XTD_NULL; cline_arg_option->values = default_value; @@ -491,7 +494,8 @@ static enum x_stat cline_arg_add_cli_args_option(ClineArgs *cline_arg, return XTD_OK; cline_arg_add_option_free_after_failure: - xfreep2p(cline_arg->allocator, cline_arg_option->splited_option_keys); + xfreep2p_wl(cline_arg->allocator, cline_arg_option->splited_option_keys, cline_arg_option->splited_option_keys_size); + xfreep2p_wl(cline_arg->allocator, cline_arg_option->choices, cline_arg_option->choices_size); cline_arg->allocator.memory_free(cline_arg_option); return XTD_ERR; } @@ -613,7 +617,7 @@ static enum x_stat cline_arg_parse_in_range(ClineArgs *cline_arg, size_t from, s } if (cline_arg_option->choices != XTD_NULL) { is_true = FALSE; - for (sub_index = 0; cline_arg_option->choices[sub_index] != XTD_NULL; sub_index++) { + for (sub_index = 0; sub_index < cline_arg_option->choices_size; sub_index++) { if (xstring_cstr_equals(cline_arg_option->choices[sub_index], val)) { is_true = TRUE; break; @@ -791,7 +795,7 @@ static enum x_stat cline_arg_section_help(ClineArgs *cline_arg, const char *sect sub_iterator = XITERATOR_INIT2(xhashtable, cstr, ClineArgsOption, entry->value->cliopts); XFOREACH(const xhashtable_entry(cstr, ClineArgsOption) *sub_entry, sub_iterator, { if (sub_entry->value->help_var != XTD_NULL) { - if (sub_entry->value->min_value_count > 0) { + if (sub_entry->value->min_value_count > 0 && !sub_entry->value->is_prefix && !sub_entry->value->is_suffix) { help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, (sub_entry->value->prefix_delimeter != XTD_NULL ? sub_entry->value->prefix_delimeter : " ")); } help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, "<"); @@ -822,9 +826,9 @@ static enum x_stat cline_arg_section_help(ClineArgs *cline_arg, const char *sect cline_arg->allocator.memory_free(help_var_text); help_var_text = XTD_NULL; } - for (index = 1; sub_entry->value->splited_option_keys[index] != XTD_NULL; index++) { + for (index = 1; index < sub_entry->value->splited_option_keys_size; index++) { if (sub_entry->value->help_var != XTD_NULL) { - if (sub_entry->value->min_value_count > 0) { + if (sub_entry->value->min_value_count > 0 && !sub_entry->value->is_prefix && !sub_entry->value->is_suffix) { help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, (sub_entry->value->prefix_delimeter != XTD_NULL ? sub_entry->value->prefix_delimeter : " ")); } help_var_text = xstring_cstr_concat_cstr(cline_arg->allocator, help_var_text, "<"); diff --git a/include/exotic/cline/cline_common.h b/include/exotic/cline/cline_common.h index 9a50938..d390311 100644 --- a/include/exotic/cline/cline_common.h +++ b/include/exotic/cline/cline_common.h @@ -1,7 +1,7 @@ /*! \copyright MIT License Copyright (c) 2021, Adewale Azeez - \author Adewale Azeez + \author Adewale Azeez \date 19 February 2021 \file cline_common.h diff --git a/include/exotic/cline/cursor_nav.h b/include/exotic/cline/cursor_nav.h index ad0c0e0..225e2d0 100644 --- a/include/exotic/cline/cursor_nav.h +++ b/include/exotic/cline/cursor_nav.h @@ -1,7 +1,7 @@ /*! \copyright MIT License Copyright (c) 2021, Adewale Azeez - \author Adewale Azeez + \author Adewale Azeez \date 19 February 2021 \file cursor_nav.h diff --git a/include/exotic/cline/font_effect.h b/include/exotic/cline/font_effect.h index 4d40e96..1e2cffc 100644 --- a/include/exotic/cline/font_effect.h +++ b/include/exotic/cline/font_effect.h @@ -1,7 +1,7 @@ /*! \copyright MIT License Copyright (c) 2021, Adewale Azeez - \author Adewale Azeez + \author Adewale Azeez \date 12 February 2021 \file font_effect.h diff --git a/include/exotic/cline/term_input.h b/include/exotic/cline/term_input.h index a65fb36..de46476 100644 --- a/include/exotic/cline/term_input.h +++ b/include/exotic/cline/term_input.h @@ -1,7 +1,7 @@ /*! \copyright MIT License Copyright (c) 2021, Adewale Azeez - \author Adewale Azeez + \author Adewale Azeez \date 19 February 2021 \file term_input.h diff --git a/include/exotic/cline/xtd_printers.h b/include/exotic/cline/xtd_printers.h index 49a6255..b173a68 100644 --- a/include/exotic/cline/xtd_printers.h +++ b/include/exotic/cline/xtd_printers.h @@ -1,7 +1,7 @@ /*! \copyright MIT License Copyright (c) 2021, Adewale Azeez - \author Adewale Azeez + \author Adewale Azeez \date 07 October 2021 \file xtd_printers.h @@ -59,8 +59,8 @@ extern "C" { XIterator *iterator##var_suffix = XITERATOR_INIT2(container_type, type1, type2, container);\ fprintf(stream, "{"); size_t size##var_suffix = container_type##_size(container);\ XFOREACH_INDEX(size_t index##var_suffix, const xpair(type1, type2) *value##var_suffix, iterator##var_suffix, {\ - CLINE_XTD_PRINTER_FPRINT_VALUE(stream, value##var_suffix->key); fprintf(stream, ": ");\ - CLINE_XTD_PRINTER_FPRINT_VALUE(stream, value##var_suffix->value); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ + CLINE_XTD_PRINTER_FPRINT_VALUE(stream, (type1) value##var_suffix->key); fprintf(stream, ": ");\ + CLINE_XTD_PRINTER_FPRINT_VALUE(stream, (type2) value##var_suffix->value); if (index##var_suffix < size##var_suffix-1) fprintf(stream, ", ");\ }); fprintf(stream, "}"); XITERATOR_DESTROY(iterator##var_suffix); /*! @@ -178,7 +178,7 @@ extern "C" { /*! */ -#define CLINE_XPRINT_XUNORDERED_SET_CUSTOM_PAIR(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunordered_set, stream, type, container, value_formatter, __LINE__) +#define CLINE_XPRINT_XUNORDERED_SET_CUSTOM(stream, type, container, value_formatter) CLINE_XPRINT_XTD_CONTAINER_CUSTOM(xunordered_set, stream, type, container, value_formatter, __LINE__) /*! diff --git a/test/cline/cliarg/test_clinearg_basic.c b/test/cline/cliarg/test_clinearg_basic.c index 28478c4..8f56818 100644 --- a/test/cline/cliarg/test_clinearg_basic.c +++ b/test/cline/cliarg/test_clinearg_basic.c @@ -1,4 +1,4 @@ -/*!gcc {0} -I. -I../include/ -I../../include/ -o out; ./out */ +/*!gcc {0} -I. -I../include/ -I../../../include/ -o out; ./out */ #include #include diff --git a/test/cline/cliarg/test_clinearg_help.c b/test/cline/cliarg/test_clinearg_help.c index ef74cc3..aed614c 100644 --- a/test/cline/cliarg/test_clinearg_help.c +++ b/test/cline/cliarg/test_clinearg_help.c @@ -1,10 +1,8 @@ -/*!gcc {0} -I. -I../include/ -I../../include/ -o out; ./out */ +/*!clang {0} -I. -I../include/ -I../../../include/ -o out; ./out */ #include #include -#define cester_assert_str_equal_(x,y) cester_assert_true(xstring_cstr_equals(x,y)) - CESTER_BODY( ) @@ -18,7 +16,7 @@ CESTER_TEST(cline_arg_help_section_name_and_description, inst, { cester_assert_int_eq(init_cline_arg(&allocator, &cline_arg, "CliCalc"), XTD_OK); cester_assert_int_eq(cline_arg_set_description(cline_arg, "A simple command line calculator"), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc\n\nA simple command line calculator\n"); + cester_assert_str_eq(help_text, "usage: CliCalc\n\nA simple command line calculator\n"); destroy_cline_arg(cline_arg); }) @@ -32,7 +30,7 @@ CESTER_TEST(cline_arg_help_section_usage, inst, { cester_assert_int_eq(init_cline_arg(&allocator, &cline_arg, "CliCalc"), XTD_OK); cester_assert_int_eq(cline_arg_set_usage(cline_arg, "usage: CliCalc [-h] (--number | --letters)"), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc [-h] (--number | --letters)\n\n"); + cester_assert_str_eq(help_text, "usage: CliCalc [-h] (--number | --letters)\n\n"); destroy_cline_arg(cline_arg); }) @@ -46,7 +44,7 @@ CESTER_TEST(cline_arg_help_section_epilog, inst, { cester_assert_int_eq(init_cline_arg(&allocator, &cline_arg, "CliCalc"), XTD_OK); cester_assert_int_eq(cline_arg_set_epilog(cline_arg, "Visit https://exoticlibraries.github.io/ for more"), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc\n\n\nVisit https://exoticlibraries.github.io/ for more\n"); + cester_assert_str_eq(help_text, "usage: CliCalc\n\n\nVisit https://exoticlibraries.github.io/ for more\n"); destroy_cline_arg(cline_arg); }) @@ -62,7 +60,7 @@ CESTER_TEST(cline_arg_help_section_description_usage_epilog, inst, { cester_assert_int_eq(cline_arg_set_description(cline_arg, "A simple command line calculator"), XTD_OK); cester_assert_int_eq(cline_arg_set_epilog(cline_arg, "Visit https://exoticlibraries.github.io/ for more"), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc [-h] (--number | --letters)\n\nA simple command line calculator\n\nVisit https://exoticlibraries.github.io/ for more\n"); + cester_assert_str_eq(help_text, "usage: CliCalc [-h] (--number | --letters)\n\nA simple command line calculator\n\nVisit https://exoticlibraries.github.io/ for more\n"); destroy_cline_arg(cline_arg); }) @@ -78,7 +76,7 @@ CESTER_TEST(cline_arg_help_name_and_description, inst, { cester_assert_int_eq(cline_arg_set_description(cline_arg, "A simple command line calculator"), XTD_OK); cester_assert_int_eq(cline_arg_set_epilog(cline_arg, "Visit https://exoticlibraries.github.io/ for more"), XTD_OK); cester_assert_int_eq(cline_arg_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc [-h] (--number | --letters)\n\nA simple command line calculator\n\nVisit https://exoticlibraries.github.io/ for more\n\n"); + cester_assert_str_eq(help_text, "usage: CliCalc [-h] (--number | --letters)\n\nA simple command line calculator\n\nVisit https://exoticlibraries.github.io/ for more\n\n"); destroy_cline_arg(cline_arg); }) @@ -95,7 +93,7 @@ CESTER_TEST(cline_arg_help_description_and_options, inst, { cester_assert_int_eq(cline_arg_add_option(cline_arg, XTD_NULL, "--version", "Print the version information and exit", FALSE), XTD_OK); cester_assert_int_eq(cline_arg_add_option(cline_arg, XTD_NULL, "--verbose", "Be extra verbose", FALSE), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc [-h|--help] [--verbose] [--version]\n" + cester_assert_str_eq(help_text, "usage: CliCalc [-h|--help] [--verbose] [--version]\n" "\n" "A simple command line calculator\n" "\n" @@ -117,7 +115,7 @@ CESTER_TEST(cline_arg_help_description_and_arguments, inst, { cester_assert_int_eq(cline_arg_add_argument(cline_arg, XTD_NULL, "--help", "Print this help message", "section", FALSE), XTD_OK); cester_assert_int_eq(cline_arg_add_argument(cline_arg, XTD_NULL, "--source", "The source file", "file", TRUE), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc [--source ] [--help
]\n" + cester_assert_str_eq(help_text, "usage: CliCalc --source [--help
]\n" "\n" "A simple command line calculator\n" "\n" @@ -138,7 +136,7 @@ CESTER_TEST(cline_arg_help_description_and_properties, inst, { cester_assert_int_eq(cline_arg_add_property(cline_arg, XTD_NULL, "-I<:>/I", "Specify the include path", "include_path", FALSE), XTD_OK); cester_assert_int_eq(cline_arg_add_property(cline_arg, XTD_NULL, "-X", "Send option to the assembler", "option", FALSE), XTD_OK); cester_assert_int_eq(cline_arg_section_help(cline_arg, XTD_NULL, XTD_NULL, &help_text), XTD_OK); - cester_assert_str_equal_(help_text, "usage: CliCalc [-X