diff options
| author | nass1pro <nass1pro@gmail.com> | 2020-06-09 19:48:34 +0200 |
|---|---|---|
| committer | Charles <sircharlesaze@gmail.com> | 2020-06-13 11:25:24 +0200 |
| commit | 19d83149feebaeb99430715242aac352890122cc (patch) | |
| tree | c5b6761db98e27d15bab3fb45ba9e0a646cf06e0 | |
| parent | 9fabc25a980550afc6337fd729632462f2680daa (diff) | |
| download | minishell-19d83149feebaeb99430715242aac352890122cc.tar.gz minishell-19d83149feebaeb99430715242aac352890122cc.tar.bz2 minishell-19d83149feebaeb99430715242aac352890122cc.zip | |
lexer_test
single_ok
273 files changed, 16407 insertions, 0 deletions
diff --git a/.DS_Store b/.DS_Store Binary files differnew file mode 100644 index 0000000..0a19ec0 --- /dev/null +++ b/.DS_Store diff --git a/libft b/libft -Subproject 3a2d19df9e509d0b015c786eb02f8315ff0ad91 +Subproject 1925805cc760061d5742f9d215998561fcd4521 diff --git a/src/.DS_Store b/src/.DS_Store Binary files differnew file mode 100644 index 0000000..68abd32 --- /dev/null +++ b/src/.DS_Store diff --git a/test_mini/a.out b/test_mini/a.out Binary files differnew file mode 100755 index 0000000..9622ab0 --- /dev/null +++ b/test_mini/a.out diff --git a/test_mini/lexer.c b/test_mini/lexer.c new file mode 100644 index 0000000..c847c1d --- /dev/null +++ b/test_mini/lexer.c @@ -0,0 +1,112 @@ + +#include "lexer.h" +#include "parse/parse.h" + + +int len_is_not_sep(char *input) +{ + int i; + + i = -1; + while(input[++i]) + { + if (lexer_sep(input[i])) + { + if (input[i + 1] == ' ') + while(input[++i] == ' ') + ; + return(i); + } + if (input[i] == '\'' || input[i] == '"') + { + i = lexer_verif_entre_cote(input, i); + if (input[i] == ' ') + return(i + 1); + return(i); + } + if (input[i] == ' ') + { + while(input[++i] == ' ') + ; + return (i); + } + } + return(i); +} + +int check_input(char *input) +{ + int i; + + i = 0; + if (lexer_sep(input[i])) + { + while(input[i] == input[i + 1]) + i++; + i += lexe_space(&input[i + 1]); + return (i + 1); + } + if (input[i] == 39 || input[i] == '"') + return(lexer_verif_entre_cote(input, i)); + if (input[i] == ' ') + { + while(input[++i] == ' ') + ; + return (i); + } + return(len_is_not_sep(&input[i])); +} + +void check_input_out(char *input) +{ + int i; + int j; + char *str; + + i = 0; + while(input[i] != '\0') + { + j = 0; + j += len_is_not_sep(&input[i]); + if (j != 0) + { + str = malloc(sizeof(char) * j + 1); + ft_strlcpy(str, &input[i], j + 1); + printf("%s%d\n",str, j); + free(str); + } + i += j; + j = check_input(&input[i]); + str = malloc(sizeof(char) * j + 1); + ft_strlcpy(str, &input[i], j + 1); + printf("%s%d\n",str, j); + free(str); + i += j; + } + +} + +t_token *create_token_list(void) +{ + t_token *lst_token; + + if (!(lst_token = malloc(sizeof(t_token) * 1))) + return (NULL); + + free(lst_token); + return (lst_token); +} + +t_ftlst *lexer(char *input) +{ + t_ftlst *lst; + + if (!input) + return (0); + if(!(lst = malloc(sizeof(t_ftlst) * 1))) + return(NULL); + + check_input_out(input); + free(lst); + return (0); +} diff --git a/test_mini/lexer.h b/test_mini/lexer.h new file mode 100644 index 0000000..a8680da --- /dev/null +++ b/test_mini/lexer.h @@ -0,0 +1,38 @@ + +# include <stdio.h> +# include <stdlib.h> +# include <libc.h> +# include "libft/include/libft_lst.h" +# include "libft/include/libft_str.h" + + +enum e_token_tag +{ + LTAG_AND = 1 << 0, + LTAG_END = 1 << 1, + LTAG_OR = 1 << 2, + LTAG_PIPE = 1 << 3, + LTAG_REDIR_IN = 1 << 4, + LTAG_REDIR_OUT = 1 << 5, + LTAG_REDIR_APPEND = 1 << 6, + LTAG_PARENT_OPEN = 1 << 7, + LTAG_PARENT_CLOSE = 1 << 8, + LTAG_STR = 1 << 9, + LTAG_STR_DOUBLE = 1 << 10, + LTAG_STR_SINGLE = 1 << 11, +}; + +typedef struct s_token +{ + enum e_token_tag token; + char *value; + +} t_token; + +t_ftlst *lexer(char *input); +enum e_token_tag ret_token_sep(char *input, int i); +enum e_token_tag ret_token_sep_redir_append(char *input, int i); + +int lexer_sep(char input); +int lexer_verif_entre_cote(char *input, int i); +int lexe_space(char *input); diff --git a/test_mini/lexer_utils.c b/test_mini/lexer_utils.c new file mode 100644 index 0000000..35050b3 --- /dev/null +++ b/test_mini/lexer_utils.c @@ -0,0 +1,81 @@ + +#include "lexer.h" + + +enum e_token_tag ret_token_sep_redir_append(char *input, int i) +{ + if (input[i + 1] == '>') + return(LTAG_REDIR_APPEND); + return (LTAG_REDIR_OUT); + +} + +enum e_token_tag ret_token_sep(char *input, int i) +{ + if (input[i] == ';') + return(LTAG_AND); + if (input[i] == '&') + return(LTAG_END); + if (input[i] == '|' && input[i + 1] == '|') + return(LTAG_OR); + if(input[i] == '|') + return(LTAG_PIPE); + if (input[i] == '>') + return(ret_token_sep_redir_append(input,i)); + if (input[i] == '<') + return(LTAG_REDIR_IN); + + return(0); + +} + + +int lexer_sep(char input) +{ + char *sep; + int i; + + i = 0; + sep = ";&|><()"; + while(sep[i] != '\0') + { + if(sep[i] == input) + return(1); + i++; + } + return (0); +} + +int lexe_space(char *input) +{ + int i; + + i=0; + while(input[i] == ' ') + i++; + return(i); +} + +int simple_cote(char *input, int i) +{ + int cote; + + cote = 39; + if (cote == input[i]) + return (1); + return(0); +} + + +int lexer_verif_entre_cote(char *input, int i) +{ + while((input[++i] != '"' || simple_cote(input,i)) && (input[i] != '\0')) + ; + //i++; + //if(input[i] == '"' || simple_cote(input,i)) + // return(lexer_verif_entre_cote(input, i)); + //if (input[i] == ' ') + // while(input[i] == ' ') + // i++; + return(i); +} diff --git a/test_mini/libft/.gitignore b/test_mini/libft/.gitignore new file mode 100644 index 0000000..07a12bb --- /dev/null +++ b/test_mini/libft/.gitignore @@ -0,0 +1,11 @@ +*.o +*.so +*.a +*.ghc +*.dSYM +a.out +test/libft_test +obj/* +rendu.makefile +doc/* +tmp/* diff --git a/test_mini/libft/.libftignore b/test_mini/libft/.libftignore new file mode 100644 index 0000000..68d827a --- /dev/null +++ b/test_mini/libft/.libftignore @@ -0,0 +1 @@ +*ft_printf* diff --git a/test_mini/libft/.travis.yml b/test_mini/libft/.travis.yml new file mode 100644 index 0000000..71027dd --- /dev/null +++ b/test_mini/libft/.travis.yml @@ -0,0 +1,4 @@ +language: c +compiler: gcc + +script: make all && make -C ./test run_v diff --git a/test_mini/libft/Doxyfile b/test_mini/libft/Doxyfile new file mode 100644 index 0000000..64cc49b --- /dev/null +++ b/test_mini/libft/Doxyfile @@ -0,0 +1,2503 @@ +# Doxyfile 1.8.17 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the configuration +# file that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# https://www.gnu.org/software/libiconv/ for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "libft" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = + +# With the PROJECT_LOGO tag one can specify a logo or an icon that is included +# in the documentation. The maximum height of the logo should not exceed 55 +# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy +# the logo to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = doc + +# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all generated output in the proper direction. +# Possible values are: None, LTR, RTL and Context. +# The default value is: None. + +OUTPUT_TEXT_DIRECTION = None + +# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = NO + +# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line +# such as +# /*************** +# as being the beginning of a Javadoc-style comment "banner". If set to NO, the +# Javadoc-style will behave just like regular comments and it will not be +# interpreted by doxygen. +# The default value is: NO. + +JAVADOC_BANNER = NO + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new +# page for each member. If set to NO, the documentation of a member will be part +# of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines (in the resulting output). You can put ^^ in the value part of an +# alias to insert a newline as if a physical newline was in the original file. +# When you need a literal { or } or , in the value part of an alias you have to +# escape them by means of a backslash (\), this can lead to conflicts with the +# commands \{ and \} for these it is advised to use the version @{ and @} or use +# a double escape (\\{ and \\}) + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = YES + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice +# sources only. Doxygen will then generate output that is more tailored for that +# language. For instance, namespaces will be presented as modules, types will be +# separated into more groups, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_SLICE = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, JavaScript, +# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, +# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran: +# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser +# tries to guess whether the code is fixed or free formatted code, this is the +# default for Fortran type files), VHDL, tcl. For instance to make doxygen treat +# .inc files as Fortran files (default is PHP), and .f files as C (default is +# Fortran), use: inc=Fortran f=C. +# +# Note: For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See https://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up +# to that level are automatically included in the table of contents, even if +# they do not have an id attribute. +# Note: This feature currently applies only to Markdown headings. +# Minimum value: 0, maximum value: 99, default value: 5. +# This tag requires that the tag MARKDOWN_SUPPORT is set to YES. + +TOC_INCLUDE_HEADINGS = 5 + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by putting a % sign in front of the word or +# globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# If one adds a struct or class to a group and this option is enabled, then also +# any nested class or struct is added to the same group. By default this option +# is disabled and one has to add nested compounds explicitly via \ingroup. +# The default value is: NO. + +GROUP_NESTED_COMPOUNDS = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual +# methods of a class will be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIV_VIRTUAL = NO + +# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO, +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. If set to YES, local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO, only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO, these classes will be included in the various overviews. This option +# has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# declarations. If set to NO, these declarations will be included in the +# documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO, these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES, upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# (including Cygwin) ands Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES, the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will +# append additional text to a page's title, such as Class Reference. If set to +# YES the compound reference will be hidden. +# The default value is: NO. + +HIDE_COMPOUND_REFERENCE= NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo +# list. This list is created by putting \todo commands in the documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test +# list. This list is created by putting \test commands in the documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if <section_label> ... \endif and \cond <section_label> +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES, the +# list will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. See also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO, doxygen will only warn about wrong or incomplete +# parameter documentation, but not about the absence of documentation. If +# EXTRACT_ALL is set to YES then this flag will automatically be disabled. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when +# a warning is encountered. +# The default value is: NO. + +WARN_AS_ERROR = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING +# Note: If this tag is empty the current directory is searched. + +INPUT = tmp + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: https://www.gnu.org/software/libiconv/) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# read by doxygen. +# +# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, +# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, +# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, +# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment), +# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen +# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f, *.for, *.tcl, *.vhd, +# *.vhdl, *.ucf, *.qsf and *.ice. + +FILE_PATTERNS = *.c \ + *.h + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# <filter> <input-file> +# +# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# properly processed by doxygen. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# properly processed by doxygen. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# entity all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see https://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# cascading style sheets that are included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefore more robust against future updates. +# Doxygen will copy the style sheet files to the output directory. +# Note: The order of the extra style sheet files is of importance (e.g. the last +# style sheet in the list overrules the setting of the previous ones in the +# list). For an example see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the style sheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# https://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to YES can help to show when doxygen was last run and thus if the +# documentation is up to date. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML +# documentation will contain a main index with vertical navigation menus that +# are dynamically created via JavaScript. If disabled, the navigation index will +# consists of multiple levels of tabs that are statically embedded in every HTML +# page. Disable this option to support browsers that do not have JavaScript, +# like the Qt help browser. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_MENUS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: https://developer.apple.com/xcode/), introduced with OSX +# 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy +# genXcode/_index.html for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler (hhc.exe). If non-empty, +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated +# (YES) or that it should be included in the master .chm file (NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated +# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANSPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands +# to create new LaTeX commands to be used in formulas as building blocks. See +# the section "Including formulas" for details. + +FORMULA_MACROFILE = + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# https://www.mathjax.org) which uses client side JavaScript for the rendering +# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from https://www.mathjax.org before deployment. +# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/ + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use <access key> + S +# (what the <access key> is depends on the OS and browser, but it is typically +# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down +# key> to jump into the search results window, the results can be navigated +# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel +# the search. The filter options can be selected when the cursor is inside the +# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys> +# to select a filter and <Enter> or <escape> to activate or cancel the filter +# option. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +SEARCHENGINE = YES + +# When the SERVER_BASED_SEARCH tag is enabled the search engine will be +# implemented using a web server instead of a web client using JavaScript. There +# are two flavors of web server based searching depending on the EXTERNAL_SEARCH +# setting. When disabled, doxygen will generate a PHP script for searching and +# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing +# and searching needs to be provided by external tools. See the section +# "External Indexing and Searching" for details. +# The default value is: NO. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SERVER_BASED_SEARCH = NO + +# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP +# script for searching. Instead the search results are written to an XML file +# which needs to be processed by an external indexer. Doxygen will invoke an +# external search engine pointed to by the SEARCHENGINE_URL option to obtain the +# search results. +# +# Doxygen ships with an example indexer (doxyindexer) and search engine +# (doxysearch.cgi) which are based on the open source search engine library +# Xapian (see: https://xapian.org/). +# +# See the section "External Indexing and Searching" for details. +# The default value is: NO. +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTERNAL_SEARCH = NO + +# The SEARCHENGINE_URL should point to a search engine hosted by a web server +# which will return the search results when EXTERNAL_SEARCH is enabled. +# +# Doxygen ships with an example indexer (doxyindexer) and search engine +# (doxysearch.cgi) which are based on the open source search engine library +# Xapian (see: https://xapian.org/). See the section "External Indexing and +# Searching" for details. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SEARCHENGINE_URL = + +# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed +# search data is written to a file for indexing by an external tool. With the +# SEARCHDATA_FILE tag the name of this file can be specified. +# The default file is: searchdata.xml. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SEARCHDATA_FILE = searchdata.xml + +# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the +# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is +# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple +# projects and redirect the results back to the right project. +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTERNAL_SEARCH_ID = + +# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen +# projects other than the one defined by this configuration file, but that are +# all added to the same external search index. Each project needs to have a +# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of +# to a relative location where the documentation can be found. The format is: +# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ... +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTRA_SEARCH_MAPPINGS = + +#--------------------------------------------------------------------------- +# Configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output. +# The default value is: YES. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: latex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. +# +# Note that when not enabling USE_PDFLATEX the default is latex when enabling +# USE_PDFLATEX the default is pdflatex and when in the later case latex is +# chosen this is overwritten by pdflatex. For specific output languages the +# default can have been set differently, this depends on the implementation of +# the output language. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_CMD_NAME = + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate +# index for LaTeX. +# Note: This tag is used in the Makefile / make.bat. +# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file +# (.tex). +# The default file is: makeindex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +MAKEINDEX_CMD_NAME = makeindex + +# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to +# generate index for LaTeX. In case there is no backslash (\) as first character +# it will be automatically added in the LaTeX code. +# Note: This tag is used in the generated output file (.tex). +# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat. +# The default value is: makeindex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_MAKEINDEX_CMD = makeindex + +# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX +# documents. This may be useful for small projects and may help to save some +# trees in general. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used by the +# printer. +# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x +# 14 inches) and executive (7.25 x 10.5 inches). +# The default value is: a4. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +PAPER_TYPE = a4 + +# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names +# that should be included in the LaTeX output. The package can be specified just +# by its name or with the correct syntax as to be used with the LaTeX +# \usepackage command. To get the times font for instance you can specify : +# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times} +# To use the option intlimits with the amsmath package you can specify: +# EXTRA_PACKAGES=[intlimits]{amsmath} +# If left blank no extra packages will be included. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the +# generated LaTeX document. The header should contain everything until the first +# chapter. If it is left blank doxygen will generate a standard header. See +# section "Doxygen usage" for information on how to let doxygen write the +# default header to a separate file. +# +# Note: Only use a user-defined header if you know what you are doing! The +# following commands have a special meaning inside the header: $title, +# $datetime, $date, $doxygenversion, $projectname, $projectnumber, +# $projectbrief, $projectlogo. Doxygen will replace $title with the empty +# string, for the replacement values of the other commands the user is referred +# to HTML_HEADER. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_HEADER = + +# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the +# generated LaTeX document. The footer should contain everything after the last +# chapter. If it is left blank doxygen will generate a standard footer. See +# LATEX_HEADER for more information on how to generate a default footer and what +# special commands can be used inside the footer. +# +# Note: Only use a user-defined footer if you know what you are doing! +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_FOOTER = + +# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# LaTeX style sheets that are included after the standard style sheets created +# by doxygen. Using this option one can overrule certain style aspects. Doxygen +# will copy the style sheet files to the output directory. +# Note: The order of the extra style sheet files is of importance (e.g. the last +# style sheet in the list overrules the setting of the previous ones in the +# list). +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_EXTRA_STYLESHEET = + +# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the LATEX_OUTPUT output +# directory. Note that the files will be copied as-is; there are no commands or +# markers available. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_EXTRA_FILES = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is +# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will +# contain links (just like the HTML output) instead of page references. This +# makes the output suitable for online browsing using a PDF viewer. +# The default value is: YES. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate +# the PDF file directly from the LaTeX files. Set this option to YES, to get a +# higher quality PDF documentation. +# The default value is: YES. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode +# command to the generated LaTeX files. This will instruct LaTeX to keep running +# if errors occur, instead of asking the user for help. This option is also used +# when generating formulas in HTML. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_BATCHMODE = NO + +# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the +# index chapters (such as File Index, Compound Index, etc.) in the output. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_HIDE_INDICES = NO + +# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source +# code with syntax highlighting in the LaTeX output. +# +# Note that which sources are shown also depends on other settings such as +# SOURCE_BROWSER. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_SOURCE_CODE = NO + +# The LATEX_BIB_STYLE tag can be used to specify the style to use for the +# bibliography, e.g. plainnat, or ieeetr. See +# https://en.wikipedia.org/wiki/BibTeX and \cite for more info. +# The default value is: plain. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_BIB_STYLE = plain + +# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_TIMESTAMP = NO + +# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute) +# path from which the emoji images will be read. If a relative path is entered, +# it will be relative to the LATEX_OUTPUT directory. If left blank the +# LATEX_OUTPUT directory will be used. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_EMOJI_DIRECTORY = + +#--------------------------------------------------------------------------- +# Configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The +# RTF output is optimized for Word 97 and may not look too pretty with other RTF +# readers/editors. +# The default value is: NO. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: rtf. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF +# documents. This may be useful for small projects and may help to save some +# trees in general. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will +# contain hyperlink fields. The RTF file will contain links (just like the HTML +# output) instead of page references. This makes the output suitable for online +# browsing using Word or some other Word compatible readers that support those +# fields. +# +# Note: WordPad (write) and others do not support links. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# configuration file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. +# +# See also section "Doxygen usage" for information on how to generate the +# default style sheet that doxygen normally uses. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an RTF document. Syntax is +# similar to doxygen's configuration file. A template extensions file can be +# generated using doxygen -e rtf extensionFile. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_EXTENSIONS_FILE = + +# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code +# with syntax highlighting in the RTF output. +# +# Note that which sources are shown also depends on other settings such as +# SOURCE_BROWSER. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_SOURCE_CODE = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for +# classes and files. +# The default value is: NO. + +GENERATE_MAN = YES + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. A directory man3 will be created inside the directory specified by +# MAN_OUTPUT. +# The default directory is: man. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to the generated +# man pages. In case the manual section does not start with a number, the number +# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is +# optional. +# The default value is: .3. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_EXTENSION = .3 + +# The MAN_SUBDIR tag determines the name of the directory created within +# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by +# MAN_EXTENSION with the initial . removed. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_SUBDIR = + +# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it +# will generate one additional man file for each entity documented in the real +# man page(s). These additional files only source the real man page, but without +# them the man command would be unable to find the correct page. +# The default value is: NO. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that +# captures the structure of the code including all documentation. +# The default value is: NO. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: xml. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_OUTPUT = xml + +# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program +# listings (including syntax highlighting and cross-referencing information) to +# the XML output. Note that enabling this will significantly increase the size +# of the XML output. +# The default value is: YES. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_PROGRAMLISTING = YES + +# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include +# namespace members in file scope as well, matching the HTML output. +# The default value is: NO. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_NS_MEMB_FILE_SCOPE = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the DOCBOOK output +#--------------------------------------------------------------------------- + +# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files +# that can be used to generate PDF. +# The default value is: NO. + +GENERATE_DOCBOOK = NO + +# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in +# front of it. +# The default directory is: docbook. +# This tag requires that the tag GENERATE_DOCBOOK is set to YES. + +DOCBOOK_OUTPUT = docbook + +# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the +# program listings (including syntax highlighting and cross-referencing +# information) to the DOCBOOK output. Note that enabling this will significantly +# increase the size of the DOCBOOK output. +# The default value is: NO. +# This tag requires that the tag GENERATE_DOCBOOK is set to YES. + +DOCBOOK_PROGRAMLISTING = NO + +#--------------------------------------------------------------------------- +# Configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an +# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures +# the structure of the code including all documentation. Note that this feature +# is still experimental and incomplete at the moment. +# The default value is: NO. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module +# file that captures the structure of the code including all documentation. +# +# Note that this feature is still experimental and incomplete at the moment. +# The default value is: NO. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary +# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI +# output from the Perl module output. +# The default value is: NO. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely +# formatted so it can be parsed by a human reader. This is useful if you want to +# understand what is going on. On the other hand, if this tag is set to NO, the +# size of the Perl module output will be much smaller and Perl will parse it +# just the same. +# The default value is: YES. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file are +# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful +# so different doxyrules.make files included by the same Makefile don't +# overwrite each other's variables. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all +# C-preprocessor directives found in the sources and include files. +# The default value is: YES. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names +# in the source code. If set to NO, only conditional compilation will be +# performed. Macro expansion can be done in a controlled way by setting +# EXPAND_ONLY_PREDEF to YES. +# The default value is: NO. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then +# the macro expansion is limited to the macros specified with the PREDEFINED and +# EXPAND_AS_DEFINED tags. +# The default value is: NO. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES, the include files in the +# INCLUDE_PATH will be searched if a #include is found. +# The default value is: YES. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by the +# preprocessor. +# This tag requires that the tag SEARCH_INCLUDES is set to YES. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will be +# used. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that are +# defined before the preprocessor is started (similar to the -D option of e.g. +# gcc). The argument of the tag is a list of macros of the form: name or +# name=definition (no spaces). If the definition and the "=" are omitted, "=1" +# is assumed. To prevent a macro definition from being undefined via #undef or +# recursively expanded use the := operator instead of the = operator. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this +# tag can be used to specify a list of macro names that should be expanded. The +# macro definition that is found in the sources will be used. Use the PREDEFINED +# tag if you want to use a different macro definition that overrules the +# definition found in the source code. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will +# remove all references to function-like macros that are alone on a line, have +# an all uppercase name, and do not end with a semicolon. Such function macros +# are typically used for boiler-plate code, and will confuse the parser if not +# removed. +# The default value is: YES. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tag files. For each tag +# file the location of the external documentation should be added. The format of +# a tag file without this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where loc1 and loc2 can be relative or absolute paths or URLs. See the +# section "Linking to external documentation" for more information about the use +# of tag files. +# Note: Each tag file must have a unique name (where the name does NOT include +# the path). If a tag file is not located in the directory in which doxygen is +# run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create a +# tag file that is based on the input files it reads. See section "Linking to +# external documentation" for more information about the usage of tag files. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES, all external class will be listed in +# the class index. If set to NO, only the inherited external classes will be +# listed. +# The default value is: NO. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will be +# listed. +# The default value is: YES. + +EXTERNAL_GROUPS = YES + +# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in +# the related pages index. If set to NO, only the current project's pages will +# be listed. +# The default value is: YES. + +EXTERNAL_PAGES = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram +# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to +# NO turns the diagrams off. Note that this option also works with HAVE_DOT +# disabled, but it is recommended to install and use dot, since it yields more +# powerful graphs. +# The default value is: YES. + +CLASS_DIAGRAMS = YES + +# You can include diagrams made with dia in doxygen documentation. Doxygen will +# then run dia to produce the diagram and insert it in the documentation. The +# DIA_PATH tag allows you to specify the directory where the dia binary resides. +# If left empty dia is assumed to be found in the default search path. + +DIA_PATH = + +# If set to YES the inheritance and collaboration graphs will hide inheritance +# and usage relations if the target is undocumented or is not a class. +# The default value is: YES. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz (see: +# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent +# Bell Labs. The other options in this section have no effect if this option is +# set to NO +# The default value is: NO. + +HAVE_DOT = NO + +# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed +# to run in parallel. When set to 0 doxygen will base this on the number of +# processors available in the system. You can set it explicitly to a value +# larger than 0 to get control over the balance between CPU load and processing +# speed. +# Minimum value: 0, maximum value: 32, default value: 0. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_NUM_THREADS = 0 + +# When you want a differently looking font in the dot files that doxygen +# generates you can specify the font name using DOT_FONTNAME. You need to make +# sure dot is able to find the font, which can be done by putting it in a +# standard location or by setting the DOTFONTPATH environment variable or by +# setting DOT_FONTPATH to the directory containing the font. +# The default value is: Helvetica. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTNAME = Helvetica + +# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of +# dot graphs. +# Minimum value: 4, maximum value: 24, default value: 10. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the default font as specified with +# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set +# the path where dot can find it using this tag. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTPATH = + +# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for +# each documented class showing the direct and indirect inheritance relations. +# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a +# graph for each documented class showing the direct and indirect implementation +# dependencies (inheritance, containment, and class references variables) of the +# class with other documented classes. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for +# groups, showing the direct groups dependencies. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +UML_LOOK = NO + +# If the UML_LOOK tag is enabled, the fields and methods are shown inside the +# class node. If there are many fields or methods and many nodes the graph may +# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the +# number of items for each type to make the size more manageable. Set this to 0 +# for no limit. Note that the threshold may be exceeded by 50% before the limit +# is enforced. So when you set the threshold to 10, up to 15 fields may appear, +# but if the number exceeds 15, the total amount of fields shown is limited to +# 10. +# Minimum value: 0, maximum value: 100, default value: 10. +# This tag requires that the tag HAVE_DOT is set to YES. + +UML_LIMIT_NUM_FIELDS = 10 + +# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and +# collaboration graphs will show the relations between templates and their +# instances. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +TEMPLATE_RELATIONS = NO + +# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to +# YES then doxygen will generate a graph for each documented file showing the +# direct and indirect include dependencies of the file with other documented +# files. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +INCLUDE_GRAPH = YES + +# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are +# set to YES then doxygen will generate a graph for each documented file showing +# the direct and indirect include dependencies of the file with other documented +# files. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH tag is set to YES then doxygen will generate a call +# dependency graph for every global function or class method. +# +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable call graphs for selected +# functions only using the \callgraph command. Disabling a call graph can be +# accomplished by means of the command \hidecallgraph. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +CALL_GRAPH = NO + +# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller +# dependency graph for every global function or class method. +# +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable caller graphs for selected +# functions only using the \callergraph command. Disabling a caller graph can be +# accomplished by means of the command \hidecallergraph. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +CALLER_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical +# hierarchy of all classes instead of a textual one. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the +# dependencies a directory has on other directories in a graphical way. The +# dependency relations are determined by the #include relations between the +# files in the directories. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. For an explanation of the image formats see the section +# output formats in the documentation of the dot tool (Graphviz (see: +# http://www.graphviz.org/)). +# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order +# to make the SVG files visible in IE 9+ (other browsers do not have this +# requirement). +# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo, +# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and +# png:gdiplus:gdiplus. +# The default value is: png. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_IMAGE_FORMAT = png + +# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to +# enable generation of interactive SVG images that allow zooming and panning. +# +# Note that this requires a modern browser other than Internet Explorer. Tested +# and working are Firefox, Chrome, Safari, and Opera. +# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make +# the SVG files visible. Older versions of IE do not have SVG support. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +INTERACTIVE_SVG = NO + +# The DOT_PATH tag can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the \dotfile +# command). +# This tag requires that the tag HAVE_DOT is set to YES. + +DOTFILE_DIRS = + +# The MSCFILE_DIRS tag can be used to specify one or more directories that +# contain msc files that are included in the documentation (see the \mscfile +# command). + +MSCFILE_DIRS = + +# The DIAFILE_DIRS tag can be used to specify one or more directories that +# contain dia files that are included in the documentation (see the \diafile +# command). + +DIAFILE_DIRS = + +# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the +# path where java can find the plantuml.jar file. If left blank, it is assumed +# PlantUML is not used or called during a preprocessing step. Doxygen will +# generate a warning when it encounters a \startuml command in this case and +# will not generate output for the diagram. + +PLANTUML_JAR_PATH = + +# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a +# configuration file for plantuml. + +PLANTUML_CFG_FILE = + +# When using plantuml, the specified paths are searched for files specified by +# the !include statement in a plantuml block. + +PLANTUML_INCLUDE_PATH = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes +# that will be shown in the graph. If the number of nodes in a graph becomes +# larger than this value, doxygen will truncate the graph, which is visualized +# by representing a node as a red box. Note that doxygen if the number of direct +# children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that +# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. +# Minimum value: 0, maximum value: 10000, default value: 50. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs +# generated by dot. A depth value of 3 means that only nodes reachable from the +# root by following a path via at most 3 edges will be shown. Nodes that lay +# further from the root node will be omitted. Note that setting this option to 1 +# or 2 may greatly reduce the computation time needed for large code bases. Also +# note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. +# Minimum value: 0, maximum value: 1000, default value: 0. +# This tag requires that the tag HAVE_DOT is set to YES. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not seem +# to support this out of the box. +# +# Warning: Depending on the platform used, enabling this option may lead to +# badly anti-aliased labels on the edges of a graph (i.e. they become hard to +# read). +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) support +# this, this feature is disabled by default. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page +# explaining the meaning of the various boxes and arrows in the dot generated +# graphs. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot +# files that are used to generate the various graphs. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_CLEANUP = YES diff --git a/test_mini/libft/LICENSE b/test_mini/libft/LICENSE new file mode 100644 index 0000000..476120d --- /dev/null +++ b/test_mini/libft/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 HappyTramp + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/test_mini/libft/Makefile b/test_mini/libft/Makefile new file mode 100644 index 0000000..7886427 --- /dev/null +++ b/test_mini/libft/Makefile @@ -0,0 +1,97 @@ +# **************************************************************************** # +# # +# ::: :::::::: # +# Makefile :+: :+: :+: # +# +:+ +:+ +:+ # +# By: cacharle <marvin@42.fr> +#+ +:+ +#+ # +# +#+#+#+#+#+ +#+ # +# Created: 2019/10/08 15:45:53 by cacharle #+# #+# # +# Updated: 2020/04/01 22:00:44 by charles ### ########.fr # +# # +# **************************************************************************** # + +LIB = ar rcs +RM = rm -f +NORM = norminette +MAKE = make +MAKE_ARGS = --no-print-directory +DOXYGEN = doxygen +DOXYGEN_FILE = Doxyfile + +SRC_DIR = src +INCLUDE_DIR = include +OBJ_DIR = obj +SCRIPT_DIR = script +TEST_DIR = test +DOC_DIR = doc + +INCLUDE_DIR = include + + +CC = gcc +OFLAG ?= -O1 +CCFLAGS = $(OFLAG) -I$(INCLUDE_DIR) -Wall -Wextra -Werror +ifeq ($(TRAVIS_COMPILER),gcc) +CCFLAGS += -Wno-unused-result +endif + +IGNORE_FILE = .libftignore +IGNORE_DEFAULT = ft_printf + +NAME = libft.a + +SRC = $(shell sh $(SCRIPT_DIR)/find_src.sh $(IGNORE_FILE)) +OBJ = $(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o) + +INCLUDE = $(shell find $(INCLUDE_DIR) -name "*.h") + +# export LIBFT_SRC = $(SRC) + +all: prebuild $(NAME) + +.PHONY: test +test: all + @echo "Testing" + @$(MAKE) $(MAKE_ARGS) -C $(TEST_DIR) run + +norm: + @if [ `command -v $(NORM)` ]; \ + then echo "Running norminette"; \ + $(NORM) $(SRC) $(INCLUDE); \ + else echo "$(NORM) not installed"; fi + +prebuild: + @for dir in $$(find $(SRC_DIR)/* $(FIND_ARGS) -type d | \ + sed 's_$(SRC_DIR)/_$(OBJ_DIR)/_g'); \ + do \ + if [ ! -d "$$dir" ]; then \ + mkdir -p $$dir; echo "Making build dir: $$dir"; fi \ + done + +$(NAME): $(OBJ) $(INCLUDE) + @echo "Linking: $@" + @$(LIB) $@ $(OBJ) + +$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c + @echo "Compiling: $@" + @$(CC) $(CCFLAGS) -c -o $@ $< + +clean: + @echo "Removing objects" + @$(RM) -r $(OBJ_DIR) + +fclean: clean + @echo "Removing library" + @$(RM) $(NAME) + +re: fclean all + +.PHONY: doc +doc: + mkdir -p tmp + for f in $(SRC) $(INCLUDE); do mkdir -p tmp/`dirname $$f` && sed 's_^/\*$$_/**_' $$f > tmp/$$f; done + $(DOXYGEN) $(DOXYGEN_FILE) + +doc_clean: + $(RM) -r $(DOC_DIR) + diff --git a/test_mini/libft/README.md b/test_mini/libft/README.md new file mode 100644 index 0000000..a278471 --- /dev/null +++ b/test_mini/libft/README.md @@ -0,0 +1,37 @@ +# libft [](https://travis-ci.com/HappyTramp/libft) + +libft is an extension/remake of the standard library. + +## Getting Started + +``` +git clone https://github.com/HappyTramp/libft libft +cd libft +make all +``` + +This will produce a `libft.a` library which you can link to your project. + +## Unit Test + +``` +make test +``` + +## Dependencies + +* [Unity](https://github.com/ThrowTheSwitch/Unity) - unit testing lib + +## .libftignore + +Much like the `.gitignore` file, you can put the files/directory to ignore when compiling. + +## Documentation + +1. Install [Doxygen](http://doxygen.nl/manual/install.html) +2. Run `make doc` +3. Open doc/html/index.html in your browser or read the man in doc/man/man3 + +## School correction state + +The state of this project when I turned it in for correction is [here](http://github.com/HappyTramp/libft/tree/raw). diff --git a/test_mini/libft/include/libft.h b/test_mini/libft/include/libft.h new file mode 100644 index 0000000..74f074b --- /dev/null +++ b/test_mini/libft/include/libft.h @@ -0,0 +1,34 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:45:02 by cacharle #+# #+# */ +/* Updated: 2020/02/10 02:19:47 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_H +# define LIBFT_H + +# include <unistd.h> +# include <stdarg.h> +# include <stdlib.h> +# include <stddef.h> +# include <limits.h> +# include <errno.h> + +# include "libft_types.h" +# include "libft_ctype.h" +# include "libft_io.h" +# include "libft_mem.h" +# include "libft_str.h" + +# ifdef __linux__ +# include <stdio.h> +# define OPEN_MAX FOPEN_MAX +# endif + +#endif diff --git a/test_mini/libft/include/libft_algo.h b/test_mini/libft/include/libft_algo.h new file mode 100644 index 0000000..7223e7b --- /dev/null +++ b/test_mini/libft/include/libft_algo.h @@ -0,0 +1,59 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_algo.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/19 07:22:57 by cacharle #+# #+# */ +/* Updated: 2020/02/10 05:58:26 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_ALGO_H +# define LIBFT_ALGO_H + +# include <stdlib.h> +# include <stddef.h> +# include "libft_mem.h" +# include "libft_types.h" + +typedef int (*t_ftcompar_func)(const void*, const void*); + +typedef struct +{ + int lo; + int hi; +} t_ftrange; + +struct s_merge_sorted_arrays +{ + void *base; + void *left; + void *right; +}; + +typedef struct s_ft_search_const +{ + const void *key; + t_ftcompar_func compar; +} t_ftsearch_const; + +t_ftbool ft_is_set(void *base, size_t nel, size_t width, + t_ftcompar_func compar); +int ft_compar_int(const void *a, const void *b); +void ft_qsort(void *base, size_t nel, size_t width, + t_ftcompar_func compar); +int ft_mergesort(void *base, size_t nel, size_t width, + int (*compar)(const void *, const void *)); +int ft_heapsort(void *base, size_t nel, size_t width, + int (*compar)(const void *, const void *)); +void ft_reverse(void *base, size_t nel, size_t width); +void *ft_bsearch(const void *base, size_t nel, size_t width, + t_ftsearch_const *consts); +void *ft_lfind(const void *base, size_t *nelp, size_t width, + t_ftsearch_const *consts); +void *ft_lsearch(const void *base, size_t *nelp, size_t width, + t_ftsearch_const *consts); + +#endif diff --git a/test_mini/libft/include/libft_bt.h b/test_mini/libft/include/libft_bt.h new file mode 100644 index 0000000..6e2cc91 --- /dev/null +++ b/test_mini/libft/include/libft_bt.h @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_bt.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/07 21:26:34 by cacharle #+# #+# */ +/* Updated: 2020/02/07 21:34:52 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_BT_H +# define LIBFT_BT_H + +# include <stdlib.h> + +typedef struct s_ftbtree +{ + void *data; + struct s_ftbtree *left; + struct s_ftbtree *right; +} t_ftbtree; + +t_ftbtree *ft_btnew(void *data); +void ft_btdestroy(t_ftbtree *tree, void (*del)(void *data)); + +#endif diff --git a/test_mini/libft/include/libft_ctype.h b/test_mini/libft/include/libft_ctype.h new file mode 100644 index 0000000..61f4534 --- /dev/null +++ b/test_mini/libft/include/libft_ctype.h @@ -0,0 +1,36 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_ctype.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:35:31 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:08:52 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_CTYPE_H +# define LIBFT_CTYPE_H + +/* +** assertion +*/ + +int ft_isalpha(int c); +int ft_isdigit(int c); +int ft_isalnum(int c); +int ft_isascii(int c); +int ft_isprint(int c); +int ft_isspace(int c); +int ft_isblank(int c); + +/* +** conversion +*/ + +int ft_toupper(int c); +int ft_tolower(int c); +int ft_todigit(int c); + +#endif diff --git a/test_mini/libft/include/libft_ht.h b/test_mini/libft/include/libft_ht.h new file mode 100644 index 0000000..10c6fc7 --- /dev/null +++ b/test_mini/libft/include/libft_ht.h @@ -0,0 +1,71 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_ht.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:36:09 by cacharle #+# #+# */ +/* Updated: 2020/04/01 17:59:35 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_HT_H +# define LIBFT_HT_H + +/* +** \file libft_ht.h +** \brief Hash table manipulation +*/ + +# include "libft.h" +# include "libft_lst.h" + +/* +** \brief Hash table entry, key/value pair +** \param key String key +** \param value Pointer to data +*/ + +typedef struct s_ftht_entry +{ + char *key; + void *value; +} t_ftht_entry; + +typedef t_ftlst* t_ftht_bucket; + +/* +** \brief Hash table struct +** \param size Number of buckets +** \param buckets Bucket array +*/ + +typedef struct s_ftht +{ + t_ftsize size; + t_ftht_bucket *buckets; +} t_ftht; + +typedef t_ftuint t_ftht_digest; + +t_ftht_digest ft_hthash(t_ftht *ht, char *key); + +t_ftht *ft_htnew(t_ftsize size); +void ft_htdestroy(t_ftht *ht, void (*del)(t_ftht_entry*)); +void *ft_htget(t_ftht *ht, char *key); +t_ftht_entry *ft_htset(t_ftht *ht, char *key, void *value, + void (*del)(t_ftht_entry*)); +void ft_htdelone(t_ftht *ht, char *key, + void (*del)(t_ftht_entry*)); +t_ftht_entry *ft_htentry_new(char *key, void *value); +void ft_htiter(t_ftht *ht, void (*f)(t_ftht_entry*)); + +/* +** internals +*/ + +int ft_inter_htkey_cmp(const void *ref_key, + const void *content); + +#endif diff --git a/test_mini/libft/include/libft_io.h b/test_mini/libft/include/libft_io.h new file mode 100644 index 0000000..418b230 --- /dev/null +++ b/test_mini/libft/include/libft_io.h @@ -0,0 +1,46 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_io.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:35:43 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:09:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_IO_H +# define LIBFT_IO_H + +# include <unistd.h> +# include <stdlib.h> +# include <limits.h> +# include "libft.h" + +void ft_putendl(char *s); +void ft_putchar(char c); +void ft_putstr(char const *s); +void ft_putnbr(int n); +void ft_putchar_fd(char c, int fd); +void ft_putstr_fd(char *s, int fd); +void ft_putendl_fd(char *s, int fd); +void ft_putnbr_fd(int n, int fd); + +char ft_getchar(void); + +# ifndef FTNL_BUFFER_SIZE +# define FTNL_BUFFER_SIZE 32 +# endif + +# define FTNL_STATUS_LINE 1 +# define FTNL_STATUS_EOF 0 +# define FTNL_STATUS_ERROR -1 + +/* +** get_next_line.c +*/ + +int ft_next_line(int fd, char **line); + +#endif diff --git a/test_mini/libft/include/libft_lst.h b/test_mini/libft/include/libft_lst.h new file mode 100644 index 0000000..d7157a9 --- /dev/null +++ b/test_mini/libft/include/libft_lst.h @@ -0,0 +1,65 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_lst.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:36:39 by cacharle #+# #+# */ +/* Updated: 2020/04/01 17:59:50 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_LST_H +# define LIBFT_LST_H + +/* +** \file libft_lst.h +** \brief Linked list Manipulation +*/ + +# include <stdlib.h> +# include "libft_types.h" +# include "libft_algo.h" + +/* +** \brief List struct +** \param data Pointer to node data +** \param next Pointer to next node or NULL if last node +*/ + +typedef struct s_ftlst +{ + void *data; + struct s_ftlst *next; +} t_ftlst; + +typedef void (*t_ftdel_func)(void *); + +t_ftlst *ft_lstnew(void const *data); +int ft_lstsize(t_ftlst *lst); +void ft_lstpush_front(t_ftlst **alst, t_ftlst *new); +void ft_lstpush_back(t_ftlst **alst, t_ftlst *new); +void ft_lstpop_front(t_ftlst **lst, void (*del)(void *)); +t_ftlst *ft_lstlast(t_ftlst *lst); +void ft_lstdelone(t_ftlst *lst, void (*del)(void *)); +void ft_lstdestroy(t_ftlst **lst, void (*del)(void *)); +void ft_lstiter(t_ftlst *lst, void (*f)(void *)); +t_ftlst *ft_lstmap(t_ftlst *lst, void *(*f)(void *), + t_ftdel_func del); +t_ftlst *ft_lstreverse_ret(t_ftlst *lst); +void ft_lstreverse(t_ftlst **lst); +void ft_lstremove_if(t_ftlst **lst, + t_ftcompar_func cmp, const void *ref, + t_ftdel_func del); +t_ftlst *ft_lstbsearch(t_ftlst *lst, t_ftcompar_func cmp, + const void *ref); +t_ftlst *ft_lstlsearch(t_ftlst *lst, t_ftcompar_func cmp, + const void *ref); +t_ftlst *ft_lstlfind(t_ftlst *lst, t_ftcompar_func cmp, + const void *ref); +void ft_lstsort(t_ftlst **begin_list, t_ftcompar_func cmp); +t_ftlst *ft_lstsorted_merge(t_ftlst *l1, t_ftlst *l2, + t_ftcompar_func cmp); + +#endif diff --git a/test_mini/libft/include/libft_mem.h b/test_mini/libft/include/libft_mem.h new file mode 100644 index 0000000..37c072e --- /dev/null +++ b/test_mini/libft/include/libft_mem.h @@ -0,0 +1,39 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_mem.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:35:57 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:17:48 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_MEM_H +# define LIBFT_MEM_H + +# include <stddef.h> +# include "libft_types.h" + +void ft_bzero(void *s, size_t n); +void *ft_memset(void *s, int c, size_t n); +void *ft_memcpy(void *dest, const void *src, size_t n); +void *ft_memccpy(void *dest, const void *src, int c, size_t n); +void *ft_memmove(void *dst, const void *src, size_t len); +void *ft_memchr(const void *s, int c, size_t n); +int ft_memcmp(const void *s1, const void *s2, size_t n); +void *ft_calloc(size_t count, size_t size); +void ft_memswap(void *a, void *b, size_t size); +void *ft_memmem(const void *big, size_t big_len, + const void *little, size_t little_len); +void ft_memset_pattern4(void *b, const void *pattern4, + size_t len); + +/* +** bloat ? +*/ + +void ft_memdel(void **ap); + +#endif diff --git a/test_mini/libft/include/libft_printf.h b/test_mini/libft/include/libft_printf.h new file mode 100644 index 0000000..8e64208 --- /dev/null +++ b/test_mini/libft/include/libft_printf.h @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_printf.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:36:47 by cacharle #+# #+# */ +/* Updated: 2020/01/31 10:36:51 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_PRINTF_H +# define LIBFT_PRINTF_H + +int ft_printf(const char *format, ...); +int ft_sprintf(char *str, const char *format, ...); +int ft_snprintf(char *str, size_t size, const char *format, ...); +int ft_asprintf(char **ret, const char *format, ...); +int ft_dprintf(int fd, const char *format, ...); +int ft_vprintf(const char *format, va_list ap); +int ft_vsprintf(char *str, const char *format, va_list ap); +int ft_vsnprintf(char *str, size_t size, const char *format, va_list ap); +int ft_vasprintf(char **ret, const char *format, va_list ap); +int ft_vdprintf(int fd, const char *format, va_list ap); + +#endif diff --git a/test_mini/libft/include/libft_str.h b/test_mini/libft/include/libft_str.h new file mode 100644 index 0000000..ea6115d --- /dev/null +++ b/test_mini/libft/include/libft_str.h @@ -0,0 +1,87 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_str.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:39:22 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:09:56 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_STR_H +# define LIBFT_STR_H + +# include <stddef.h> +# include "libft_ctype.h" + +typedef enum +{ + FT_STRJOINF_FST, + FT_STRJOINF_SND, + FT_STRJOINF_ALL +} t_ftstrjoinf_tag; + +/* +** std +*/ + +size_t ft_strlen(const char *s); +char *ft_strcpy(char *dest, const char *src); +char *ft_strncpy(char *dest, const char *src, size_t n); +char *ft_strdup(const char *s); +char *ft_strndup(const char *s1, size_t n); +char *ft_strcat(char *dest, const char *src); +char *ft_strncat(char *dest, const char *src, size_t n); +size_t ft_strlcat(char *dst, const char *src, size_t size); +size_t ft_strlcpy(char *dst, const char *src, size_t size); +char *ft_strchr(const char *s, int c); +char *ft_strrchr(const char *s, int c); +char *ft_strstr(const char *haystack, const char *needle); +char *ft_strnstr(const char *haystack, const char *needle, size_t len); +int ft_strcmp(const char *s1, const char *s2); +int ft_strncmp(const char *s1, const char *s2, size_t n); +int ft_atoi(const char *nptr); + +/* +** extra +*/ + +void ft_striter(char *s, void (*f)(char *)); +void ft_striteri(char *s, void (*f)(unsigned int, char *)); +char *ft_substr(char const *s, unsigned int start, size_t len); +char *ft_strjoin(char const *s1, char const *s2); +char *ft_strjoin3(char const *s1, char const *s2, char const *s3); +char *ft_strjoinf(char const *s1, char const *s2, t_ftstrjoinf_tag tag); +char *ft_strtrim(char const *s1, char const *set); +char **ft_split(char const *s, char c); +int ft_strcount(char *str, char c); +char *ft_itoa(int n); +int ft_atoi_strict(const char *s); +long ft_strtol(const char *s, char **endptr, int base); +int ft_strcasecmp(const char *s1, const char *s2); +int ft_strncasecmp(const char *s1, const char *s2, size_t n); +size_t ft_strspn(const char *s, const char *charset); +size_t ft_strcspn(const char *s, const char *charset); +char *ft_strpbrk(const char *s, const char *charset); +char *ft_strsep(char **stringp, const char *delim); +size_t ft_strnlen(const char *s, size_t maxlen); +char *ft_strmap(char const *s, char (*f)(char)); +char *ft_strmapi(char *s, char (*f)(unsigned int, char)); +int ft_strequ(char const *s1, char const *s2); +int ft_strnequ(char const *s1, char const *s2, size_t n); +char *ft_strtolower(char *s); +char *ft_strtoupper(char *s); + +/* +** bloat ? +*/ + +/* +** char *ft_strnew(size_t size); +** void ft_strdel(char **as); +** void ft_strclr(char *s); +*/ + +#endif diff --git a/test_mini/libft/include/libft_types.h b/test_mini/libft/include/libft_types.h new file mode 100644 index 0000000..3987a80 --- /dev/null +++ b/test_mini/libft/include/libft_types.h @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_types.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:36:56 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:10:02 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_TYPES_H +# define LIBFT_TYPES_H + +# define TRUE 1 +# define FALSE 0 + +typedef unsigned char t_ftbyte; +typedef int t_ftbool; +typedef unsigned int t_ftsize; + +typedef char t_ftchar; +typedef unsigned char t_ftuchar; +typedef int t_ftint; +typedef unsigned int t_ftuint; +typedef long int t_ftlong; +typedef unsigned long int t_ftulong; + +#endif diff --git a/test_mini/libft/include/libft_util.h b/test_mini/libft/include/libft_util.h new file mode 100644 index 0000000..7a9e056 --- /dev/null +++ b/test_mini/libft/include/libft_util.h @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_util.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/27 17:51:36 by cacharle #+# #+# */ +/* Updated: 2020/02/27 17:52:16 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_UTIL_H +# define LIBFT_UTIL_H + +# include <stdlib.h> + +void *ft_split_destroy(char **strs); + +#endif diff --git a/test_mini/libft/include/libft_vec.h b/test_mini/libft/include/libft_vec.h new file mode 100644 index 0000000..f9199ba --- /dev/null +++ b/test_mini/libft/include/libft_vec.h @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* libft_vec.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 18:57:16 by charles #+# #+# */ +/* Updated: 2020/04/01 22:53:33 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef LIBFT_VEC_H +# define LIBFT_VEC_H + +/* +** \file libft_vec.h +** \brief Vector manipulation +*/ + +# include <stdlib.h> +# include <stddef.h> +# include "libft_mem.h" + +/* +** \brief Vector struct +** \param data Underlying array +** \param capacity Size of the underlying array +** \param size Number of element in the vector +*/ + +typedef struct s_ftvec +{ + void **data; + size_t capacity; + size_t size; +} t_ftvec; + +t_ftvec *ft_vecnew(size_t capacity); +void ft_vecdestroy(t_ftvec *vec, void (*del)(void *elem)); +t_ftvec *ft_vecgrow(t_ftvec *vec); +t_ftvec *ft_vecpush(t_ftvec *vec, void *pushed); +void ft_vecpop(t_ftvec *vec, void (*del)(void *elem)); +void ft_veciter(t_ftvec *vec, void (*f)(void *elem)); +void ft_vecremove(t_ftvec *vec, size_t i, void (*del)(void *elem)); + +#endif diff --git a/test_mini/libft/script/find_src.sh b/test_mini/libft/script/find_src.sh new file mode 100755 index 0000000..511642b --- /dev/null +++ b/test_mini/libft/script/find_src.sh @@ -0,0 +1,20 @@ +#!bin/sh + +if [ $# -ne 1 ]; then + echo "Usage $0 ignore_file" + exit 1 +fi + +IGNORE_FILE=$1 + +if [ ! -e $IGNORE_FILE ]; then + echo "Ignore file doesnt exist" + exit 1 +fi + +SRC_DIR=src + +IGNORE_FIND_ARGS=`sed 's/.*/-not -path "&"/' $IGNORE_FILE | paste -sd " " -` + +sh -c "find $SRC_DIR $IGNORE_FIND_ARGS -name \"*.c\"" +# find $SRC_DIR $IGNORE_FIND_ARGS -name "*.c" diff --git a/test_mini/libft/script/generate_boilerplate_test.sh b/test_mini/libft/script/generate_boilerplate_test.sh new file mode 100755 index 0000000..ef6a2cf --- /dev/null +++ b/test_mini/libft/script/generate_boilerplate_test.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +for f in $@ +do + test_name="test_`basename $f | sed 's/\..*//'`" + + + echo $test_name +done diff --git a/test_mini/libft/script/generate_rendu.sh b/test_mini/libft/script/generate_rendu.sh new file mode 100755 index 0000000..1b68a97 --- /dev/null +++ b/test_mini/libft/script/generate_rendu.sh @@ -0,0 +1,26 @@ +#!/bin/sh + +if [ "$(git status --porcelain)" ] +then + echo "Error: Your working directory isn't clean" + exit +fi + +BASE_BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD) +RENDU_BRANCH_NAME="rendu-$BASE_BRANCH_NAME" + +if [ -z $(git show-ref --verify --quiet refs/heads/$RENDU_BRANCH_NAME) ] +then + echo "Error: $RENDU_BRANCH_NAME was already generated" + exit +fi + +git checkout -b $RENDU_BRANCH_NAME +RENDU_IGNORE=$(sed -n 's/RENDU_IGNORE=//p') +make fclean +rm -f $RENDU_IGNORE + +# generate makefile strict src + +git add . +git commit --message "Generated commit: creation of rendu for $BASE_BRANCH_NAME" diff --git a/test_mini/libft/script/generate_rendu_makefile.sh b/test_mini/libft/script/generate_rendu_makefile.sh new file mode 100644 index 0000000..00a9e81 --- /dev/null +++ b/test_mini/libft/script/generate_rendu_makefile.sh @@ -0,0 +1,5 @@ +#!bin/sh + +SRC=`sh script/find_src.sh .libftignore` + +sed 's:\#INSERTSRC:'$SRC':g' template.makefile > rendu.makefile diff --git a/test_mini/libft/script/template.makefile b/test_mini/libft/script/template.makefile new file mode 100644 index 0000000..b0902ec --- /dev/null +++ b/test_mini/libft/script/template.makefile @@ -0,0 +1,38 @@ +# **************************************************************************** # +# # +# ::: :::::::: # +# Makefile :+: :+: :+: # +# +:+ +:+ +:+ # +# By: cacharle <marvin@42.fr> +#+ +:+ +#+ # +# +#+#+#+#+#+ +#+ # +# Created: 2019/10/08 15:45:53 by cacharle #+# #+# # +# Updated: 2020/01/31 06:51:18 by cacharle ### ########.fr # +# # +# **************************************************************************** # + +RM = rm -f +LIB = ar rcs + +CC = gcc +CCFLAGS = -Iinclude -Wall -Wextra -Werror + +#INSERTSRC + +OBJ = $(SRC:.c=.o) +NAME = libft.a + +all: $(NAME) + +$(NAME): $(OBJ) + $(LIB) $@ $(OBJ) + +%.o: %.c + $(CC) $(CCFLAGS) -c -o $@ $< + +clean: + $(RM) -r $(OBJ_DIR) + +fclean: clean + $(RM) $(NAME) + +re: fclean all diff --git a/test_mini/libft/script/test.sh b/test_mini/libft/script/test.sh new file mode 100644 index 0000000..50a17c9 --- /dev/null +++ b/test_mini/libft/script/test.sh @@ -0,0 +1,14 @@ +#include "libft_test.h" + +TEST_GROUP(test.sh); + +TEST_SETUP(test.sh); +{} + +TEST_TEAR_DOWN(test.sh); +{} + +TEST(test.sh, basic) +{ + +} diff --git a/test_mini/libft/src/algo/ft_bsearch.c b/test_mini/libft/src/algo/ft_bsearch.c new file mode 100644 index 0000000..5132fa2 --- /dev/null +++ b/test_mini/libft/src/algo/ft_bsearch.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_bsearch.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 05:29:05 by cacharle #+# #+# */ +/* Updated: 2020/02/13 23:14:48 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +void *ft_bsearch(const void *base, size_t nel, size_t width, + t_ftsearch_const *consts) +{ + int res; + size_t mid; + + if (nel < 1) + return (NULL); + mid = nel / 2; + res = (consts->compar)(consts->key, base + mid * width); + if (res == 0) + return ((void*)base + mid * width); + if (res < 0) + return (ft_bsearch(base, mid, width, consts)); + else + return (ft_bsearch(base + (mid + 1) * width, nel - mid - 1, + width, consts)); +} diff --git a/test_mini/libft/src/algo/ft_compar_int.c b/test_mini/libft/src/algo/ft_compar_int.c new file mode 100644 index 0000000..848dc71 --- /dev/null +++ b/test_mini/libft/src/algo/ft_compar_int.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_compar_int.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/19 08:24:43 by cacharle #+# #+# */ +/* Updated: 2020/01/19 08:27:38 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_compar_int(const void *a, const void *b) +{ + return (*(int*)a - *(int*)b); +} diff --git a/test_mini/libft/src/algo/ft_heapsort.c b/test_mini/libft/src/algo/ft_heapsort.c new file mode 100644 index 0000000..d309624 --- /dev/null +++ b/test_mini/libft/src/algo/ft_heapsort.c @@ -0,0 +1,54 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_heapsort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 02:59:22 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:22:19 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +/* static void st_build_max_heap(void *base, size_t nel, size_t width, */ +/* int (*compar)(const void *, const void *)) */ +/* { */ +/* int i; */ +/* */ +/* i = 1; */ +/* while (i < nel) */ +/* { */ +/* compar(base + i * width, base + 2 * i * width) */ +/* */ +/* i++; */ +/* } */ +/* } */ +/* */ +/* static void st_heapify(void *base, size_t nel, size_t width, */ +/* int (*compar)(const void *, const void *)) */ +/* { */ +/* */ +/* } */ + +int ft_heapsort(void *base, size_t nel, size_t width, + int (*compar)(const void *, const void *)) +{ + (void)base; + (void)nel; + (void)width; + (void)compar; + /* size_t i; */ + /* */ + /* if (nel < 2) */ + /* return (0); */ + /* st_build_max_heap(base, nel, width, compar); */ + /* i = -1; */ + /* while (++i < nel) */ + /* { */ + /* ft_memswap(base, base + (nel - i - 1) * width); */ + /* st_heapify(base, nel - i - 1, width, compar); */ + /* } */ + return (0); +} diff --git a/test_mini/libft/src/algo/ft_is_set.c b/test_mini/libft/src/algo/ft_is_set.c new file mode 100644 index 0000000..3e7ae31 --- /dev/null +++ b/test_mini/libft/src/algo/ft_is_set.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_is_set.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/19 07:17:15 by cacharle #+# #+# */ +/* Updated: 2020/02/10 02:51:41 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_algo.h" + +t_ftbool ft_is_set(void *base, size_t nel, size_t width, + t_ftcompar_func compar) +{ + size_t i; + + if (nel < 2) + return (TRUE); + ft_qsort(base, nel, width, compar); + i = 0; + while (i < nel - 1) + { + if (compar(base + (i * width), base + ((i + 1) * width)) == 0) + return (FALSE); + i++; + } + return (TRUE); +} diff --git a/test_mini/libft/src/algo/ft_lfind.c b/test_mini/libft/src/algo/ft_lfind.c new file mode 100644 index 0000000..8538f50 --- /dev/null +++ b/test_mini/libft/src/algo/ft_lfind.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lfind.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 05:49:19 by cacharle #+# #+# */ +/* Updated: 2020/02/10 05:58:19 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +void *ft_lfind(const void *base, size_t *nelp, size_t width, + t_ftsearch_const *consts) +{ + size_t i; + + i = 0; + while (i < *nelp) + { + if ((consts->compar)(consts->key, base + i * width) == 0) + return ((void*)base + i * width); + i++; + } + return (NULL); +} diff --git a/test_mini/libft/src/algo/ft_lsearch.c b/test_mini/libft/src/algo/ft_lsearch.c new file mode 100644 index 0000000..4c77bca --- /dev/null +++ b/test_mini/libft/src/algo/ft_lsearch.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lsearch.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 05:53:57 by cacharle #+# #+# */ +/* Updated: 2020/02/10 05:59:33 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +void *ft_lsearch(const void *base, size_t *nelp, size_t width, + t_ftsearch_const *consts) +{ + void *found; + + if ((found = ft_lfind(base, nelp, width, consts)) != NULL) + return (found); + return (ft_memcpy((void*)base + (*nelp)++ * width, consts->key, width)); +} diff --git a/test_mini/libft/src/algo/ft_mergesort.c b/test_mini/libft/src/algo/ft_mergesort.c new file mode 100644 index 0000000..25b4255 --- /dev/null +++ b/test_mini/libft/src/algo/ft_mergesort.c @@ -0,0 +1,76 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_mergesort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 02:26:41 by cacharle #+# #+# */ +/* Updated: 2020/02/13 23:14:21 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +static int st_mergesort_error(void *left, void *right) +{ + free(left); + free(right); + return (-1); +} + +static void st_merge_sorted(struct s_merge_sorted_arrays *arrays, size_t nel, + size_t width, int (*compar)(const void *, const void *)) +{ + size_t bi; + size_t li; + size_t ri; + size_t mid; + + mid = nel / 2; + bi = 0; + li = 0; + ri = 0; + while (li < mid && ri < nel - mid) + { + if (compar(arrays->left + li * width, arrays->right + ri * width) < 0) + ft_memcpy(arrays->base + bi * width, + arrays->left + li++ * width, width); + else + ft_memcpy(arrays->base + bi * width, + arrays->right + ri++ * width, width); + bi++; + } + while (li < mid) + ft_memcpy(arrays->base + bi++ * width, + arrays->left + li++ * width, width); + while (ri < nel - mid) + ft_memcpy(arrays->base + bi++ * width, + arrays->right + ri++ * width, width); +} + +int ft_mergesort(void *base, size_t nel, size_t width, + int (*compar)(const void *, const void *)) +{ + size_t mid; + struct s_merge_sorted_arrays arrays; + + if (nel < 2) + return (0); + mid = nel / 2; + if ((arrays.left = malloc(mid * width)) == NULL) + return (-1); + if ((arrays.right = malloc((nel - mid) * width)) == NULL) + return (st_mergesort_error(arrays.left, NULL)); + ft_memcpy(arrays.left, base, mid * width); + ft_memcpy(arrays.right, base + mid * width, (nel - mid) * width); + if (ft_mergesort(arrays.left, mid, width, compar) == -1) + return (st_mergesort_error(arrays.left, arrays.right)); + if (ft_mergesort(arrays.right, nel - mid, width, compar) == -1) + return (st_mergesort_error(arrays.left, arrays.right)); + arrays.base = base; + st_merge_sorted(&arrays, nel, width, compar); + free(arrays.left); + free(arrays.right); + return (0); +} diff --git a/test_mini/libft/src/algo/ft_qsort.c b/test_mini/libft/src/algo/ft_qsort.c new file mode 100644 index 0000000..9bcfcdf --- /dev/null +++ b/test_mini/libft/src/algo/ft_qsort.c @@ -0,0 +1,64 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_qsort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/19 07:25:51 by cacharle #+# #+# */ +/* Updated: 2020/02/10 02:55:14 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +static t_ftrange ft_range_new(int lo, int hi) +{ + t_ftrange range; + + range.lo = lo; + range.hi = hi; + return (range); +} + +static int ft_qsort_partition(void *base, t_ftrange range, + size_t width, t_ftcompar_func compar) +{ + void *pivot; + int p; + int i; + + pivot = base + (range.hi * width); + p = range.lo; + i = range.lo - 1; + while (++i < range.hi) + { + if (compar(base + (i * width), pivot) < 0) + { + ft_memswap(base + (i * width), base + (p * width), width); + p++; + } + } + ft_memswap(pivot, base + (p * width), width); + return (p); +} + +static void ft_qsort_rec(void *base, t_ftrange range, + size_t width, t_ftcompar_func compar) +{ + int pivot; + + if (range.lo >= range.hi) + return ; + pivot = ft_qsort_partition(base, range, width, compar); + ft_qsort_rec(base, ft_range_new(range.lo, pivot - 1), width, compar); + ft_qsort_rec(base, ft_range_new(pivot + 1, range.hi), width, compar); +} + +void ft_qsort(void *base, size_t nel, size_t width, + t_ftcompar_func compar) +{ + if (width == 0 || nel < 2) + return ; + ft_qsort_rec(base, ft_range_new(0, nel - 1), width, compar); +} diff --git a/test_mini/libft/src/algo/ft_reverse.c b/test_mini/libft/src/algo/ft_reverse.c new file mode 100644 index 0000000..0bc447f --- /dev/null +++ b/test_mini/libft/src/algo/ft_reverse.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_reverse.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 05:07:13 by cacharle #+# #+# */ +/* Updated: 2020/02/10 05:19:22 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_algo.h" + +void ft_reverse(void *base, size_t nel, size_t width) +{ + size_t i; + + i = 0; + nel--; + while (i < nel) + { + ft_memswap(base + i * width, base + nel * width, width); + i++; + nel--; + } +} diff --git a/test_mini/libft/src/bt/ft_btdestroy.c b/test_mini/libft/src/bt/ft_btdestroy.c new file mode 100644 index 0000000..c802db0 --- /dev/null +++ b/test_mini/libft/src/bt/ft_btdestroy.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_btdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/07 21:30:53 by cacharle #+# #+# */ +/* Updated: 2020/02/07 21:35:19 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_bt.h" + +void ft_btdestroy(t_ftbtree *tree, void (*del)(void *data)) +{ + if (tree == NULL) + return ; + ft_btdestroy(tree->left, del); + ft_btdestroy(tree->right, del); + (*del)(tree->data); + free(tree); +} diff --git a/test_mini/libft/src/bt/ft_btnew.c b/test_mini/libft/src/bt/ft_btnew.c new file mode 100644 index 0000000..973e1a4 --- /dev/null +++ b/test_mini/libft/src/bt/ft_btnew.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_btnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/07 21:33:16 by cacharle #+# #+# */ +/* Updated: 2020/02/07 21:34:35 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_bt.h" + +t_ftbtree *ft_btnew(void *data) +{ + t_ftbtree *tree; + + if ((tree = (t_ftbtree*)malloc(sizeof(t_ftbtree))) == NULL) + return (NULL); + tree->data = data; + tree->left = NULL; + tree->right = NULL; + return (tree); +} diff --git a/test_mini/libft/src/ctype/ft_isalnum.c b/test_mini/libft/src/ctype/ft_isalnum.c new file mode 100644 index 0000000..1ee1e0f --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isalnum.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isalnum.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:41:40 by cacharle #+# #+# */ +/* Updated: 2019/10/07 09:41:56 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isalnum(int c) +{ + return (ft_isalpha(c) || ft_isdigit(c)); +} diff --git a/test_mini/libft/src/ctype/ft_isalpha.c b/test_mini/libft/src/ctype/ft_isalpha.c new file mode 100644 index 0000000..6f155b4 --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isalpha.c @@ -0,0 +1,16 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isalpha.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:54:52 by cacharle #+# #+# */ +/* Updated: 2019/10/20 13:01:13 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +int ft_isalpha(int c) +{ + return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); +} diff --git a/test_mini/libft/src/ctype/ft_isascii.c b/test_mini/libft/src/ctype/ft_isascii.c new file mode 100644 index 0000000..12b6849 --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isascii.c @@ -0,0 +1,16 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isascii.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:54:30 by cacharle #+# #+# */ +/* Updated: 2020/02/12 23:01:02 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +int ft_isascii(int c) +{ + return (c >= 00 && c <= 0177); +} diff --git a/test_mini/libft/src/ctype/ft_isblank.c b/test_mini/libft/src/ctype/ft_isblank.c new file mode 100644 index 0000000..def106b --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isblank.c @@ -0,0 +1,16 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isblank.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 05:17:45 by cacharle #+# #+# */ +/* Updated: 2020/02/10 05:18:34 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +int ft_isblank(int c) +{ + return (c == ' ' || c == '\t'); +} diff --git a/test_mini/libft/src/ctype/ft_isdigit.c b/test_mini/libft/src/ctype/ft_isdigit.c new file mode 100644 index 0000000..f8a5850 --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isdigit.c @@ -0,0 +1,16 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isdigit.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:41:20 by cacharle #+# #+# */ +/* Updated: 2019/10/07 10:41:25 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +int ft_isdigit(int c) +{ + return (c >= '0' && c <= '9'); +} diff --git a/test_mini/libft/src/ctype/ft_isprint.c b/test_mini/libft/src/ctype/ft_isprint.c new file mode 100644 index 0000000..c311709 --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isprint.c @@ -0,0 +1,16 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isprint.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:52:09 by cacharle #+# #+# */ +/* Updated: 2019/10/20 13:03:36 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +int ft_isprint(int c) +{ + return (c >= ' ' && c <= '~'); +} diff --git a/test_mini/libft/src/ctype/ft_isspace.c b/test_mini/libft/src/ctype/ft_isspace.c new file mode 100644 index 0000000..18b6dba --- /dev/null +++ b/test_mini/libft/src/ctype/ft_isspace.c @@ -0,0 +1,19 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isspace.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/15 11:33:36 by cacharle #+# #+# */ +/* Updated: 2020/01/15 11:35:07 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isspace(int c) +{ + return (c == ' ' || c == '\t' || c == '\n' + || c == '\v' || c == '\f' || c == '\r'); +} diff --git a/test_mini/libft/src/ctype/ft_todigit.c b/test_mini/libft/src/ctype/ft_todigit.c new file mode 100644 index 0000000..f201470 --- /dev/null +++ b/test_mini/libft/src/ctype/ft_todigit.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_todigit.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/15 10:37:57 by cacharle #+# #+# */ +/* Updated: 2020/02/12 23:11:55 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_todigit(int c) +{ + if (!ft_isdigit(c)) + return (-1); + return (c & 0x0F); +} diff --git a/test_mini/libft/src/ctype/ft_tolower.c b/test_mini/libft/src/ctype/ft_tolower.c new file mode 100644 index 0000000..919469f --- /dev/null +++ b/test_mini/libft/src/ctype/ft_tolower.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_tolower.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:14:26 by cacharle #+# #+# */ +/* Updated: 2019/11/20 01:04:02 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** E: 0100 0101 +** e: 0110 0101 +** ^ +*/ + +int ft_tolower(int c) +{ + if (c >= 'A' && c <= 'Z') + return (c | 0b00100000); + return (c); +} diff --git a/test_mini/libft/src/ctype/ft_toupper.c b/test_mini/libft/src/ctype/ft_toupper.c new file mode 100644 index 0000000..8579b91 --- /dev/null +++ b/test_mini/libft/src/ctype/ft_toupper.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_toupper.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:14:10 by cacharle #+# #+# */ +/* Updated: 2019/11/20 01:04:51 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_toupper(int c) +{ + if (c >= 'a' && c <= 'z') + return (c ^ 0b00100000); + return (c); +} diff --git a/test_mini/libft/src/ht/ft_htdelone.c b/test_mini/libft/src/ht/ft_htdelone.c new file mode 100644 index 0000000..7374a44 --- /dev/null +++ b/test_mini/libft/src/ht/ft_htdelone.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 09:27:18 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:10:16 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** \brief Delete one hash table entry +** \param key Key of entry to delete +** \param del Function to destroy the entry +** \warning The del function HAS to free the key +** \note Do nothing if their is to entry which correspond to key +*/ + +void ft_htdelone(t_ftht *ht, char *key, void (*del)(t_ftht_entry*)) +{ + ft_lstremove_if(ht->buckets + ft_hthash(ht, key), + ft_inter_htkey_cmp, key, + (void (*)(void*))del); +} diff --git a/test_mini/libft/src/ht/ft_htdestroy.c b/test_mini/libft/src/ht/ft_htdestroy.c new file mode 100644 index 0000000..ff362d2 --- /dev/null +++ b/test_mini/libft/src/ht/ft_htdestroy.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 08:31:02 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:10:31 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** \brief Destroy an hash table. +** \param del Function to delete each entry +** \warning The del function HAS to free the key +*/ + +void ft_htdestroy(t_ftht *ht, void (*del)(t_ftht_entry*)) +{ + if (ht == NULL) + return ; + while (ht->size-- > 0) + ft_lstdestroy(ht->buckets + ht->size, (void (*)(void*))del); + free(ht->buckets); + free(ht); +} diff --git a/test_mini/libft/src/ht/ft_htentry_new.c b/test_mini/libft/src/ht/ft_htentry_new.c new file mode 100644 index 0000000..12a1159 --- /dev/null +++ b/test_mini/libft/src/ht/ft_htentry_new.c @@ -0,0 +1,37 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htentry_new.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 08:45:36 by cacharle #+# #+# */ +/* Updated: 2020/02/17 04:09:50 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** \brief Create a new hash table key/value pair. +** \param key Hash entry string key (always duplicated) +** \return Content or NULL if an allocation failed. +*/ + +t_ftht_entry *ft_htentry_new(char *key, void *value) +{ + t_ftht_entry *content; + + if (key == NULL) + return (NULL); + if ((content = (t_ftht_entry*)malloc(sizeof(t_ftht_entry))) == NULL) + return (NULL); + if ((content->key = ft_strdup(key)) == NULL) + { + free(content); + return (NULL); + } + content->value = value; + return (content); +} diff --git a/test_mini/libft/src/ht/ft_htget.c b/test_mini/libft/src/ht/ft_htget.c new file mode 100644 index 0000000..a6383fe --- /dev/null +++ b/test_mini/libft/src/ht/ft_htget.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htget.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 08:33:21 by cacharle #+# #+# */ +/* Updated: 2020/04/01 18:02:57 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** \brief Retrieve a value with a key +** \param ht Hash table where key is searched +** \param key Searched key +** \return Value void pointer at key or NULL if not found +*/ + +void *ft_htget(t_ftht *ht, char *key) +{ + t_ftht_digest digest; + t_ftlst *found; + + if (ht == NULL || key == NULL) + return (NULL); + digest = ft_hthash(ht, key); + found = ft_lstlfind(ht->buckets[digest], ft_inter_htkey_cmp, key); + if (found == NULL) + return (NULL); + return (((t_ftht_entry*)found->data)->value); +} diff --git a/test_mini/libft/src/ht/ft_hthash.c b/test_mini/libft/src/ht/ft_hthash.c new file mode 100644 index 0000000..3369d24 --- /dev/null +++ b/test_mini/libft/src/ht/ft_hthash.c @@ -0,0 +1,36 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_hthash.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 09:56:01 by cacharle #+# #+# */ +/* Updated: 2020/01/30 10:34:27 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_ht.h" + +/* +** \brief Hash a string +** \param ht So that the index is in the hash table bound +** \param key String to hash +** \return Hash +*/ + +// maybe use a less efficient but understandable function +t_ftht_digest ft_hthash(t_ftht *ht, char *key) +{ + t_ftht_digest digest; + + if (*key == '\0') + return (0); + digest = *key++ << 7; + while (*key != '\0') + { + digest = ((1000003 * digest) ^ *key) & (1 << 16); + key++; + } + return (digest % ht->size); +} diff --git a/test_mini/libft/src/ht/ft_htiter.c b/test_mini/libft/src/ht/ft_htiter.c new file mode 100644 index 0000000..b854993 --- /dev/null +++ b/test_mini/libft/src/ht/ft_htiter.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htiter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 18:02:24 by charles #+# #+# */ +/* Updated: 2020/04/01 18:02:32 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_ht.h" + +/* +** \brief Iterate over entry of hash table +** \param ht Iterated hash table +** \param f Function applied to each entry +*/ + +void ft_htiter(t_ftht *ht, void (*f)(t_ftht_entry*)) +{ + size_t i; + + i = 0; + while (i < ht->size) + { + ft_lstiter(ht->buckets[i], (void (*)(void*))f); + i++; + } +} diff --git a/test_mini/libft/src/ht/ft_htnew.c b/test_mini/libft/src/ht/ft_htnew.c new file mode 100644 index 0000000..e5335d2 --- /dev/null +++ b/test_mini/libft/src/ht/ft_htnew.c @@ -0,0 +1,38 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 08:19:16 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:23:43 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** \brief Create a new hash table. +** \param size Size of the underlying array of linked list (buckets) +** \return Created hash table or NULL is an allocation failed +*/ + +t_ftht *ft_htnew(t_ftsize size) +{ + t_ftht *ht; + + if (size == 0) + return (NULL); + if ((ht = (t_ftht*)malloc(sizeof(t_ftht))) == NULL) + return (NULL); + ht->buckets = (t_ftht_bucket*)ft_calloc(size, sizeof(t_ftht_entry)); + if (ht->buckets == NULL) + { + free(ht); + return (NULL); + } + ht->size = size; + return (ht); +} diff --git a/test_mini/libft/src/ht/ft_htset.c b/test_mini/libft/src/ht/ft_htset.c new file mode 100644 index 0000000..68d3752 --- /dev/null +++ b/test_mini/libft/src/ht/ft_htset.c @@ -0,0 +1,56 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_htset.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 08:41:52 by cacharle #+# #+# */ +/* Updated: 2020/04/01 18:02:12 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** \brief Create/Update a entry in hash table. +** \note If `key` already exist in `ht` +** only updates the list node content. +** Else create a new list node in addition the list content. +** \param ht Hash table where the entry is modified +** \param key Key of the new entry +** \param value Value of the new entry +** \param del Destroy function in case the entry is modified. +** \return Pointer to the created entry, NULL if an allocation failed. +*/ + +t_ftht_entry *ft_htset(t_ftht *ht, char *key, void *value, + void (*del)(t_ftht_entry*)) +{ + t_ftht_digest digest; + t_ftht_entry *content; + t_ftht_bucket bucket; + t_ftlst *tmp; + + if (ht == NULL || key == NULL) + return (NULL); + if ((content = ft_htentry_new(key, value)) == NULL) + return (NULL); + digest = ft_hthash(ht, key); + tmp = ft_lstlfind(ht->buckets[digest], ft_inter_htkey_cmp, key); + if (tmp != NULL) + { + if (del != NULL) + del(tmp->data); + tmp->data = content; + return ((t_ftht_entry*)tmp->data); + } + if ((bucket = ft_lstnew(content)) == NULL) + { + del(content); + return (NULL); + } + ft_lstpush_front(ht->buckets + digest, bucket); + return (content); +} diff --git a/test_mini/libft/src/ht/ft_inter_htkey_cmp.c b/test_mini/libft/src/ht/ft_inter_htkey_cmp.c new file mode 100644 index 0000000..e8a0375 --- /dev/null +++ b/test_mini/libft/src/ht/ft_inter_htkey_cmp.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_internal_htkey_equal.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 09:24:39 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:20:43 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_ht.h" + +/* +** Hash table internal function to compare key string in linked list. +*/ + +int ft_inter_htkey_cmp(const void *ref_key, const void *content) +{ + if (ref_key == NULL || content == NULL) + return (-1); + return (ft_strcmp((char*)ref_key, ((t_ftht_entry*)content)->key)); +} diff --git a/test_mini/libft/src/io/ft_getchar.c b/test_mini/libft/src/io/ft_getchar.c new file mode 100644 index 0000000..9d233c0 --- /dev/null +++ b/test_mini/libft/src/io/ft_getchar.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_getchar.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/18 10:29:54 by cacharle #+# #+# */ +/* Updated: 2020/02/14 02:24:56 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char ft_getchar(void) +{ + char c; + + if (read(STDIN_FILENO, &c, 1) < 0) + return (-1); + return (c); +} diff --git a/test_mini/libft/src/io/ft_next_line.c b/test_mini/libft/src/io/ft_next_line.c new file mode 100644 index 0000000..74afa71 --- /dev/null +++ b/test_mini/libft/src/io/ft_next_line.c @@ -0,0 +1,113 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_next_line.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/31 10:39:38 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:11:35 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +static int st_find_newline(char *str) +{ + int i; + + i = -1; + while (str[++i]) + if (str[i] == '\n') + return (i); + return (-1); +} + +static int st_free_return(char **ptr, char **ptr2, int ret) +{ + if (ptr != NULL) + { + free(*ptr); + *ptr = NULL; + } + if (ptr2 != NULL) + { + free(*ptr2); + *ptr2 = NULL; + } + return (ret); +} + +static int st_read_line(int fd, char **line, char *rest) +{ + int ret; + int split_at; + char *buf; + + if ((buf = malloc(sizeof(char) * (FTNL_BUFFER_SIZE + 1))) == NULL) + return (st_free_return(line, NULL, FTNL_STATUS_ERROR)); + while ((ret = read(fd, buf, FTNL_BUFFER_SIZE)) > 0) + { + buf[ret] = '\0'; + if ((split_at = st_find_newline(buf)) != -1) + { + ft_strcpy(rest, buf + split_at + 1); + buf[split_at] = '\0'; + if ((*line = ft_strjoinf(*line, buf, FT_STRJOINF_FST)) == NULL) + return (st_free_return(&buf, NULL, FTNL_STATUS_ERROR)); + return (st_free_return(&buf, NULL, FTNL_STATUS_LINE)); + } + if ((*line = ft_strjoinf(*line, buf, FT_STRJOINF_FST)) == NULL) + return (st_free_return(&buf, NULL, FTNL_STATUS_ERROR)); + } + if (ret == -1) + return (st_free_return(&buf, line, FTNL_STATUS_ERROR)); + return (st_free_return(&buf, NULL, ret)); +} + +/* +** if has rest: +** if rest has newline: +** push rest until newline in line, shift rest +** return LINE_READ +** else: +** push rest in line +** +** while can read fd in buf +** if buf has newline: +** push buf until newline in line +** push buf after newline in rest +** return LINE_READ +** push buf in line +** +** return FTNL_EOF +*/ + +int ft_next_line(int fd, char **line) +{ + int split_at; + static char rest[OPEN_MAX][FTNL_BUFFER_SIZE + 1] = {{0}}; + + if (fd < 0 || fd > OPEN_MAX || line == NULL || FTNL_BUFFER_SIZE <= 0) + return (FTNL_STATUS_ERROR); + if ((*line = ft_strdup("")) == NULL) + return (FTNL_STATUS_ERROR); + if (rest[fd][0] == '\0') + return (st_read_line(fd, line, rest[fd])); + if ((split_at = st_find_newline(rest[fd])) != -1) + { + free(*line); + if ((*line = (char*)malloc(sizeof(char) * (split_at + 1))) == NULL) + return (FTNL_STATUS_ERROR); + ft_strncpy(*line, rest[fd], split_at); + (*line)[split_at] = '\0'; + ft_strcpy(rest[fd], rest[fd] + split_at + 1); + return (FTNL_STATUS_LINE); + } + free(*line); + if (!(*line = (char*)malloc(sizeof(char) * (ft_strlen(rest[fd]) + 1)))) + return (FTNL_STATUS_ERROR); + ft_strcpy(*line, rest[fd]); + rest[fd][0] = '\0'; + return (st_read_line(fd, line, rest[fd])); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_asprintf.c b/test_mini/libft/src/io/ft_printf/ft_asprintf.c new file mode 100644 index 0000000..5eb62d9 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_asprintf.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_asprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:30:33 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:43:08 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_asprintf(char **ret, const char *format, ...) +{ + int vret; + va_list ap; + + va_start(ap, format); + vret = ft_vasprintf(ret, format, ap); + va_end(ap); + return (vret); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_dprintf.c b/test_mini/libft/src/io/ft_printf/ft_dprintf.c new file mode 100644 index 0000000..8e60970 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_dprintf.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_dprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:29:11 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:42:05 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_dprintf(int fd, const char *format, ...) +{ + int ret; + va_list ap; + + va_start(ap, format); + ret = ft_vdprintf(fd, format, ap); + va_end(ap); + return (ret); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_printf.c b/test_mini/libft/src/io/ft_printf/ft_printf.c new file mode 100644 index 0000000..1b92bb2 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_printf.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_printf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:31:32 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:41:54 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_printf(const char *format, ...) +{ + int ret; + va_list ap; + + va_start(ap, format); + ret = ft_vprintf(format, ap); + va_end(ap); + return (ret); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_snprintf.c b/test_mini/libft/src/io/ft_printf/ft_snprintf.c new file mode 100644 index 0000000..e1fdfbd --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_snprintf.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_snprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:27:55 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:41:49 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_snprintf(char *str, size_t size, const char *format, ...) +{ + int ret; + va_list ap; + + va_start(ap, format); + ret = ft_vsnprintf(str, size, format, ap); + va_end(ap); + return (ret); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_sprintf.c b/test_mini/libft/src/io/ft_printf/ft_sprintf.c new file mode 100644 index 0000000..31da75e --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_sprintf.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_sprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:17:21 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:42:28 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_sprintf(char *str, const char *format, ...) +{ + int ret; + va_list ap; + + va_start(ap, format); + ret = ft_vsprintf(str, format, ap); + va_end(ap); + return (ret); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_vasprintf.c b/test_mini/libft/src/io/ft_printf/ft_vasprintf.c new file mode 100644 index 0000000..85f66bc --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_vasprintf.c @@ -0,0 +1,21 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vasprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:49:56 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:45:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_vasprintf(char **ret, const char *format, va_list ap) +{ + (void)ret; + (void)format; + (void)ap; + return (0); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_vasprintf.h b/test_mini/libft/src/io/ft_printf/ft_vasprintf.h new file mode 100644 index 0000000..2d364c8 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_vasprintf.h @@ -0,0 +1,155 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* header.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/29 00:06:46 by cacharle #+# #+# */ +/* Updated: 2020/01/15 11:39:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef FT_VASPRINTF_H +# define FT_VASPRINTF_H + +# include <unistd.h> +# include <stdlib.h> +# include <stdarg.h> +# include "libft.h" + +# define STATUS_ERROR -1 + +# define SPECIFIERS_STR "nfcspdiuxX%" +# define FLAGS_STR "#0- +'" + +# define IS_STANDALONE_FLAG(c) (ft_strchr(FLAGS_STR, c) != NULL) + +# define FLAG_MINUS (1 << 0) +# define FLAG_ZERO (1 << 1) +# define FLAG_SIGNED (1 << 2) +# define FLAG_SPACE (1 << 3) +# define FLAG_ALTERNATE (1 << 4) +# define FLAG_SHORT (1 << 5) +# define FLAG_SHORT_SHORT (1 << 6) +# define FLAG_LONG (1 << 7) +# define FLAG_LONG_LONG (1 << 8) +# define FLAG_WIDTH_WILDCARD (1 << 9) +# define FLAG_PRECISION_WILDCARD (1 << 10) +# define FLAG_WIDTH_OVERWRITE (1 << 11) + +# define ITOA_HEX_LOW(x) (ft_itoa_unsigned_base(x, "0123456789abcdef")) +# define ITOA_HEX_UP(x) (ft_itoa_unsigned_base(x, "0123456789ABCDEF")) +# define ITOA_DEC(x) (ft_itoa_base(x, "0123456789")) + +typedef int t_bool; +typedef short t_flags; +typedef long long int t_big_int; +typedef long long unsigned int t_big_uint; + +typedef struct +{ + int precision; + int width; + t_flags flags; + char specifier; + int fmt_len; + int size; + long long int *written; +} t_pformat; + +typedef struct s_flist +{ + struct s_flist *next; + t_pformat *content; +} t_flist; + +typedef struct s_printf_status +{ + va_list ap; + t_flist *flist; + const char *format; + char *out; + int out_size; +} t_printf_status; + +/* +** ft_printf.c +*/ + +int ft_printf(const char *format, ...); +const char *add_conversion(t_printf_status *status, + t_pformat *pformat); +const char *add_between(t_printf_status *status); +int destroy_status_error(t_printf_status *status); + +/* +** parse.c +*/ + +int parse(const char *format, t_flist **flist); +t_pformat *parse_reduced(const char *fmt); + +/* +** printer.c +*/ + +char *convert(t_pformat *pformat, va_list ap); +char *convert_specifier(va_list ap, t_pformat *pformat); +char *handle_width(t_pformat *pformat, char *str); +char *handle_precision(t_pformat *pformat, char *str); + +/* +** utils.c +*/ + +char *ft_itoa_base(long long int n, char *base); +char *ft_itoa_unsigned_base(long long unsigned int n, + char *base); +void *ft_memjoin_free(void *dst, int dst_size, void *src, + int src_size); + +/* +** extract.c +*/ + +const char *extract_flags(t_pformat *pformat, const char *fmt); +const char *extract_width(t_pformat *pformat, const char *fmt); +const char *extract_precision(t_pformat *pformat, const char *fmt); +const char *extract_length_modifier(t_pformat *pformat, + const char *fmt); + +/* +** list.c +*/ + +t_flist *list_new(t_pformat *content); +void *list_destroy(t_flist **lst); +void list_push_front(t_flist **lst, t_flist *new); +void list_pop_front(t_flist **lst); +t_flist *list_reverse(t_flist *lst); + +/* +** convert_*.c +*/ + +char *convert_char(va_list ap, t_pformat *pformat); +char *convert_str(va_list ap, t_pformat *pformat); +char *convert_ptr(va_list ap, t_pformat *pformat); +char *convert_int(va_list ap, t_pformat *pformat); +char *convert_uint(va_list ap, t_pformat *pformat); +char *convert_hex(va_list ap, t_pformat *pformat); +char *convert_percent(va_list ap, t_pformat *pformat); +char *convert_written(va_list ap, t_pformat *pformat); +char *convert_double(va_list ap, t_pformat *pformat); +char *convert_none(va_list ap, t_pformat *pformat); + +/* +** length_modifier.c +*/ + +t_big_uint length_modifier_unsigned_int( + va_list ap, t_pformat *pformat); +t_big_int length_modifier_int(va_list ap, t_pformat *pformat); + +#endif diff --git a/test_mini/libft/src/io/ft_printf/ft_vdprintf.c b/test_mini/libft/src/io/ft_printf/ft_vdprintf.c new file mode 100644 index 0000000..a5e5ebf --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_vdprintf.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vdprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:40:03 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:46:00 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_vdprintf(int fd, const char *format, va_list ap) +{ + int out_len; + char *out; + + if ((out_len = ft_vasprintf(&out, format, ap)) == -1) + return (-1); + write(fd, out, out_len); + return (out_len); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_vprintf.c b/test_mini/libft/src/io/ft_printf/ft_vprintf.c new file mode 100644 index 0000000..b98670b --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_vprintf.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:32:44 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:44:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_vprintf(const char *format, va_list ap) +{ + return (ft_vdprintf(STDOUT_FILENO, format, ap)); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_vsnprintf.c b/test_mini/libft/src/io/ft_printf/ft_vsnprintf.c new file mode 100644 index 0000000..7db988c --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_vsnprintf.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vsnprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:36:32 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:45:14 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_vsnprintf(char *str, size_t size, const char *format, va_list ap) +{ + int ret; + int full_out_len; + char *full_out; + + full_out_len = ft_vasprintf(&full_out, format, ap); + ft_strncpy(str, full_out, size); + ret = MIN((size_t)full_out_len, size); + free(full_out); + return (ret); +} diff --git a/test_mini/libft/src/io/ft_printf/ft_vsprintf.c b/test_mini/libft/src/io/ft_printf/ft_vsprintf.c new file mode 100644 index 0000000..91b4815 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/ft_vsprintf.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vsprintf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/21 02:34:17 by cacharle #+# #+# */ +/* Updated: 2019/11/21 03:44:24 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_vsprintf(char *str, const char *format, va_list ap) +{ + return (ft_vsnprintf(str, INT_MAX + 1, format, ap)); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert.c b/test_mini/libft/src/io/ft_printf/internals/convert.c new file mode 100644 index 0000000..398c754 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert.c @@ -0,0 +1,122 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* printer.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/28 23:19:24 by cacharle #+# #+# */ +/* Updated: 2019/11/14 10:22:04 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include <unistd.h> +#include <stdlib.h> +#include <stdarg.h> +#include "libft.h" +#include "ft_vasprintf.h" + +char *convert(t_pformat *pformat, va_list ap) +{ + char *str; + + if (pformat == NULL) + return (NULL); + if (pformat->flags & FLAG_WIDTH_WILDCARD) + { + if (pformat->flags & FLAG_WIDTH_OVERWRITE) + (void)va_arg(ap, int); + else + pformat->width = va_arg(ap, int); + if (pformat->width < 0) + { + pformat->flags |= FLAG_MINUS; + pformat->width *= -1; + } + } + if (pformat->flags & FLAG_PRECISION_WILDCARD) + pformat->precision = va_arg(ap, int); + if ((str = convert_specifier(ap, pformat)) == NULL) + return (NULL); + return (str); +} + +char *convert_specifier(va_list ap, t_pformat *pformat) +{ + if (pformat->specifier == 'c') + return (convert_char(ap, pformat)); + if (pformat->specifier == 's') + return (convert_str(ap, pformat)); + if (pformat->specifier == 'p') + return (convert_ptr(ap, pformat)); + if (pformat->specifier == 'd' || pformat->specifier == 'i') + return (convert_int(ap, pformat)); + if (pformat->specifier == 'u') + return (convert_uint(ap, pformat)); + if (pformat->specifier == 'x') + return (convert_hex(ap, pformat)); + if (pformat->specifier == 'X') + return (convert_hex(ap, pformat)); + if (pformat->specifier == '%') + return (convert_percent(ap, pformat)); + if (pformat->specifier == 'n') + return (convert_written(ap, pformat)); + else + return (convert_none(ap, pformat)); + return (NULL); +} + +char *handle_width(t_pformat *pformat, char *str) +{ + char *tmp; + int len; + int i; + + if ((len = ft_strlen(str)) >= pformat->width) + return (str); + if ((tmp = (char*)malloc(sizeof(char) * (pformat->width + 1))) == NULL) + return (NULL); + if (pformat->flags & FLAG_MINUS) + { + i = len; + ft_strcpy(tmp, str); + while (i < pformat->width) + tmp[i++] = ' '; + tmp[i] = 0; + } + else + { + i = 0; + while (i <= pformat->width - len) + tmp[i++] = pformat->flags & FLAG_ZERO ? '0' : ' '; + ft_strcpy(tmp + i - 1, str); + } + free(str); + return (tmp); +} + +char *handle_precision(t_pformat *pformat, char *str) +{ + int len; + char *tmp; + + if (pformat == NULL || str == NULL) + return (NULL); + if (ft_strchr("diuxX", pformat->specifier) && pformat->precision >= 0) + pformat->flags &= ~FLAG_ZERO; + len = ft_strlen(str); + if (pformat->precision == 0 && str[0] == '0') + { + free(str); + return (ft_strdup("")); + } + if (!ft_strchr("diuxXp", pformat->specifier) || len >= pformat->precision) + return (str); + if ((tmp = (char*)malloc(sizeof(char) * (pformat->precision + 1))) == NULL) + return (NULL); + ft_strcpy(tmp + pformat->precision - len, str); + while (pformat->precision-- > len) + tmp[pformat->precision - len] = '0'; + free(str); + return (tmp); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_char.c b/test_mini/libft/src/io/ft_printf/internals/convert_char.c new file mode 100644 index 0000000..c5f3a93 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_char.c @@ -0,0 +1,53 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_char.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:22:29 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:44:42 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +static char *handle_width_char(t_pformat *pformat, char *str) +{ + char *tmp; + int i; + + pformat->size = 1; + if (1 >= pformat->width) + return (str); + if ((tmp = (char*)malloc(sizeof(char) * (pformat->width + 1))) == NULL) + return (NULL); + if (pformat->flags & FLAG_MINUS) + { + ft_memcpy(tmp, str, (i = 1) + 1); + while (i < pformat->width) + tmp[i++] = ' '; + tmp[i] = 0; + } + else + { + i = 0; + while (i <= pformat->width - 1) + tmp[i++] = pformat->flags & FLAG_ZERO ? '0' : ' '; + ft_memcpy(tmp + i - 1, str, 2); + } + free(str); + pformat->size = pformat->width; + return (tmp); +} + +char *convert_char(va_list ap, t_pformat *pformat) +{ + char *str; + + if ((str = ft_strnew(2)) == NULL) + return (NULL); + str[0] = va_arg(ap, int); + str[1] = '\0'; + return (handle_width_char(pformat, str)); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_hex.c b/test_mini/libft/src/io/ft_printf/internals/convert_hex.c new file mode 100644 index 0000000..0464dc7 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_hex.c @@ -0,0 +1,34 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_hex.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:23:06 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:58:59 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_hex(va_list ap, t_pformat *pformat) +{ + char *str; + long long unsigned int n; + + n = length_modifier_unsigned_int(ap, pformat); + str = pformat->specifier == 'x' ? ITOA_HEX_LOW(n) : ITOA_HEX_UP(n); + str = handle_precision(pformat, str); + if (pformat->flags & FLAG_ZERO) + { + if (pformat->flags & FLAG_ALTERNATE && n != 0) + pformat->width -= 2; + str = handle_width(pformat, str); + } + if (pformat->flags & FLAG_ALTERNATE && n != 0) + str = ft_strjoin_free_snd(pformat->specifier == 'X' ? "0X" : "0x", str); + if (!(pformat->flags & FLAG_ZERO)) + str = handle_width(pformat, str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_int.c b/test_mini/libft/src/io/ft_printf/internals/convert_int.c new file mode 100644 index 0000000..2345f76 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_int.c @@ -0,0 +1,40 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_int.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:29:53 by cacharle #+# #+# */ +/* Updated: 2019/11/06 00:00:09 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_int(va_list ap, t_pformat *pformat) +{ + int is_neg; + long long int n; + char *str; + + n = length_modifier_int(ap, pformat); + is_neg = n < 0; + str = ITOA_DEC(n); + if (is_neg) + ft_strcpy(str, str + 1); + str = handle_precision(pformat, str); + if (pformat->flags & FLAG_ZERO) + { + if (is_neg || pformat->flags & (FLAG_SIGNED | FLAG_SPACE)) + pformat->width--; + str = handle_width(pformat, str); + } + if (is_neg) + str = ft_strjoin_free_snd("-", str); + else if (pformat->flags & (FLAG_SIGNED | FLAG_SPACE)) + str = ft_strjoin_free_snd(pformat->flags & FLAG_SPACE ? " " : "+", str); + if (!(pformat->flags & FLAG_ZERO)) + str = handle_width(pformat, str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_none.c b/test_mini/libft/src/io/ft_printf/internals/convert_none.c new file mode 100644 index 0000000..358ef1b --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_none.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_none.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/04 19:30:25 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:44:13 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_none(va_list ap, t_pformat *pformat) +{ + char *str; + + (void)ap; + if ((str = ft_strdup("")) == NULL) + return (NULL); + str = handle_precision(pformat, str); + str = handle_width(pformat, str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_percent.c b/test_mini/libft/src/io/ft_printf/internals/convert_percent.c new file mode 100644 index 0000000..813bb77 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_percent.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_percent.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:23:27 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:44:07 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_percent(va_list ap, t_pformat *pformat) +{ + char *str; + + (void)ap; + str = ft_strdup("%"); + str = handle_width(pformat, str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_ptr.c b/test_mini/libft/src/io/ft_printf/internals/convert_ptr.c new file mode 100644 index 0000000..63babb9 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_ptr.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_ptr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:24:08 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:43:45 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_ptr(va_list ap, t_pformat *pformat) +{ + char *str; + + str = ITOA_HEX_LOW((long long unsigned int)va_arg(ap, void*)); + str = handle_precision(pformat, str); + if (!(pformat->flags & FLAG_ZERO)) + str = ft_strjoin_free_snd("0x", str); + if (pformat->flags & FLAG_ZERO) + pformat->width -= 2; + str = handle_width(pformat, str); + if (pformat->flags & FLAG_ZERO) + str = ft_strjoin_free_snd("0x", str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_str.c b/test_mini/libft/src/io/ft_printf/internals/convert_str.c new file mode 100644 index 0000000..7d51a5e --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_str.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_str.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:22:25 by cacharle #+# #+# */ +/* Updated: 2019/11/09 01:07:24 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_str(va_list ap, t_pformat *pformat) +{ + char *str; + + str = va_arg(ap, char*); + str = str == NULL ? ft_strdup("(null)") : ft_strdup(str); + if (pformat->precision >= 0 && pformat->precision < (int)ft_strlen(str)) + str[pformat->precision] = '\0'; + str = handle_width(pformat, str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_uint.c b/test_mini/libft/src/io/ft_printf/internals/convert_uint.c new file mode 100644 index 0000000..4207165 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_uint.c @@ -0,0 +1,34 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_uint.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:25:40 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:44:19 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_uint(va_list ap, t_pformat *pformat) +{ + char *str; + long long unsigned int n; + + if (pformat->flags & FLAG_SHORT) + n = (unsigned short)va_arg(ap, int); + else if (pformat->flags & FLAG_SHORT_SHORT) + n = (unsigned char)va_arg(ap, int); + else if (pformat->flags & FLAG_LONG) + n = va_arg(ap, long unsigned int); + else if (pformat->flags & FLAG_LONG_LONG) + n = va_arg(ap, long long unsigned int); + else + n = va_arg(ap, unsigned int); + str = ft_itoa_unsigned_base(n, "0123456789"); + str = handle_precision(pformat, str); + str = handle_width(pformat, str); + return (str); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/convert_written.c b/test_mini/libft/src/io/ft_printf/internals/convert_written.c new file mode 100644 index 0000000..4beeaef --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/convert_written.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* convert_written.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/30 23:38:28 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:59:24 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +char *convert_written(va_list ap, t_pformat *pformat) +{ + if (pformat->flags & FLAG_SHORT) + pformat->written = (long long int*)va_arg(ap, signed char*); + if (pformat->flags & FLAG_SHORT_SHORT) + pformat->written = (long long int*)va_arg(ap, short*); + if (pformat->flags & FLAG_LONG) + pformat->written = (long long int*)va_arg(ap, long int*); + if (pformat->flags & FLAG_LONG_LONG) + pformat->written = va_arg(ap, long long int*); + else + pformat->written = (long long int*)va_arg(ap, int*); + return (NULL); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/extract.c b/test_mini/libft/src/io/ft_printf/internals/extract.c new file mode 100644 index 0000000..c56a777 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/extract.c @@ -0,0 +1,98 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* extract.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/29 00:10:36 by cacharle #+# #+# */ +/* Updated: 2019/11/10 10:33:33 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +const char *extract_flags(t_pformat *pformat, const char *fmt) +{ + if (*fmt == '\0') + return (fmt); + while (ft_strchr(FLAGS_STR, *fmt) != NULL) + { + if (*fmt == '0') + pformat->flags |= FLAG_ZERO; + if (*fmt == '-') + pformat->flags |= FLAG_MINUS; + if (*fmt == '+') + pformat->flags |= FLAG_SIGNED; + if (*fmt == ' ') + pformat->flags |= FLAG_SPACE; + if (*fmt == '#') + pformat->flags |= FLAG_ALTERNATE; + if (*fmt == '\'') + ; + fmt++; + } + if (pformat->flags & FLAG_SIGNED) + pformat->flags &= ~FLAG_SPACE; + return (fmt); +} + +const char *extract_width(t_pformat *pformat, const char *fmt) +{ + if (*fmt == '\0') + return (fmt); + if (*fmt == '*') + { + pformat->flags |= FLAG_WIDTH_WILDCARD; + fmt++; + } + if (!ft_isdigit(*fmt)) + return (fmt); + pformat->width = ft_atoi(fmt); + while (*fmt && ft_isdigit(*fmt)) + fmt++; + if (pformat->flags & FLAG_WIDTH_WILDCARD) + pformat->flags |= FLAG_WIDTH_OVERWRITE; + return (fmt); +} + +const char *extract_precision(t_pformat *pformat, const char *fmt) +{ + if (*fmt == '\0' || *fmt != '.') + return (fmt); + fmt++; + if (*fmt == '*') + { + pformat->flags |= FLAG_PRECISION_WILDCARD; + fmt++; + } + pformat->precision = ft_atoi(fmt); + while (*fmt && ft_isdigit(*fmt)) + fmt++; + return (fmt); +} + +const char *extract_length_modifier(t_pformat *pformat, const char *fmt) +{ + if (fmt[0] && fmt[0] == 'l') + { + if (fmt[1] && fmt[1] == 'l') + { + pformat->flags |= FLAG_LONG_LONG; + return (fmt + 2); + } + pformat->flags |= FLAG_LONG; + return (fmt + 1); + } + if (fmt[0] && fmt[0] == 'h') + { + if (fmt[1] && fmt[1] == 'h') + { + pformat->flags |= FLAG_SHORT_SHORT; + return (fmt + 2); + } + pformat->flags |= FLAG_SHORT; + return (fmt + 1); + } + return (fmt); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/length_modifier.c b/test_mini/libft/src/io/ft_printf/internals/length_modifier.c new file mode 100644 index 0000000..88226da --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/length_modifier.c @@ -0,0 +1,39 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* length_modifier.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/05 23:56:07 by cacharle #+# #+# */ +/* Updated: 2019/11/09 00:50:06 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +t_big_uint length_modifier_unsigned_int(va_list ap, t_pformat *pformat) +{ + if (pformat->flags & FLAG_SHORT) + return ((unsigned short)va_arg(ap, int)); + else if (pformat->flags & FLAG_SHORT_SHORT) + return ((unsigned char)va_arg(ap, int)); + else if (pformat->flags & FLAG_LONG) + return (va_arg(ap, long unsigned int)); + else if (pformat->flags & FLAG_LONG_LONG) + return (va_arg(ap, long long unsigned int)); + return (va_arg(ap, unsigned int)); +} + +t_big_int length_modifier_int(va_list ap, t_pformat *pformat) +{ + if (pformat->flags & FLAG_SHORT) + return ((short)va_arg(ap, int)); + else if (pformat->flags & FLAG_SHORT_SHORT) + return ((signed char)va_arg(ap, int)); + else if (pformat->flags & FLAG_LONG) + return (va_arg(ap, long int)); + else if (pformat->flags & FLAG_LONG_LONG) + return (va_arg(ap, long long int)); + return (va_arg(ap, int)); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/list.c b/test_mini/libft/src/io/ft_printf/internals/list.c new file mode 100644 index 0000000..37f8013 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/list.c @@ -0,0 +1,67 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* list.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/29 00:14:50 by cacharle #+# #+# */ +/* Updated: 2019/11/05 23:45:42 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +t_flist *list_new(t_pformat *content) +{ + t_flist *lst; + + if ((lst = (t_flist*)malloc(sizeof(t_flist))) == NULL) + return (NULL); + lst->data = content; + lst->next = NULL; + return (lst); +} + +void *list_destroy(t_flist **lst) +{ + if (lst == NULL) + return (NULL); + while (*lst != NULL) + list_pop_front(lst); + return (NULL); +} + +void list_push_front(t_flist **lst, t_flist *new) +{ + if (lst == NULL || new == NULL) + return ; + new->next = *lst; + *lst = new; +} + +void list_pop_front(t_flist **lst) +{ + t_flist *tmp; + + if (lst == NULL || *lst == NULL) + return ; + tmp = (*lst)->next; + free((*lst)->data); + free(*lst); + *lst = tmp; +} + +t_flist *list_reverse(t_flist *lst) +{ + t_flist *tmp; + + if (lst == NULL) + return (NULL); + if (lst->next == NULL) + return (lst); + tmp = list_reverse(lst->next); + lst->next->next = lst; + lst->next = NULL; + return (tmp); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/parse.c b/test_mini/libft/src/io/ft_printf/internals/parse.c new file mode 100644 index 0000000..4650481 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/parse.c @@ -0,0 +1,61 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* parse.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/29 00:11:33 by cacharle #+# #+# */ +/* Updated: 2019/11/13 08:13:02 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +int parse(const char *format, t_flist **flist) +{ + t_flist *tmp; + t_pformat *parsed; + + *flist = NULL; + while (*format) + { + format++; + if (format[-1] != '%') + continue; + if ((parsed = parse_reduced(format)) == NULL) + return ((int)list_destroy(flist)); + if ((tmp = list_new(parsed)) == NULL) + return ((int)list_destroy(flist)); + list_push_front(flist, tmp); + format += (*flist)->data->fmt_len; + } + *flist = list_reverse(*flist); + return (1); +} + +t_pformat *parse_reduced(const char *fmt) +{ + t_pformat *pformat; + const char *start; + + if ((pformat = (t_pformat*)malloc(sizeof(t_pformat))) == NULL) + return (NULL); + pformat->precision = -1; + pformat->width = -1; + pformat->flags = 0; + start = fmt; + fmt = extract_flags(pformat, fmt); + fmt = extract_width(pformat, fmt); + fmt = extract_precision(pformat, fmt); + fmt = extract_length_modifier(pformat, fmt); + pformat->fmt_len = fmt - start + 1; + if (*fmt == '\0' || ft_strchr(SPECIFIERS_STR, *fmt) == NULL) + { + pformat->fmt_len--; + pformat->specifier = '_'; + } + else + pformat->specifier = *ft_strchr(SPECIFIERS_STR, *fmt); + return (pformat); +} diff --git a/test_mini/libft/src/io/ft_printf/internals/utils.c b/test_mini/libft/src/io/ft_printf/internals/utils.c new file mode 100644 index 0000000..ad44980 --- /dev/null +++ b/test_mini/libft/src/io/ft_printf/internals/utils.c @@ -0,0 +1,115 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* utils.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/29 00:12:40 by cacharle #+# #+# */ +/* Updated: 2019/11/13 08:49:58 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "ft_vasprintf.h" + +static int nbrlen_radix(long long int nbr, int radix) +{ + int counter; + long long unsigned int u_nbr; + + if (nbr == 0) + return (1); + counter = 0; + u_nbr = nbr; + if (nbr < 0) + { + counter++; + u_nbr = -nbr; + } + while (u_nbr > 0) + { + u_nbr /= radix; + counter++; + } + return (counter); +} + +char *ft_itoa_base(long long int n, char *base) +{ + char *str; + int len; + int radix; + long long unsigned int u_nbr; + + radix = ft_strlen(base); + len = nbrlen_radix(n, radix); + if ((str = (char*)malloc(sizeof(char) * (len + 1))) == NULL) + return (NULL); + str[len] = '\0'; + u_nbr = n < 0 ? -n : n; + if (n < 0) + str[0] = '-'; + while (--len >= (n < 0 ? 1 : 0)) + { + str[len] = base[u_nbr % radix]; + u_nbr /= radix; + } + return (str); +} + +static int nbrlen_unsigned_radix(long long unsigned int nbr, int radix) +{ + int counter; + + if (nbr == 0) + return (1); + counter = 0; + while (nbr > 0) + { + nbr /= radix; + counter++; + } + return (counter); +} + +char *ft_itoa_unsigned_base(long long unsigned int n, char *base) +{ + char *str; + int len; + int radix; + + radix = ft_strlen(base); + len = nbrlen_unsigned_radix(n, radix); + if ((str = (char*)malloc(sizeof(char) * (len + 1))) == NULL) + return (NULL); + str[len] = '\0'; + while (--len >= 0) + { + str[len] = base[n % radix]; + n /= radix; + } + return (str); +} + +void *ft_memjoin_free(void *dst, int dst_size, void *src, int src_size) +{ + void *clone; + + if (dst == NULL) + { + if ((dst = malloc(src_size)) == NULL) + return (NULL); + ft_memcpy(dst, src, src_size); + return (dst); + } + if ((clone = malloc(dst_size)) == NULL) + return (NULL); + ft_memcpy(clone, dst, dst_size); + free(dst); + if ((dst = malloc(dst_size + src_size)) == NULL) + return (NULL); + ft_memcpy(dst, clone, dst_size); + free(clone); + ft_memcpy(dst + dst_size, src, src_size); + return (dst); +} diff --git a/test_mini/libft/src/io/ft_putchar.c b/test_mini/libft/src/io/ft_putchar.c new file mode 100644 index 0000000..2838f0a --- /dev/null +++ b/test_mini/libft/src/io/ft_putchar.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putchar.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:53:31 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:49:14 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putchar(char c) +{ + write(STDOUT_FILENO, &c, 1); +} diff --git a/test_mini/libft/src/io/ft_putchar_fd.c b/test_mini/libft/src/io/ft_putchar_fd.c new file mode 100644 index 0000000..97d6f7a --- /dev/null +++ b/test_mini/libft/src/io/ft_putchar_fd.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putchar_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:42:34 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:49:28 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putchar_fd(char c, int fd) +{ + if (fd < 0 || fd > OPEN_MAX) + return ; + write(fd, &c, 1); +} diff --git a/test_mini/libft/src/io/ft_putendl.c b/test_mini/libft/src/io/ft_putendl.c new file mode 100644 index 0000000..880977e --- /dev/null +++ b/test_mini/libft/src/io/ft_putendl.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putendl.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:42:54 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:00:32 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putendl(char *s) +{ + ft_putendl_fd(s, STDOUT_FILENO); +} diff --git a/test_mini/libft/src/io/ft_putendl_fd.c b/test_mini/libft/src/io/ft_putendl_fd.c new file mode 100644 index 0000000..a8077fc --- /dev/null +++ b/test_mini/libft/src/io/ft_putendl_fd.c @@ -0,0 +1,21 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putendl_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:44:06 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:00:07 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putendl_fd(char *s, int fd) +{ + if (s == NULL || fd < 0 || fd > OPEN_MAX) + return ; + ft_putstr_fd(s, fd); + ft_putchar_fd('\n', fd); +} diff --git a/test_mini/libft/src/io/ft_putnbr.c b/test_mini/libft/src/io/ft_putnbr.c new file mode 100644 index 0000000..247df40 --- /dev/null +++ b/test_mini/libft/src/io/ft_putnbr.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:52:33 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:59:34 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putnbr(int n) +{ + ft_putnbr_fd(n, STDOUT_FILENO); +} diff --git a/test_mini/libft/src/io/ft_putnbr_fd.c b/test_mini/libft/src/io/ft_putnbr_fd.c new file mode 100644 index 0000000..169d1b5 --- /dev/null +++ b/test_mini/libft/src/io/ft_putnbr_fd.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbr_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:40:35 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:46:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putnbr_fd(int n, int fd) +{ + unsigned int p_n; + + if (fd < 0 || fd > OPEN_MAX) + return ; + p_n = n; + if (n < 0) + { + ft_putchar_fd('-', fd); + p_n = -n; + } + if (p_n > 9) + ft_putnbr_fd(p_n / 10, fd); + ft_putchar_fd(p_n % 10 | 0x30, fd); +} diff --git a/test_mini/libft/src/io/ft_putstr.c b/test_mini/libft/src/io/ft_putstr.c new file mode 100644 index 0000000..14b01a3 --- /dev/null +++ b/test_mini/libft/src/io/ft_putstr.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putstr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:52:12 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:48:48 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putstr(char const *s) +{ + ft_putstr_fd((char*)s, STDOUT_FILENO); +} diff --git a/test_mini/libft/src/io/ft_putstr_fd.c b/test_mini/libft/src/io/ft_putstr_fd.c new file mode 100644 index 0000000..d0279ab --- /dev/null +++ b/test_mini/libft/src/io/ft_putstr_fd.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putstr_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:40:15 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:47:59 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putstr_fd(char *s, int fd) +{ + if (s == NULL || fd < 0 || fd > OPEN_MAX) + return ; + write(fd, s, ft_strlen(s)); +} diff --git a/test_mini/libft/src/lst/ft_lstbsearch.c b/test_mini/libft/src/lst/ft_lstbsearch.c new file mode 100644 index 0000000..0c48eb0 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstbsearch.c @@ -0,0 +1,65 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstbsearch.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 09:17:51 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:12:12 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_lst.h" + +static t_ftlst *st_lstmiddle(t_ftlst *lst, t_ftlst *last) +{ + t_ftlst *slow; + t_ftlst *fast; + + if (lst == NULL) + return (NULL); + slow = lst; + fast = lst; + while (fast != last) + { + fast = fast->next; + if (fast == last) + break ; + slow = slow->next; + fast = fast->next; + } + return (slow); +} + +static t_ftlst *st_lstbsearch_rec(t_ftlst *lst, t_ftlst *last, + t_ftcompar_func cmp, const void *ref) +{ + int res; + t_ftlst *mid; + + if (lst == NULL) + return (NULL); + mid = st_lstmiddle(lst, last); + if (mid == NULL) + return (NULL); + if (mid->next == NULL) + { + if (cmp(ref, mid->data) == 0) + return (mid); + return (NULL); + } + res = cmp(ref, mid->next->data); + if (res < 0) + return (st_lstbsearch_rec(lst, mid, cmp, ref)); + else if (res > 0) + return (st_lstbsearch_rec(mid->next->next, NULL, cmp, ref)); + return (mid->next); +} + +t_ftlst *ft_lstbsearch(t_ftlst *lst, t_ftcompar_func cmp, + const void *ref) +{ + return (st_lstbsearch_rec(lst, NULL, cmp, ref)); +} diff --git a/test_mini/libft/src/lst/ft_lstdelone.c b/test_mini/libft/src/lst/ft_lstdelone.c new file mode 100644 index 0000000..3dfbbbb --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstdelone.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:03:02 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:02:31 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Delete list node +** \param del Delete function for node's data +*/ + +void ft_lstdelone(t_ftlst *lst, void (*del)(void *)) +{ + if (lst == NULL) + return ; + if (del != NULL) + (*del)(lst->data); + free(lst); +} diff --git a/test_mini/libft/src/lst/ft_lstdestroy.c b/test_mini/libft/src/lst/ft_lstdestroy.c new file mode 100644 index 0000000..35da2a5 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstdestroy.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:02:39 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:02:37 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Destroy a list and set his pointer to NULL +** \param del Delete Function for data of each node +*/ + +void ft_lstdestroy(t_ftlst **lst, void (*del)(void *)) +{ + if (lst == NULL) + return ; + if (*lst == NULL) + return ; + ft_lstdestroy(&((*lst)->next), del); + ft_lstdelone(*lst, del); + *lst = NULL; +} diff --git a/test_mini/libft/src/lst/ft_lstiter.c b/test_mini/libft/src/lst/ft_lstiter.c new file mode 100644 index 0000000..e46b507 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstiter.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstiter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:03:22 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:01:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Iterate of list +** \param f Funtion applied to data of each node +*/ + +void ft_lstiter(t_ftlst *lst, void (*f)(void *)) +{ + if (f == NULL) + return ; + while (lst != NULL) + { + (*f)(lst->data); + lst = lst->next; + } +} diff --git a/test_mini/libft/src/lst/ft_lstlast.c b/test_mini/libft/src/lst/ft_lstlast.c new file mode 100644 index 0000000..97b853d --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstlast.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstlast.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:03:40 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:02:26 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Last node +** \return List's last node +*/ + +t_ftlst *ft_lstlast(t_ftlst *lst) +{ + if (lst == NULL) + return (NULL); + while (lst->next != NULL) + lst = lst->next; + return (lst); +} diff --git a/test_mini/libft/src/lst/ft_lstlfind.c b/test_mini/libft/src/lst/ft_lstlfind.c new file mode 100644 index 0000000..fd7e688 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstlfind.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstlfind.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/27 18:00:37 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:24:05 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +t_ftlst *ft_lstlfind(t_ftlst *lst, t_ftcompar_func cmp, const void *ref) +{ + if (lst == NULL) + return (NULL); + if (cmp(ref, lst->data) == 0) + return (lst); + return (ft_lstlfind(lst->next, cmp, ref)); +} diff --git a/test_mini/libft/src/lst/ft_lstlsearch.c b/test_mini/libft/src/lst/ft_lstlsearch.c new file mode 100644 index 0000000..11c528c --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstlsearch.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstlsearch.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/27 16:18:33 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:24:31 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +t_ftlst *ft_lstlsearch(t_ftlst *lst, t_ftcompar_func cmp, const void *ref) +{ + if (lst == NULL) + return (ft_lstnew(ref)); + if (cmp(ref, lst->data) == 0) + return (lst); + if (lst->next == NULL) + { + lst->next = ft_lstnew(ref); + return (lst->next); + } + return (ft_lstlsearch(lst->next, cmp, ref)); +} diff --git a/test_mini/libft/src/lst/ft_lstmap.c b/test_mini/libft/src/lst/ft_lstmap.c new file mode 100644 index 0000000..3182bb0 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstmap.c @@ -0,0 +1,56 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstmap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:03:57 by cacharle #+# #+# */ +/* Updated: 2020/02/15 23:11:42 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Clone a list and map a function to each node data +** \param lst Origin list +** \param f Function applied to each node's data +** \param del Delete function for cleanning up in case of failed allocation +** \return Mapped clone list +*/ + +t_ftlst *ft_lstmap(t_ftlst *lst, void *(*f)(void *), void (*del)(void *)) +{ + t_ftlst *mapped; + t_ftlst *tmp; + + if (lst == NULL || f == NULL) + return (NULL); + mapped = NULL; + while (lst != NULL) + { + if ((tmp = ft_lstnew((*f)(lst->data))) == NULL) + { + ft_lstdestroy(&mapped, del); + return (NULL); + } + ft_lstpush_back(&mapped, tmp); + lst = lst->next; + } + return (mapped); +} + +/* +** Rest in peace, my beautiful recursion. +** +** t_ftlst *tmp; +** +** if (lst == NULL) +** return (NULL); +** if ((tmp = ft_lstnew(lst->data)) == NULL) +** return (NULL); +** tmp->data = (*f)(tmp->data); +** tmp->next = ft_lstmap(lst->next, f); +** return (tmp); +*/ diff --git a/test_mini/libft/src/lst/ft_lstnew.c b/test_mini/libft/src/lst/ft_lstnew.c new file mode 100644 index 0000000..1616b71 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstnew.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:01:16 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:01:35 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Create a list node +** \param data Pointer to data of node +*/ + +t_ftlst *ft_lstnew(void const *data) +{ + t_ftlst *elem; + + if ((elem = (t_ftlst*)malloc(sizeof(t_ftlst))) == NULL) + return (NULL); + elem->data = (void*)data; + elem->next = NULL; + return (elem); +} diff --git a/test_mini/libft/src/lst/ft_lstpop_front.c b/test_mini/libft/src/lst/ft_lstpop_front.c new file mode 100644 index 0000000..a61350a --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstpop_front.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstpop_front_bonus.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 08:29:58 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:12:47 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Delete head node and replace it with next node +** \param del Delete function for node data +*/ + +void ft_lstpop_front(t_ftlst **lst, void (*del)(void *)) +{ + t_ftlst *tmp; + + if (lst == NULL || *lst == NULL) + return ; + tmp = (*lst)->next; + ft_lstdelone(*lst, del); + *lst = tmp; +} diff --git a/test_mini/libft/src/lst/ft_lstpush_back.c b/test_mini/libft/src/lst/ft_lstpush_back.c new file mode 100644 index 0000000..1dca078 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstpush_back.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstpush_back.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:02:03 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:01:26 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Push new node to the list end +** \param new Pushed node +*/ + +void ft_lstpush_back(t_ftlst **alst, t_ftlst *new) +{ + if (alst == NULL) + return ; + if (*alst == NULL) + { + *alst = new; + return ; + } + ft_lstlast(*alst)->next = new; +} diff --git a/test_mini/libft/src/lst/ft_lstpush_front.c b/test_mini/libft/src/lst/ft_lstpush_front.c new file mode 100644 index 0000000..85df649 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstpush_front.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstpush_front.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:02:25 by cacharle #+# #+# */ +/* Updated: 2019/10/18 12:16:06 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Push node to list front +** \param new Pushed node +*/ + +void ft_lstpush_front(t_ftlst **alst, t_ftlst *new) +{ + if (alst == NULL || new == NULL) + return ; + new->next = *alst; + *alst = new; +} diff --git a/test_mini/libft/src/lst/ft_lstremove_if.c b/test_mini/libft/src/lst/ft_lstremove_if.c new file mode 100644 index 0000000..4070355 --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstremove_if.c @@ -0,0 +1,38 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstremove_if.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/30 09:36:49 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:20:51 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Remove node on some condition +** \param cmp Comparison function, return 0 if equal +** \param ref Reference data passed has the first arg of `cmp` +** \param del Delete function to free removed node data +*/ + +void ft_lstremove_if(t_ftlst **lst, t_ftcompar_func cmp, + const void *ref, t_ftdel_func del) +{ + t_ftlst *saved_next; + + if (lst == NULL || *lst == NULL) + return ; + if (cmp(ref, (*lst)->data) == 0) + { + saved_next = (*lst)->next; + ft_lstdelone(*lst, del); + *lst = saved_next; + ft_lstremove_if(lst, cmp, ref, del); + return ; + } + ft_lstremove_if(&(*lst)->next, cmp, ref, del); +} diff --git a/test_mini/libft/src/lst/ft_lstreverse.c b/test_mini/libft/src/lst/ft_lstreverse.c new file mode 100644 index 0000000..7c2778d --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstreverse.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstreverse.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/15 12:49:14 by cacharle #+# #+# */ +/* Updated: 2020/02/15 22:53:23 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Reverse a list +*/ + +void ft_lstreverse(t_ftlst **lst) +{ + *lst = ft_lstreverse_ret(*lst); +} diff --git a/test_mini/libft/src/lst/ft_lstreverse_ret.c b/test_mini/libft/src/lst/ft_lstreverse_ret.c new file mode 100644 index 0000000..36c0c5c --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstreverse_ret.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstreverse_ret.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/15 12:51:15 by cacharle #+# #+# */ +/* Updated: 2020/02/10 02:20:21 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Reverse list +** \return Pointer to reversed list +*/ + +t_ftlst *ft_lstreverse_ret(t_ftlst *lst) +{ + t_ftlst *tmp; + + if (lst == NULL) + return (NULL); + if (lst->next == NULL) + return (lst); + tmp = ft_lstreverse_ret(lst->next); + lst->next->next = lst; + lst->next = NULL; + return (tmp); +} diff --git a/test_mini/libft/src/lst/ft_lstsize.c b/test_mini/libft/src/lst/ft_lstsize.c new file mode 100644 index 0000000..3c6956b --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstsize.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstsize.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/09 09:04:28 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:01:44 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief List size +** \return Number of node in list +*/ + +int ft_lstsize(t_ftlst *lst) +{ + int counter; + + counter = 0; + while (lst != NULL) + { + counter++; + lst = lst->next; + } + return (counter); +} diff --git a/test_mini/libft/src/lst/ft_lstsort.c b/test_mini/libft/src/lst/ft_lstsort.c new file mode 100644 index 0000000..9945a0f --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstsort.c @@ -0,0 +1,46 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstsort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 01:53:55 by cacharle #+# #+# */ +/* Updated: 2020/02/16 02:18:05 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Sort list +** \param cmp Comparison function, <0 if less, 0 if equal, >0 if greater +** \note Use merge sort algorithm +*/ + +void ft_lstsort(t_ftlst **begin_list, t_ftcompar_func cmp) +{ + t_ftlst *fast; + t_ftlst *slow; + t_ftlst *middle; + + if (begin_list == NULL || *begin_list == NULL + || (*begin_list)->next == NULL) + return ; + fast = (*begin_list)->next; + slow = *begin_list; + while (fast != NULL) + { + fast = fast->next; + if (fast != NULL) + { + fast = fast->next; + slow = slow->next; + } + } + middle = slow->next; + slow->next = NULL; + ft_lstsort(begin_list, cmp); + ft_lstsort(&middle, cmp); + *begin_list = ft_lstsorted_merge(*begin_list, middle, cmp); +} diff --git a/test_mini/libft/src/lst/ft_lstsorted_merge.c b/test_mini/libft/src/lst/ft_lstsorted_merge.c new file mode 100644 index 0000000..995785f --- /dev/null +++ b/test_mini/libft/src/lst/ft_lstsorted_merge.c @@ -0,0 +1,43 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstsorted_merge.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 01:58:52 by cacharle #+# #+# */ +/* Updated: 2020/02/16 02:18:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_lst.h" + +/* +** \brief Merge sorted lists, the new list is also sorted +** \param l1 First list +** \param l2 Second list +** \param cmp Comparison function, <0 if less, 0 if equal, >0 if greater +** \return Pointer to first node of merged list +*/ + +t_ftlst *ft_lstsorted_merge(t_ftlst *l1, t_ftlst *l2, t_ftcompar_func cmp) +{ + t_ftlst *merged; + + merged = NULL; + if (l1 == NULL) + return (l2); + if (l2 == NULL) + return (l1); + if (cmp(l1->data, l2->data) < 0) + { + merged = l1; + merged->next = ft_lstsorted_merge(l1->next, l2, cmp); + } + else + { + merged = l2; + merged->next = ft_lstsorted_merge(l1, l2->next, cmp); + } + return (merged); +} diff --git a/test_mini/libft/src/mem/ft_bzero.c b/test_mini/libft/src/mem/ft_bzero.c new file mode 100644 index 0000000..d179af0 --- /dev/null +++ b/test_mini/libft/src/mem/ft_bzero.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_bzero.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:50:10 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:29:26 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_bzero(void *s, size_t n) +{ + ft_memset(s, 0, n); +} diff --git a/test_mini/libft/src/mem/ft_calloc.c b/test_mini/libft/src/mem/ft_calloc.c new file mode 100644 index 0000000..24501bf --- /dev/null +++ b/test_mini/libft/src/mem/ft_calloc.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_calloc.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 12:45:37 by cacharle #+# #+# */ +/* Updated: 2019/11/21 01:05:53 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_calloc(size_t count, size_t size) +{ + void *mem; + + if ((mem = malloc(count * size)) == NULL) + return (NULL); + ft_bzero(mem, count * size); + return (mem); +} diff --git a/test_mini/libft/src/mem/ft_memalloc.c b/test_mini/libft/src/mem/ft_memalloc.c new file mode 100644 index 0000000..5aab2ec --- /dev/null +++ b/test_mini/libft/src/mem/ft_memalloc.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memalloc.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:07:14 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:28:56 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_memalloc(size_t size) +{ + return (ft_calloc(size, 1)); +} diff --git a/test_mini/libft/src/mem/ft_memccpy.c b/test_mini/libft/src/mem/ft_memccpy.c new file mode 100644 index 0000000..8ce656a --- /dev/null +++ b/test_mini/libft/src/mem/ft_memccpy.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memccpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:01:53 by cacharle #+# #+# */ +/* Updated: 2020/01/17 10:54:03 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_memccpy(void *dest, const void *src, int c, size_t n) +{ + size_t i; + t_ftbyte *cast_dest; + t_ftbyte *cast_src; + + cast_dest = (t_ftbyte*)dest; + cast_src = (t_ftbyte*)src; + i = -1; + while (++i < n) + { + cast_dest[i] = cast_src[i]; + if (cast_dest[i] == (unsigned char)c) + return (cast_dest + i + 1); + } + return (NULL); +} diff --git a/test_mini/libft/src/mem/ft_memchr.c b/test_mini/libft/src/mem/ft_memchr.c new file mode 100644 index 0000000..4fd8689 --- /dev/null +++ b/test_mini/libft/src/mem/ft_memchr.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:55:31 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:28:00 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_memchr(const void *s, int c, size_t n) +{ + size_t i; + t_ftbyte *cast_s; + + cast_s = (t_ftbyte*)s; + i = -1; + while (++i < n) + if (cast_s[i] == (unsigned char)c) + return (cast_s + i); + return (NULL); +} diff --git a/test_mini/libft/src/mem/ft_memcmp.c b/test_mini/libft/src/mem/ft_memcmp.c new file mode 100644 index 0000000..233d796 --- /dev/null +++ b/test_mini/libft/src/mem/ft_memcmp.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memcmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:56:44 by cacharle #+# #+# */ +/* Updated: 2020/01/17 10:54:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_memcmp(const void *s1, const void *s2, size_t n) +{ + size_t i; + t_ftbyte *cast_s1; + t_ftbyte *cast_s2; + + cast_s1 = (t_ftbyte*)s1; + cast_s2 = (t_ftbyte*)s2; + if (n == 0) + return (0); + i = -1; + while (++i < n) + if (cast_s1[i] != cast_s2[i]) + return (cast_s1[i] - cast_s2[i]); + return (0); +} diff --git a/test_mini/libft/src/mem/ft_memcpy.c b/test_mini/libft/src/mem/ft_memcpy.c new file mode 100644 index 0000000..d0ef008 --- /dev/null +++ b/test_mini/libft/src/mem/ft_memcpy.c @@ -0,0 +1,33 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:00:07 by cacharle #+# #+# */ +/* Updated: 2020/01/17 10:39:04 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_memcpy(void *dest, const void *src, size_t n) +{ + long int *long_dest; + const long int *long_src; + + if (dest == src) + return (dest); + while (n % 8 > 0) + { + n--; + ((t_ftbyte*)dest)[n] = ((t_ftbyte*)src)[n]; + } + long_dest = dest; + long_src = src; + n /= 8; + while (n-- > 0) + long_dest[n] = long_src[n]; + return (dest); +} diff --git a/test_mini/libft/src/mem/ft_memdel.c b/test_mini/libft/src/mem/ft_memdel.c new file mode 100644 index 0000000..2b21f33 --- /dev/null +++ b/test_mini/libft/src/mem/ft_memdel.c @@ -0,0 +1,21 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memdel.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:00:56 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:22:41 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_memdel(void **ap) +{ + if (ap == NULL) + return ; + free(*ap); + *ap = NULL; +} diff --git a/test_mini/libft/src/mem/ft_memmem.c b/test_mini/libft/src/mem/ft_memmem.c new file mode 100644 index 0000000..fa1446c --- /dev/null +++ b/test_mini/libft/src/mem/ft_memmem.c @@ -0,0 +1,58 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memmem.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 01:54:55 by cacharle #+# #+# */ +/* Updated: 2020/02/13 21:04:46 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_mem.h" + +#define BAD_TABLE_SIZE 256 + +static void st_bad_table_init(size_t bad_table[BAD_TABLE_SIZE], + const char *little, size_t little_len) +{ + size_t i; + + i = 0; + while (i < BAD_TABLE_SIZE) + bad_table[i++] = little_len; + i = 0; + while (i < little_len - 1) + { + bad_table[(int)little[i]] = little_len - i - 1; + i++; + } +} + +static int st_memcmp_end(const void *s1, const void *s2, size_t n) +{ + while (n-- > 0) + if (*(t_ftbyte*)(s1 + n) != *(t_ftbyte*)(s2 + n)) + return (*(t_ftbyte*)(s1 + n) - *(t_ftbyte*)(s2 + n)); + return (0); +} + +void *ft_memmem(const void *big, size_t big_len, + const void *little, size_t little_len) +{ + size_t i; + size_t bad_table[BAD_TABLE_SIZE]; + + if (big_len < little_len || little_len == 0 || big_len == 0) + return (NULL); + st_bad_table_init(bad_table, little, little_len); + i = 0; + while (i <= big_len - little_len) + { + if (st_memcmp_end(big + i, little, little_len) == 0) + return ((void*)big + i); + i += bad_table[*(t_ftbyte*)(big + i + little_len - 1)]; + } + return (NULL); +} diff --git a/test_mini/libft/src/mem/ft_memmove.c b/test_mini/libft/src/mem/ft_memmove.c new file mode 100644 index 0000000..2f794fd --- /dev/null +++ b/test_mini/libft/src/mem/ft_memmove.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memmove.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:03:21 by cacharle #+# #+# */ +/* Updated: 2020/01/17 10:39:26 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_memmove(void *dst, const void *src, size_t len) +{ + long int *long_dst; + const long int *long_src; + void *dst_copy; + + if (dst >= src) + return (ft_memcpy(dst, src, len)); + dst_copy = dst; + while (len % 8 > 0) + { + len--; + *(t_ftbyte*)dst++ = *(t_ftbyte*)src++; + } + long_dst = dst; + long_src = src; + len /= 8; + while (len-- > 0) + *long_dst++ = *long_src++; + return (dst_copy); +} diff --git a/test_mini/libft/src/mem/ft_memset.c b/test_mini/libft/src/mem/ft_memset.c new file mode 100644 index 0000000..89f53ff --- /dev/null +++ b/test_mini/libft/src/mem/ft_memset.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memset.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:01:23 by cacharle #+# #+# */ +/* Updated: 2020/01/17 10:39:10 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void *ft_memset(void *s, int c, size_t n) +{ + long int buf; + long int *long_s; + + c = (unsigned char)c; + while (n % 8 > 0) + *((t_ftbyte*)s + --n) = c; + buf = (long int)c | (long int)c << 8 | (long int)c << 16 + | (long int)c << 24 | (long int)c << 32 | (long int)c << 40 + | (long int)c << 48 | (long int)c << 56; + n /= 8; + long_s = s; + while (n > 0) + long_s[--n] = buf; + return (s); +} diff --git a/test_mini/libft/src/mem/ft_memset_pattern4.c b/test_mini/libft/src/mem/ft_memset_pattern4.c new file mode 100644 index 0000000..112ce6d --- /dev/null +++ b/test_mini/libft/src/mem/ft_memset_pattern4.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memset_pattern4.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:06:41 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:58:10 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_mem.h" + +void ft_memset_pattern4(void *b, const void *pattern4, size_t len) +{ + int i; + + i = len / 4; + while (i-- > 0) + ((int*)b)[i] = *(int*)pattern4; + i = len % 4; + len -= len % 4; + while (i-- > 0) + ((t_ftbyte*)b)[len + i] = ((t_ftbyte*)pattern4)[i]; +} diff --git a/test_mini/libft/src/mem/ft_memswap.c b/test_mini/libft/src/mem/ft_memswap.c new file mode 100644 index 0000000..8661fda --- /dev/null +++ b/test_mini/libft/src/mem/ft_memswap.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memswap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/19 07:56:43 by cacharle #+# #+# */ +/* Updated: 2020/02/10 02:55:52 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_memswap(void *a, void *b, size_t size) +{ + t_ftbyte tmp; + t_ftbyte *cast_a; + t_ftbyte *cast_b; + + cast_a = (t_ftbyte*)a; + cast_b = (t_ftbyte*)b; + while (size-- > 0) + { + tmp = cast_a[size]; + cast_a[size] = cast_b[size]; + cast_b[size] = tmp; + } +} diff --git a/test_mini/libft/src/str/ft_atoi.c b/test_mini/libft/src/str/ft_atoi.c new file mode 100644 index 0000000..d6fa5bb --- /dev/null +++ b/test_mini/libft/src/str/ft_atoi.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_atoi.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 09:46:16 by cacharle #+# #+# */ +/* Updated: 2020/01/15 10:56:06 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +/* +** Convert a string to an int +*/ + +int ft_atoi(const char *str) +{ + return ((int)ft_strtol(str, (char**)NULL, 10)); +} diff --git a/test_mini/libft/src/str/ft_atoi_strict.c b/test_mini/libft/src/str/ft_atoi_strict.c new file mode 100644 index 0000000..8be4c4b --- /dev/null +++ b/test_mini/libft/src/str/ft_atoi_strict.c @@ -0,0 +1,38 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strict_atoi.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/15 10:06:29 by cacharle #+# #+# */ +/* Updated: 2020/02/14 02:46:43 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_atoi_strict(const char *s) +{ + char *end; + long ret; + + if (*s != '-' && !ft_isdigit(*s)) + { + errno = EINVAL; + return (0); + } + errno = 0; + ret = ft_strtol(s, &end, 10); + if (errno == ERANGE || ret > INT_MAX || ret < INT_MIN) + { + errno = ERANGE; + return (0); + } + if (*end != '\0') + { + errno = EINVAL; + return (0); + } + return (ret); +} diff --git a/test_mini/libft/src/str/ft_itoa.c b/test_mini/libft/src/str/ft_itoa.c new file mode 100644 index 0000000..39b6e12 --- /dev/null +++ b/test_mini/libft/src/str/ft_itoa.c @@ -0,0 +1,40 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_itoa.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:19:56 by cacharle #+# #+# */ +/* Updated: 2020/02/14 03:39:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_itoa(int n) +{ + char *str; + int len; + unsigned int u_nbr; + + len = n < 0 || n == 0 ? 1 : 0; + u_nbr = n < 0 ? -n : n; + while (u_nbr > 0) + { + u_nbr /= 10; + len++; + } + if ((str = (char*)malloc(sizeof(char) * (len + 1))) == NULL) + return (NULL); + str[len] = '\0'; + u_nbr = n < 0 ? -n : n; + if (n < 0) + str[0] = '-'; + while (--len >= (n < 0 ? 1 : 0)) + { + str[len] = (u_nbr % 10) | 0x30; + u_nbr /= 10; + } + return (str); +} diff --git a/test_mini/libft/src/str/ft_split.c b/test_mini/libft/src/str/ft_split.c new file mode 100644 index 0000000..6fb5964 --- /dev/null +++ b/test_mini/libft/src/str/ft_split.c @@ -0,0 +1,73 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_split.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/17 08:29:02 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:08:27 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +static size_t count_segment(char const *s, char c) +{ + size_t counter; + int i; + + counter = 0; + i = 0; + while (s[i]) + { + if (s[i] == c) + { + i++; + continue ; + } + counter++; + while (s[i] && s[i] != c) + i++; + } + return (counter); +} + +static void *destroy_strs(char **strs) +{ + if (strs == NULL) + return (NULL); + while (*strs != NULL) + free(*strs++); + free(strs); + return (NULL); +} + +char **ft_split(char const *s, char c) +{ + char **strs; + size_t tab_counter; + size_t i; + size_t j; + + if (s == NULL) + return (NULL); + tab_counter = count_segment(s, c); + if ((strs = (char**)malloc(sizeof(char*) * (tab_counter + 1))) == NULL) + return (NULL); + tab_counter = 0; + j = -1; + while (s[++j]) + { + if (s[j] == c) + continue ; + i = 0; + while (s[j + i] && s[j + i] != c) + i++; + if ((strs[tab_counter++] = ft_strndup(&s[j], i)) == NULL) + return (destroy_strs(strs)); + j += i - 1; + } + strs[tab_counter] = NULL; + return (strs); +} diff --git a/test_mini/libft/src/str/ft_strcasecmp.c b/test_mini/libft/src/str/ft_strcasecmp.c new file mode 100644 index 0000000..044e6de --- /dev/null +++ b/test_mini/libft/src/str/ft_strcasecmp.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcasecmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:08:38 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:31:33 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" +#include "libft_types.h" + +int ft_strcasecmp(const char *s1, const char *s2) +{ + while (*s1 && *s2 && ft_tolower(*s1) == ft_tolower(*s2)) + { + s1++; + s2++; + } + return ((t_ftuchar)ft_tolower(*s1) - (t_ftuchar)ft_tolower(*s2)); +} diff --git a/test_mini/libft/src/str/ft_strcat.c b/test_mini/libft/src/str/ft_strcat.c new file mode 100644 index 0000000..d5bc7e0 --- /dev/null +++ b/test_mini/libft/src/str/ft_strcat.c @@ -0,0 +1,19 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcat.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:09:41 by cacharle #+# #+# */ +/* Updated: 2019/11/21 01:03:38 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strcat(char *dest, const char *src) +{ + ft_memcpy(dest + ft_strlen(dest), src, ft_strlen(src) + 1); + return (dest); +} diff --git a/test_mini/libft/src/str/ft_strchr.c b/test_mini/libft/src/str/ft_strchr.c new file mode 100644 index 0000000..50bfc0a --- /dev/null +++ b/test_mini/libft/src/str/ft_strchr.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:14:47 by cacharle #+# #+# */ +/* Updated: 2019/11/21 01:04:52 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strchr(const char *s, int c) +{ + return (ft_memchr(s, c, ft_strlen(s) + 1)); +} diff --git a/test_mini/libft/src/str/ft_strclr.c b/test_mini/libft/src/str/ft_strclr.c new file mode 100644 index 0000000..7e412fe --- /dev/null +++ b/test_mini/libft/src/str/ft_strclr.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strclr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:15:18 by cacharle #+# #+# */ +/* Updated: 2019/11/21 01:11:51 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_strclr(char *s) +{ + if (s == NULL) + return ; + ft_bzero(s, ft_strlen(s)); +} diff --git a/test_mini/libft/src/str/ft_strcmp.c b/test_mini/libft/src/str/ft_strcmp.c new file mode 100644 index 0000000..aced711 --- /dev/null +++ b/test_mini/libft/src/str/ft_strcmp.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:16:07 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:18:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_strcmp(const char *s1, const char *s2) +{ + while (*s1 && *s2 && *s1 == *s2) + { + s1++; + s2++; + } + return (*s1 - *s2); +} diff --git a/test_mini/libft/src/str/ft_strcount.c b/test_mini/libft/src/str/ft_strcount.c new file mode 100644 index 0000000..87e756d --- /dev/null +++ b/test_mini/libft/src/str/ft_strcount.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcount.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/15 09:17:48 by cacharle #+# #+# */ +/* Updated: 2019/11/15 09:19:36 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +int ft_strcount(char *str, char c) +{ + int counter; + + if (c == '\0') + return (1); + counter = 0; + while (*str) + if (*str++ == c) + counter++; + return (counter); +} diff --git a/test_mini/libft/src/str/ft_strcpy.c b/test_mini/libft/src/str/ft_strcpy.c new file mode 100644 index 0000000..ee6ff0d --- /dev/null +++ b/test_mini/libft/src/str/ft_strcpy.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:38:36 by cacharle #+# #+# */ +/* Updated: 2020/01/17 11:36:19 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strcpy(char *dest, const char *src) +{ + return (ft_memcpy(dest, src, ft_strlen(src) + 1)); +} diff --git a/test_mini/libft/src/str/ft_strcspn.c b/test_mini/libft/src/str/ft_strcspn.c new file mode 100644 index 0000000..7cc06a5 --- /dev/null +++ b/test_mini/libft/src/str/ft_strcspn.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcspn.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:30:59 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:32:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" + +size_t ft_strcspn(const char *s, const char *charset) +{ + int i; + + i = 0; + while (ft_strchr(charset, s[i]) == NULL) + i++; + return (i); +} diff --git a/test_mini/libft/src/str/ft_strdel.c b/test_mini/libft/src/str/ft_strdel.c new file mode 100644 index 0000000..05cf064 --- /dev/null +++ b/test_mini/libft/src/str/ft_strdel.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strdel.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:39:14 by cacharle #+# #+# */ +/* Updated: 2019/11/20 01:58:27 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_strdel(char **as) +{ + ft_memdel((void*)as); +} diff --git a/test_mini/libft/src/str/ft_strdup.c b/test_mini/libft/src/str/ft_strdup.c new file mode 100644 index 0000000..b248272 --- /dev/null +++ b/test_mini/libft/src/str/ft_strdup.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strdup.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:18:07 by cacharle #+# #+# */ +/* Updated: 2020/02/14 03:39:56 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strdup(const char *s) +{ + char *clone; + + if ((clone = (char*)malloc(sizeof(char) * (ft_strlen(s) + 1))) == NULL) + return (NULL); + return (ft_strcpy(clone, s)); +} diff --git a/test_mini/libft/src/str/ft_strequ.c b/test_mini/libft/src/str/ft_strequ.c new file mode 100644 index 0000000..75ccb81 --- /dev/null +++ b/test_mini/libft/src/str/ft_strequ.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strequ.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:18:34 by cacharle #+# #+# */ +/* Updated: 2019/11/20 02:00:22 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_strequ(char const *s1, char const *s2) +{ + if (s1 == NULL || s2 == NULL) + return (0); + return (ft_strcmp(s1, s2) == 0); +} diff --git a/test_mini/libft/src/str/ft_striter.c b/test_mini/libft/src/str/ft_striter.c new file mode 100644 index 0000000..f410d24 --- /dev/null +++ b/test_mini/libft/src/str/ft_striter.c @@ -0,0 +1,21 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_striter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:38:16 by cacharle #+# #+# */ +/* Updated: 2019/11/20 02:01:32 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_striter(char *s, void (*f)(char *)) +{ + if (s == NULL || f == NULL) + return ; + while (*s) + (*f)(s++); +} diff --git a/test_mini/libft/src/str/ft_striteri.c b/test_mini/libft/src/str/ft_striteri.c new file mode 100644 index 0000000..05f15d4 --- /dev/null +++ b/test_mini/libft/src/str/ft_striteri.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_striteri.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:33:09 by cacharle #+# #+# */ +/* Updated: 2019/11/20 02:01:41 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_striteri(char *s, void (*f)(unsigned int, char *)) +{ + unsigned int i; + + if (s == NULL || f == NULL) + return ; + i = 0; + while (s[i]) + { + (*f)(i, &s[i]); + i++; + } +} diff --git a/test_mini/libft/src/str/ft_strjoin.c b/test_mini/libft/src/str/ft_strjoin.c new file mode 100644 index 0000000..b65eaa2 --- /dev/null +++ b/test_mini/libft/src/str/ft_strjoin.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strjoin.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:35:26 by cacharle #+# #+# */ +/* Updated: 2020/02/14 03:40:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strjoin(char const *s1, char const *s2) +{ + char *joined; + + if (s1 == NULL || s2 == NULL) + return (NULL); + if ((joined = (char*)malloc(sizeof(char) + * (ft_strlen(s1) + ft_strlen(s2) + 1))) == NULL) + return (NULL); + return (ft_strcat(ft_strcpy(joined, s1), s2)); +} diff --git a/test_mini/libft/src/str/ft_strjoin3.c b/test_mini/libft/src/str/ft_strjoin3.c new file mode 100644 index 0000000..e5e5530 --- /dev/null +++ b/test_mini/libft/src/str/ft_strjoin3.c @@ -0,0 +1,36 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strjoin3.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 18:00:49 by charles #+# #+# */ +/* Updated: 2020/04/01 18:01:43 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +/* +** \brief Join 3 strings in a new malloc'd one +** \param s1 String 1 +** \param s2 String 2 +** \param s3 String 3 +** \return The joined string +*/ + +char *ft_strjoin3(char const *s1, char const *s2, char const *s3) +{ + char *joined; + + if (s1 == NULL || s2 == NULL || s3 == NULL) + return (NULL); + if ((joined = (char*)malloc(sizeof(char) + * (ft_strlen(s1) + ft_strlen(s2) + ft_strlen(s3) + 1))) == NULL) + return (NULL); + ft_strcpy(joined, s1); + ft_strcat(joined, s2); + ft_strcat(joined, s3); + return (joined); +} diff --git a/test_mini/libft/src/str/ft_strjoinf.c b/test_mini/libft/src/str/ft_strjoinf.c new file mode 100644 index 0000000..228a963 --- /dev/null +++ b/test_mini/libft/src/str/ft_strjoinf.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strjoinf.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/14 03:41:07 by cacharle #+# #+# */ +/* Updated: 2020/02/14 03:41:25 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include <stdlib.h> +#include "libft.h" +#include "libft_str.h" + +char *ft_strjoinf(char const *s1, char const *s2, t_ftstrjoinf_tag tag) +{ + char *joined; + + if (s1 == NULL || s2 == NULL) + return (NULL); + if ((joined = ft_strjoin(s1, s2)) == NULL) + return (NULL); + if (tag == FT_STRJOINF_FST) + free((void*)s1); + else if (tag == FT_STRJOINF_SND) + free((void*)s2); + else if (tag == FT_STRJOINF_ALL) + { + free((void*)s1); + free((void*)s2); + } + return (joined); +} diff --git a/test_mini/libft/src/str/ft_strlcat.c b/test_mini/libft/src/str/ft_strlcat.c new file mode 100644 index 0000000..ce7fa0b --- /dev/null +++ b/test_mini/libft/src/str/ft_strlcat.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strlcat.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:31:37 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:31:08 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +size_t ft_strlcat(char *dst, const char *src, size_t size) +{ + size_t i; + size_t j; + size_t dst_len; + size_t src_len; + + dst_len = ft_strlen(dst); + src_len = ft_strlen(src); + if (size <= dst_len) + return (src_len + size); + i = 0; + j = dst_len; + while (src[i] && j < size - 1) + dst[j++] = src[i++]; + dst[j] = '\0'; + return (dst_len + src_len); +} diff --git a/test_mini/libft/src/str/ft_strlcpy.c b/test_mini/libft/src/str/ft_strlcpy.c new file mode 100644 index 0000000..6afb8f5 --- /dev/null +++ b/test_mini/libft/src/str/ft_strlcpy.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strlcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 12:28:47 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:31:16 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +size_t ft_strlcpy(char *dst, const char *src, size_t size) +{ + unsigned int i; + + if (dst == NULL || src == NULL) + return (0); + if (size == 0) + return (ft_strlen(src)); + i = -1; + while (++i < size - 1 && src[i] != '\0') + dst[i] = src[i]; + dst[i] = '\0'; + return (ft_strlen(src)); +} diff --git a/test_mini/libft/src/str/ft_strlen.c b/test_mini/libft/src/str/ft_strlen.c new file mode 100644 index 0000000..0d593e1 --- /dev/null +++ b/test_mini/libft/src/str/ft_strlen.c @@ -0,0 +1,41 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strlen.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:32:48 by cacharle #+# #+# */ +/* Updated: 2020/01/17 11:13:43 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +size_t ft_strlen(const char *s) +{ + unsigned long int *ptr; + const char *cpy; + + ptr = (unsigned long int*)s; + while (TRUE) + { + cpy = (const char*)ptr++; + if (cpy[0] == '\0') + return (cpy - s); + if (cpy[1] == '\0') + return (cpy + 1 - s); + if (cpy[2] == '\0') + return (cpy + 2 - s); + if (cpy[3] == '\0') + return (cpy + 3 - s); + if (cpy[4] == '\0') + return (cpy + 4 - s); + if (cpy[5] == '\0') + return (cpy + 5 - s); + if (cpy[6] == '\0') + return (cpy + 6 - s); + if (cpy[7] == '\0') + return (cpy + 7 - s); + } +} diff --git a/test_mini/libft/src/str/ft_strmap.c b/test_mini/libft/src/str/ft_strmap.c new file mode 100644 index 0000000..61d16f1 --- /dev/null +++ b/test_mini/libft/src/str/ft_strmap.c @@ -0,0 +1,34 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strmap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:29:52 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:02:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strmap(char const *s, char (*f)(char)) +{ + size_t i; + size_t len; + char *mapped; + + if (s == NULL || f == NULL) + return (NULL); + len = ft_strlen(s); + if ((mapped = (char*)malloc(sizeof(char) * (len + 1))) == NULL) + return (NULL); + i = 0; + while (i < len) + { + mapped[i] = (*f)(s[i]); + i++; + } + mapped[i] = '\0'; + return (mapped); +} diff --git a/test_mini/libft/src/str/ft_strmapi.c b/test_mini/libft/src/str/ft_strmapi.c new file mode 100644 index 0000000..71d77e4 --- /dev/null +++ b/test_mini/libft/src/str/ft_strmapi.c @@ -0,0 +1,34 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strmapi.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:29:32 by cacharle #+# #+# */ +/* Updated: 2019/11/20 04:02:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strmapi(char *s, char (*f)(unsigned int, char)) +{ + size_t i; + size_t len; + char *mapped; + + if (s == NULL || f == NULL) + return (NULL); + len = ft_strlen(s); + if ((mapped = (char*)malloc(sizeof(char) * (len + 1))) == NULL) + return (NULL); + i = 0; + while (i < len) + { + mapped[i] = (*f)((unsigned int)i, s[i]); + i++; + } + mapped[i] = '\0'; + return (mapped); +} diff --git a/test_mini/libft/src/str/ft_strncasecmp.c b/test_mini/libft/src/str/ft_strncasecmp.c new file mode 100644 index 0000000..aafdc8c --- /dev/null +++ b/test_mini/libft/src/str/ft_strncasecmp.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncasecmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:18:36 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:31:38 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_types.h" + +int ft_strncasecmp(const char *s1, const char *s2, size_t n) +{ + size_t i; + + if (n == 0) + return (0); + i = 0; + while (i + 1 < n && s1[i] && ft_tolower(s1[i]) == ft_tolower(s2[i])) + i++; + return ((t_ftuchar)ft_tolower(s1[i]) - (t_ftuchar)ft_tolower(s2[i])); +} diff --git a/test_mini/libft/src/str/ft_strncat.c b/test_mini/libft/src/str/ft_strncat.c new file mode 100644 index 0000000..d68db0a --- /dev/null +++ b/test_mini/libft/src/str/ft_strncat.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncat.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:28:37 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:33:22 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strncat(char *dest, const char *src, size_t n) +{ + size_t i; + size_t j; + + i = ft_strlen(dest); + j = 0; + while (j < n && src[j]) + { + dest[i + j] = src[j]; + j++; + } + dest[i + j] = '\0'; + return (dest); +} diff --git a/test_mini/libft/src/str/ft_strncmp.c b/test_mini/libft/src/str/ft_strncmp.c new file mode 100644 index 0000000..caa052b --- /dev/null +++ b/test_mini/libft/src/str/ft_strncmp.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:27:34 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:17:50 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" +#include "libft_types.h" + +int ft_strncmp(const char *s1, const char *s2, size_t n) +{ + size_t i; + + if (n == 0) + return (0); + i = 0; + while (i + 1 < n && s1[i] == s2[i] && s1[i]) + i++; + return ((t_ftuchar)s1[i] - (t_ftuchar)s2[i]); +} diff --git a/test_mini/libft/src/str/ft_strncpy.c b/test_mini/libft/src/str/ft_strncpy.c new file mode 100644 index 0000000..07a4927 --- /dev/null +++ b/test_mini/libft/src/str/ft_strncpy.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:26:59 by cacharle #+# #+# */ +/* Updated: 2020/01/17 10:40:21 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strncpy(char *dest, const char *src, size_t n) +{ + size_t len; + + len = ft_strlen(src); + ft_memcpy(dest, src, n < len ? n : len); + if (len < n) + ft_bzero(dest + len, n - len); + return (dest); +} diff --git a/test_mini/libft/src/str/ft_strndup.c b/test_mini/libft/src/str/ft_strndup.c new file mode 100644 index 0000000..894ea4e --- /dev/null +++ b/test_mini/libft/src/str/ft_strndup.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strndup.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/25 03:28:52 by cacharle #+# #+# */ +/* Updated: 2020/02/14 03:43:55 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strndup(const char *s1, size_t n) +{ + char *clone; + + if ((clone = (char*)malloc(sizeof(char) * (n + 1))) == NULL) + return (NULL); + clone[n] = '\0'; + return (ft_strncpy(clone, s1, n)); +} diff --git a/test_mini/libft/src/str/ft_strnequ.c b/test_mini/libft/src/str/ft_strnequ.c new file mode 100644 index 0000000..e242ee7 --- /dev/null +++ b/test_mini/libft/src/str/ft_strnequ.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnequ.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:30:27 by cacharle #+# #+# */ +/* Updated: 2019/11/20 02:00:42 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_strnequ(char const *s1, char const *s2, size_t n) +{ + if (s1 == NULL || s2 == NULL) + return (0); + return (ft_strncmp(s1, s2, n) == 0); +} diff --git a/test_mini/libft/src/str/ft_strnew.c b/test_mini/libft/src/str/ft_strnew.c new file mode 100644 index 0000000..1bca6d5 --- /dev/null +++ b/test_mini/libft/src/str/ft_strnew.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:17:34 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:16:14 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strnew(size_t size) +{ + return ((char*)ft_calloc(size + 1, sizeof(char))); +} diff --git a/test_mini/libft/src/str/ft_strnlen.c b/test_mini/libft/src/str/ft_strnlen.c new file mode 100644 index 0000000..5e1569c --- /dev/null +++ b/test_mini/libft/src/str/ft_strnlen.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnlen.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 05:21:04 by cacharle #+# #+# */ +/* Updated: 2020/02/10 05:23:23 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" + +/* +** wrong implementation since it scans beyond maxlen +*/ + +size_t ft_strnlen(const char *s, size_t maxlen) +{ + size_t len; + + len = ft_strlen(s); + return (len > maxlen ? maxlen : len); +} diff --git a/test_mini/libft/src/str/ft_strnstr.c b/test_mini/libft/src/str/ft_strnstr.c new file mode 100644 index 0000000..4995637 --- /dev/null +++ b/test_mini/libft/src/str/ft_strnstr.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnstr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:25:13 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:58:42 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strnstr(const char *haystack, const char *needle, size_t len) +{ + size_t needle_len; + + needle_len = ft_strlen(needle); + if (needle_len == 0) + return ((char*)haystack); + while (*haystack && len-- >= needle_len) + { + if (ft_strnequ(haystack, needle, needle_len)) + return ((char*)haystack); + haystack++; + } + return (NULL); +} diff --git a/test_mini/libft/src/str/ft_strpbrk.c b/test_mini/libft/src/str/ft_strpbrk.c new file mode 100644 index 0000000..753e4d9 --- /dev/null +++ b/test_mini/libft/src/str/ft_strpbrk.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strpbrk.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:39:29 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:54:13 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" + +char *ft_strpbrk(const char *s, const char *charset) +{ + if (s == NULL || charset == NULL) + return (NULL); + while (*s && ft_strchr(charset, *s) == NULL) + s++; + if (*s == '\0') + return (NULL); + return ((char*)s); +} diff --git a/test_mini/libft/src/str/ft_strrchr.c b/test_mini/libft/src/str/ft_strrchr.c new file mode 100644 index 0000000..4cedb76 --- /dev/null +++ b/test_mini/libft/src/str/ft_strrchr.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strrchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:26:24 by cacharle #+# #+# */ +/* Updated: 2019/11/21 18:46:27 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strrchr(const char *s, int c) +{ + size_t i; + + i = ft_strlen(s) + 1; + while (s[--i] != (char)c) + if (i == 0) + return (NULL); + return ((char*)s + i); +} diff --git a/test_mini/libft/src/str/ft_strsep.c b/test_mini/libft/src/str/ft_strsep.c new file mode 100644 index 0000000..2000706 --- /dev/null +++ b/test_mini/libft/src/str/ft_strsep.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strsep.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:44:11 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:51:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" + +char *ft_strsep(char **stringp, const char *delim) +{ + char *tmp; + + if (stringp == NULL || *stringp == NULL || delim == NULL) + return (NULL); + tmp = ft_strpbrk(*stringp, delim); + if (tmp == NULL) + return (NULL); + *tmp = '\0'; + *stringp = tmp; + return (tmp); +} diff --git a/test_mini/libft/src/str/ft_strspn.c b/test_mini/libft/src/str/ft_strspn.c new file mode 100644 index 0000000..81814e5 --- /dev/null +++ b/test_mini/libft/src/str/ft_strspn.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strspn.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:29:13 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:33:11 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" + +size_t ft_strspn(const char *s, const char *charset) +{ + int i; + + i = 0; + while (ft_strchr(charset, s[i]) != NULL) + i++; + return (i); +} diff --git a/test_mini/libft/src/str/ft_strstr.c b/test_mini/libft/src/str/ft_strstr.c new file mode 100644 index 0000000..4d4d403 --- /dev/null +++ b/test_mini/libft/src/str/ft_strstr.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strstr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:15:29 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:58:32 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strstr(const char *haystack, const char *needle) +{ + size_t needle_len; + + needle_len = ft_strlen(needle); + if (needle_len == 0) + return ((char*)haystack); + while (*haystack) + { + if (ft_strnequ(haystack, needle, needle_len)) + return ((char*)haystack); + haystack++; + } + return (NULL); +} diff --git a/test_mini/libft/src/str/ft_strtol.c b/test_mini/libft/src/str/ft_strtol.c new file mode 100644 index 0000000..82276d8 --- /dev/null +++ b/test_mini/libft/src/str/ft_strtol.c @@ -0,0 +1,80 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strtol.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/01/15 10:26:45 by cacharle #+# #+# */ +/* Updated: 2020/02/10 02:21:16 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +#define STRTOL_STD_BASE "0123456789abcdefghijklmnopqrstuvwxyz" + +static int st_strtol_handle_base(int base, const char **str) +{ + if (base > 36) + return (-1); + if (base != 16 && base != 0) + return (base); + if (base == 16 && **str == '0' && (*str)[1] == 'x') + { + *str += 2; + return (base); + } + if (**str == '0') + { + (*str)++; + if (**str == 'x') + { + (*str)++; + return (16); + } + else + return (8); + } + return (10); +} + +static long st_errno_return(int err) +{ + errno = err; + return (0); +} + +/* +** If there is no digits doesn't put str in endptr like the original, +** instead it puts the address of the char after spaces and sign. +** Too much lines and annoyance, I can't be bothered. +*/ + +long ft_strtol(const char *str, char **endptr, int base) +{ + t_ftbool is_negative; + long long nb; + char base_str[37]; + + while (ft_isspace(*str)) + str++; + is_negative = *str == '-' ? TRUE : FALSE; + if (*str == '-' || *str == '+') + str++; + if ((base = st_strtol_handle_base(base, &str)) == -1) + return (st_errno_return(EINVAL)); + ft_strncpy(base_str, STRTOL_STD_BASE, base); + base_str[base] = '\0'; + nb = 0; + while (*str != '\0' && ft_strchr(base_str, *str) != NULL) + { + nb *= base; + nb += ft_strchr(base_str, ft_tolower(*str++)) - base_str; + if (((long)nb ^ (long)(nb / base)) < 0) + errno = ERANGE; + } + if (endptr != NULL) + *endptr = (char*)str; + return (is_negative ? -nb : nb); +} diff --git a/test_mini/libft/src/str/ft_strtolower.c b/test_mini/libft/src/str/ft_strtolower.c new file mode 100644 index 0000000..2eb34c2 --- /dev/null +++ b/test_mini/libft/src/str/ft_strtolower.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strtolower.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:10:01 by cacharle #+# #+# */ +/* Updated: 2020/02/10 04:12:21 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" +#include "libft_ctype.h" + +char *ft_strtolower(char *s) +{ + int i; + + if (s == NULL) + return (NULL); + i = -1; + while (s[i]) + s[i] = ft_tolower(s[i]); + return (s); +} diff --git a/test_mini/libft/src/str/ft_strtoupper.c b/test_mini/libft/src/str/ft_strtoupper.c new file mode 100644 index 0000000..4a751d3 --- /dev/null +++ b/test_mini/libft/src/str/ft_strtoupper.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strtoupper.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/10 04:12:04 by cacharle #+# #+# */ +/* Updated: 2020/02/14 02:49:35 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_str.h" +#include "libft_ctype.h" + +char *ft_strtoupper(char *s) +{ + int i; + + if (s == NULL) + return (NULL); + i = -1; + while (s[i]) + s[i] = ft_toupper(s[i]); + return (s); +} diff --git a/test_mini/libft/src/str/ft_strtrim.c b/test_mini/libft/src/str/ft_strtrim.c new file mode 100644 index 0000000..aa48826 --- /dev/null +++ b/test_mini/libft/src/str/ft_strtrim.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strtrim.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/07 10:24:16 by cacharle #+# #+# */ +/* Updated: 2019/11/20 03:52:58 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_strtrim(char const *s1, char const *set) +{ + size_t start; + size_t len; + + if (s1 == NULL || set == NULL) + return (NULL); + start = 0; + while (s1[start] && ft_strchr(set, s1[start]) != NULL) + start++; + len = ft_strlen(&s1[start]); + if (len != 0) + while (s1[start + len - 1] + && ft_strchr(set, s1[start + len - 1]) != NULL) + len--; + return (ft_substr(s1, start, len)); +} diff --git a/test_mini/libft/src/str/ft_substr.c b/test_mini/libft/src/str/ft_substr.c new file mode 100644 index 0000000..ad9c706 --- /dev/null +++ b/test_mini/libft/src/str/ft_substr.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_substr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/10/17 08:28:49 by cacharle #+# #+# */ +/* Updated: 2020/02/14 03:44:42 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +char *ft_substr(char const *s, unsigned int start, size_t len) +{ + char *sub; + + if (s == NULL) + return (NULL); + if ((sub = (char*)malloc(sizeof(char) * (len + 1))) == NULL) + return (NULL); + if (start > ft_strlen(s)) + return (sub); + return (ft_strncpy(sub, s + start, len)); +} diff --git a/test_mini/libft/src/util/ft_split_destroy.c b/test_mini/libft/src/util/ft_split_destroy.c new file mode 100644 index 0000000..bc3f4e6 --- /dev/null +++ b/test_mini/libft/src/util/ft_split_destroy.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_split_destroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/27 16:30:55 by cacharle #+# #+# */ +/* Updated: 2020/02/27 17:52:31 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_util.h" + +void *ft_split_destroy(char **strs) +{ + int i; + + i = -1; + while (strs[++i] != NULL) + free(strs[i]); + free(strs); + return (NULL); +} diff --git a/test_mini/libft/src/vec/ft_vecdestroy.c b/test_mini/libft/src/vec/ft_vecdestroy.c new file mode 100644 index 0000000..781e02e --- /dev/null +++ b/test_mini/libft/src/vec/ft_vecdestroy.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vecdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:06:22 by charles #+# #+# */ +/* Updated: 2020/04/01 19:09:09 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Destroy a vector +** \param vec Vector to destroy +** \param del Delete function applied to each element of the vector +*/ + +void ft_vecdestroy(t_ftvec *vec, void (*del)(void *elem)) +{ + if (vec == NULL) + return ; + if (del != NULL) + ft_veciter(vec, del); + free(vec->data); + free(vec); +} diff --git a/test_mini/libft/src/vec/ft_vecgrow.c b/test_mini/libft/src/vec/ft_vecgrow.c new file mode 100644 index 0000000..bb8b8c7 --- /dev/null +++ b/test_mini/libft/src/vec/ft_vecgrow.c @@ -0,0 +1,43 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vecgrow.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:13:07 by charles #+# #+# */ +/* Updated: 2020/04/01 21:15:20 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Vector Growth factor +*/ + +#define FT_VEC_GROWTH_FACTOR 1.5 + +/* +** \brief Grow the vector capacity by a constant factor +** \param vec Vector to grow +** \return Passed vector of NULL on error +*/ + +t_ftvec *ft_vecgrow(t_ftvec *vec) +{ + size_t new_capacity; + void **new_data; + + if (vec->capacity <= 1) + new_capacity = 2; + else + new_capacity = vec->capacity * FT_VEC_GROWTH_FACTOR; + if ((new_data = (void**)malloc(sizeof(void*) * new_capacity)) == NULL) + return (NULL); + ft_memcpy(new_data, vec->data, vec->size); + free(vec->data); + vec->data = new_data; + vec->capacity = new_capacity; + return (vec); +} diff --git a/test_mini/libft/src/vec/ft_veciter.c b/test_mini/libft/src/vec/ft_veciter.c new file mode 100644 index 0000000..ec4a917 --- /dev/null +++ b/test_mini/libft/src/vec/ft_veciter.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_veciter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:09:51 by charles #+# #+# */ +/* Updated: 2020/04/01 20:15:13 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Iterate a function over elements of a vector +** \param vec Iterated vector +** \param f Function applied to each elements +*/ + +void ft_veciter(t_ftvec *vec, void (*f)(void *elem)) +{ + size_t i; + + i = 0; + while (i < vec->size) + { + f(vec->data[i]); + i++; + } +} diff --git a/test_mini/libft/src/vec/ft_vecnew.c b/test_mini/libft/src/vec/ft_vecnew.c new file mode 100644 index 0000000..8a8736a --- /dev/null +++ b/test_mini/libft/src/vec/ft_vecnew.c @@ -0,0 +1,38 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vecnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:03:49 by charles #+# #+# */ +/* Updated: 2020/04/01 20:00:00 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Create a new vector +** \param capacity Initial capacity of the underlying array +** Can't be lower than 1 +** \return Created vector or NULL on malloc error +*/ + +t_ftvec *ft_vecnew(size_t capacity) +{ + t_ftvec *vec; + + if ((vec = (t_ftvec*)malloc(sizeof(t_ftvec))) == NULL) + return (NULL); + if (capacity == 0) + capacity = 1; + if ((vec->data = (void**)malloc(sizeof(void*) * capacity)) == NULL) + { + free(vec); + return (NULL); + } + vec->capacity = capacity; + vec->size = 0; + return (vec); +} diff --git a/test_mini/libft/src/vec/ft_vecpop.c b/test_mini/libft/src/vec/ft_vecpop.c new file mode 100644 index 0000000..5b77b46 --- /dev/null +++ b/test_mini/libft/src/vec/ft_vecpop.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vecpop.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:26:27 by charles #+# #+# */ +/* Updated: 2020/04/01 20:26:34 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Pop last element of a vector +** \param vec Vector poped +** \param del Delete function applied to last element +*/ + +void ft_vecpop(t_ftvec *vec, void (*del)(void *elem)) +{ + if (vec->size == 0) + return ; + if (del != NULL) + del(vec->data[vec->size - 1]); + vec->size--; +} diff --git a/test_mini/libft/src/vec/ft_vecpush.c b/test_mini/libft/src/vec/ft_vecpush.c new file mode 100644 index 0000000..fc903ef --- /dev/null +++ b/test_mini/libft/src/vec/ft_vecpush.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vecpush.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:22:20 by charles #+# #+# */ +/* Updated: 2020/04/01 20:20:06 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Push element at the end of vector +** \param vec Vector where element will be pushed +** \param pushed Element to push +** \return Passed vector or NULL if couldnt grow vector +*/ + +t_ftvec *ft_vecpush(t_ftvec *vec, void *pushed) +{ + if (vec->capacity <= vec->size) + if (ft_vecgrow(vec) == NULL) + return (NULL); + vec->data[vec->size] = pushed; + vec->size++; + return (vec); +} diff --git a/test_mini/libft/src/vec/ft_vecremove.c b/test_mini/libft/src/vec/ft_vecremove.c new file mode 100644 index 0000000..d24ba29 --- /dev/null +++ b/test_mini/libft/src/vec/ft_vecremove.c @@ -0,0 +1,31 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_vecremove.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 22:45:07 by charles #+# #+# */ +/* Updated: 2020/04/01 22:58:21 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_vec.h" + +/* +** \brief Remove element from vector +** \param vec Vector to remove from +** \param i Index of the element to remove +** \param del Delete function applied to ith element +*/ + +void ft_vecremove(t_ftvec *vec, size_t i, void (*del)(void *elem)) +{ + if (vec->size == 0 || i > vec->size - 1) + return ; + if (del != NULL) + del(vec->data[i]); + ft_memmove(vec->data + i, vec->data + i + 1, + (vec->size - i - 1) * sizeof(void*)); + vec->size--; +} diff --git a/test_mini/libft/subject.pdf b/test_mini/libft/subject.pdf Binary files differnew file mode 100644 index 0000000..67a054c --- /dev/null +++ b/test_mini/libft/subject.pdf diff --git a/test_mini/libft/test/Makefile b/test_mini/libft/test/Makefile new file mode 100644 index 0000000..cf065c6 --- /dev/null +++ b/test_mini/libft/test/Makefile @@ -0,0 +1,79 @@ +# **************************************************************************** # +# # +# ::: :::::::: # +# Makefile :+: :+: :+: # +# +:+ +:+ +:+ # +# By: cacharle <marvin@42.fr> +#+ +:+ +#+ # +# +#+#+#+#+#+ +#+ # +# Created: 2020/02/15 04:35:44 by cacharle #+# #+# # +# Updated: 2020/02/28 12:13:30 by cacharle ### ########.fr # +# # +# **************************************************************************** # + +MAKE = make +MAKE_ARGS = --no-print-directory + +UNITY_DIR = ../vendor/_unity +LIBFT_DIR = .. + +SRC_DIR = src +INCLUDE_DIR = include + +CC = gcc +CCFLAGS = -I$(INCLUDE_DIR) -I$(UNITY_DIR)/include -I$(LIBFT_DIR)/include -Wall -Wextra #-Werror +LDFLAGS = -L$(UNITY_DIR) -lunity -L$(LIBFT_DIR) -lft + +NAME = libft_test + +INCLUDE = $(shell find $(INCLUDE_DIR) -type f -name "*.h") +SRC = $(shell find $(SRC_DIR) -type f -name "*.c") +OBJ = $(SRC:.c=.o) + + +all: unity_all $(NAME) + +run: all + @echo "Test: Running" + @./$(NAME) + +run_v: all + @echo "Test: Running" + @./$(NAME) -v + +run_s: all + @echo "Test: Running" + @./$(NAME) -s + +$(NAME): libft_all $(OBJ) + @echo "Test: Linking: $@" + @$(CC) -o $@ $(OBJ) $(LDFLAGS) + +%.o: %.c $(INCLUDE) $(LIBFT_SRC) + @echo "Test: Compiling: $@" + @$(CC) $(CCFLAGS) -c -o $@ $< + +clean: + @echo "Test: Removing object" + @$(RM) $(OBJ) + +clean_dep: unity_fclean libft_fclean + +fclean: clean + @echo "Test: Removing executable" + @$(RM) $(NAME) + +re: fclean all + +re_dep: clean_dep fclean all + +unity_all: + @$(MAKE) $(MAKE_ARGS) -s -C $(UNITY_DIR) all + +unity_fclean: + @$(MAKE) $(MAKE_ARGS) -s -C $(UNITY_DIR) fclean + +libft_all: + @$(MAKE) $(MAKE_ARGS) -s -C $(LIBFT_DIR) all + +libft_fclean: + @$(MAKE) $(MAKE_ARGS) -s -C $(LIBFT_DIR) fclean diff --git a/test_mini/libft/test/include/helper/helper_segfault.h b/test_mini/libft/test/include/helper/helper_segfault.h new file mode 100644 index 0000000..d638a70 --- /dev/null +++ b/test_mini/libft/test/include/helper/helper_segfault.h @@ -0,0 +1,20 @@ +#ifndef HELPER_SEGFAULT_H +# define HELPER_SEGFAULT_H + +extern int helper_segfault_pid; + +# define TEST_ASSERT_SEGFAULT(code) do { \ + fflush(stdout); \ + if ((helper_segfault_pid = fork()) < 0) \ + exit(EXIT_FAILURE); \ + if (helper_segfault_pid == 0) \ + { \ + do { code; } while (0); \ + exit(EXIT_FAILURE); \ + } \ + wait(&helper_segfault_pid); \ + if (WIFSIGNALED(helper_segfault_pid)) \ + TEST_FAIL_MESSAGE("Segfault"); \ +} while (0) + +#endif diff --git a/test_mini/libft/test/include/libft_test.h b/test_mini/libft/test/include/libft_test.h new file mode 100644 index 0000000..efa15cd --- /dev/null +++ b/test_mini/libft/test/include/libft_test.h @@ -0,0 +1,27 @@ +#ifndef LIBFT_TEST_H +# define LIBFT_TEST_H + +# include <string.h> +# include <ctype.h> +# include <sys/wait.h> +# ifdef __APPLE__ +# include <malloc/malloc.h> +# endif + +# include "unity.h" +# include "unity_fixture.h" + +# undef free +# undef malloc + +# include <stdlib.h> + +# include "libft.h" +# include "libft_algo.h" +# include "libft_lst.h" +# include "libft_ht.h" +# include "libft_vec.h" + +# include "helper/helper_segfault.h" + +#endif diff --git a/test_mini/libft/test/src/algo/test_ft_bsearch.c b/test_mini/libft/test/src/algo/test_ft_bsearch.c new file mode 100644 index 0000000..27858ee --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_bsearch.c @@ -0,0 +1,55 @@ +#include "libft_test.h" + +TEST_GROUP(ft_bsearch); + +TEST_SETUP(ft_bsearch) +{} + +TEST_TEAR_DOWN(ft_bsearch) +{} + +TEST(ft_bsearch, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + t_ftsearch_const consts; + + int a = 189; + consts.key = &a; + consts.compar = ft_compar_int; + + size_t nelp = sizeof(arr) / sizeof(int); + qsort(arr, nelp, sizeof(int), ft_compar_int); + + void *ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int b = 123; + consts.key = &b; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_NULL(ptr); + + int c = -134; + consts.key = &c; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int e = 1; + consts.key = &e; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int d = -1; + consts.key = &d; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int f = 34; + consts.key = &f; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int g = 7; + consts.key = &g; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); +} diff --git a/test_mini/libft/test/src/algo/test_ft_compar_int.c b/test_mini/libft/test/src/algo/test_ft_compar_int.c new file mode 100644 index 0000000..39cc322 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_compar_int.c @@ -0,0 +1,20 @@ +#include "libft_test.h" + +TEST_GROUP(ft_compar_int); + +TEST_SETUP(ft_compar_int) +{} + +TEST_TEAR_DOWN(ft_compar_int) +{} + +TEST(ft_compar_int, basic) +{ + int a = 4; + int b = 3; + + TEST_ASSERT_GREATER_THAN(0, ft_compar_int(&a, &b)); + TEST_ASSERT_LESS_THAN(0, ft_compar_int(&b, &a)); + TEST_ASSERT_EQUAL(0, ft_compar_int(&a, &a)); + TEST_ASSERT_EQUAL(0, ft_compar_int(&b, &b)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_heapsort.c b/test_mini/libft/test/src/algo/test_ft_heapsort.c new file mode 100644 index 0000000..6c2c3fb --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_heapsort.c @@ -0,0 +1,27 @@ +#include "libft_test.h" + +TEST_GROUP(ft_heapsort); + +TEST_SETUP(ft_heapsort) +{} + +TEST_TEAR_DOWN(ft_heapsort) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_heapsort, basic) +{ + TEST_IGNORE(); + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int sorted_arr[sizeof(arr)]; + + memcpy(sorted_arr, arr, sizeof(arr)); + qsort(sorted_arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + + ft_heapsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_is_set.c b/test_mini/libft/test/src/algo/test_ft_is_set.c new file mode 100644 index 0000000..604ec53 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_is_set.c @@ -0,0 +1,23 @@ +#include "libft_test.h" + +TEST_GROUP(ft_is_set); + +TEST_SETUP(ft_is_set) +{} + +TEST_TEAR_DOWN(ft_is_set) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_is_set, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int unique_arr[] = {3, 4, 2, 189, -1, -134, 7, 1, 34}; + + TEST_ASSERT_FALSE(ft_is_set(arr, sizeof(arr) / sizeof(int), sizeof(int), compar)); + TEST_ASSERT_TRUE(ft_is_set(unique_arr, sizeof(unique_arr) / sizeof(int), sizeof(int), compar)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_lfind.c b/test_mini/libft/test/src/algo/test_ft_lfind.c new file mode 100644 index 0000000..0080d55 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_lfind.c @@ -0,0 +1,38 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lfind); + +TEST_SETUP(ft_lfind) +{} + +TEST_TEAR_DOWN(ft_lfind) +{} + +TEST(ft_lfind, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + t_ftsearch_const consts; + + int a = 189; + consts.key = &a; + consts.compar = ft_compar_int; + + size_t nelp = sizeof(arr) / sizeof(int); + void *ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 5, ptr); + + int b = 123; + consts.key = &b; + ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_NULL(ptr); + + int c = 34; + consts.key = &c; + ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 10, ptr); + + int d = 3; + consts.key = &d; + ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr, ptr); +} diff --git a/test_mini/libft/test/src/algo/test_ft_lsearch.c b/test_mini/libft/test/src/algo/test_ft_lsearch.c new file mode 100644 index 0000000..13fae13 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_lsearch.c @@ -0,0 +1,52 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lsearch); + +TEST_SETUP(ft_lsearch) +{} + +TEST_TEAR_DOWN(ft_lsearch) +{} + +TEST(ft_lsearch, basic) +{ + int arr[32] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + t_ftsearch_const consts; + + int a = 189; + consts.key = &a; + consts.compar = ft_compar_int; + + size_t nelp = 11; + void *ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 5, ptr); + + int c = 34; + consts.key = &c; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 10, ptr); + + int d = 3; + consts.key = &d; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr, ptr); + + int b = 123; + consts.key = &b; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL(12, nelp); + TEST_ASSERT_EQUAL(123, arr[11]); + TEST_ASSERT_EQUAL_PTR(arr + 11, ptr); + + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL(12, nelp); + TEST_ASSERT_EQUAL(123, arr[11]); + TEST_ASSERT_EQUAL_PTR(arr + 11, ptr); + + int e = 1234; + consts.key = &e; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL(13, nelp); + TEST_ASSERT_EQUAL(1234, arr[12]); + TEST_ASSERT_EQUAL_PTR(arr + 12, ptr); +} diff --git a/test_mini/libft/test/src/algo/test_ft_mergesort.c b/test_mini/libft/test/src/algo/test_ft_mergesort.c new file mode 100644 index 0000000..567e31d --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_mergesort.c @@ -0,0 +1,26 @@ +#include "libft_test.h" + +TEST_GROUP(ft_mergesort); + +TEST_SETUP(ft_mergesort) +{} + +TEST_TEAR_DOWN(ft_mergesort) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_mergesort, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int sorted_arr[sizeof(arr)]; + + memcpy(sorted_arr, arr, sizeof(arr)); + qsort(sorted_arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + + ft_mergesort(arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_qsort.c b/test_mini/libft/test/src/algo/test_ft_qsort.c new file mode 100644 index 0000000..25a5ef6 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_qsort.c @@ -0,0 +1,26 @@ +#include "libft_test.h" + +TEST_GROUP(ft_qsort); + +TEST_SETUP(ft_qsort) +{} + +TEST_TEAR_DOWN(ft_qsort) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_qsort, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int sorted_arr[sizeof(arr)]; + + memcpy(sorted_arr, arr, sizeof(arr)); + qsort(sorted_arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + + ft_qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_reverse.c b/test_mini/libft/test/src/algo/test_ft_reverse.c new file mode 100644 index 0000000..feca520 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_reverse.c @@ -0,0 +1,19 @@ +#include "libft_test.h" + +TEST_GROUP(ft_reverse); + +TEST_SETUP(ft_reverse) +{} + +TEST_TEAR_DOWN(ft_reverse) +{} + +TEST(ft_reverse, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int rev_arr[] = {34, 1, 7, -134, -1, 189, 7, 2, 1, 4, 3}; + + ft_reverse(arr, sizeof(arr) / sizeof(int), sizeof(int)); + TEST_ASSERT_EQUAL_INT_ARRAY(rev_arr, arr, sizeof(arr) / sizeof(int)); + +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isalnum.c b/test_mini/libft/test/src/ctype/test_ft_isalnum.c new file mode 100644 index 0000000..0019a03 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isalnum.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isalnum); + +TEST_SETUP(ft_isalnum) +{} + +TEST_TEAR_DOWN(ft_isalnum) +{} + +TEST(ft_isalnum, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isalnum(i), !!ft_isalnum(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isalpha.c b/test_mini/libft/test/src/ctype/test_ft_isalpha.c new file mode 100644 index 0000000..9846985 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isalpha.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isalpha); + +TEST_SETUP(ft_isalpha) +{} + +TEST_TEAR_DOWN(ft_isalpha) +{} + +TEST(ft_isalpha, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isalpha(i), !!ft_isalpha(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isascii.c b/test_mini/libft/test/src/ctype/test_ft_isascii.c new file mode 100644 index 0000000..c052571 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isascii.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isascii); + +TEST_SETUP(ft_isascii) +{} + +TEST_TEAR_DOWN(ft_isascii) +{} + +TEST(ft_isascii, base) +{ + for (int i = 0; i < UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isascii(i), !!ft_isascii(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isblank.c b/test_mini/libft/test/src/ctype/test_ft_isblank.c new file mode 100644 index 0000000..3c8460f --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isblank.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isblank); + +TEST_SETUP(ft_isblank) +{} + +TEST_TEAR_DOWN(ft_isblank) +{} + +TEST(ft_isblank, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isblank(i), !!ft_isblank(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isdigit.c b/test_mini/libft/test/src/ctype/test_ft_isdigit.c new file mode 100644 index 0000000..74c210b --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isdigit.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isdigit); + +TEST_SETUP(ft_isdigit) +{} + +TEST_TEAR_DOWN(ft_isdigit) +{} + +TEST(ft_isdigit, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isdigit(i), !!ft_isdigit(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isprint.c b/test_mini/libft/test/src/ctype/test_ft_isprint.c new file mode 100644 index 0000000..0f15661 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isprint.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isprint); + +TEST_SETUP(ft_isprint) +{} + +TEST_TEAR_DOWN(ft_isprint) +{} + +TEST(ft_isprint, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isprint(i), !!ft_isprint(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isspace.c b/test_mini/libft/test/src/ctype/test_ft_isspace.c new file mode 100644 index 0000000..f94a1ea --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isspace.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isspace); + +TEST_SETUP(ft_isspace) +{} + +TEST_TEAR_DOWN(ft_isspace) +{} + +TEST(ft_isspace, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isspace(i), !!ft_isspace(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_todigit.c b/test_mini/libft/test/src/ctype/test_ft_todigit.c new file mode 100644 index 0000000..cd8d9f3 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_todigit.c @@ -0,0 +1,20 @@ +#include "libft_test.h" + +TEST_GROUP(ft_todigit); + +TEST_SETUP(ft_todigit) +{} + +TEST_TEAR_DOWN(ft_todigit) +{} + +TEST(ft_todigit, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + { + if (isdigit(i)) + TEST_ASSERT_EQUAL(i - '0', ft_todigit(i)); + else + TEST_ASSERT_EQUAL(-1, ft_todigit(i)); + } +} diff --git a/test_mini/libft/test/src/ctype/test_ft_tolower.c b/test_mini/libft/test/src/ctype/test_ft_tolower.c new file mode 100644 index 0000000..9465544 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_tolower.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_tolower); + +TEST_SETUP(ft_tolower) +{} + +TEST_TEAR_DOWN(ft_tolower) +{} + +TEST(ft_tolower, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(tolower(i), ft_tolower(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_toupper.c b/test_mini/libft/test/src/ctype/test_ft_toupper.c new file mode 100644 index 0000000..b23c08b --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_toupper.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_toupper); + +TEST_SETUP(ft_toupper) +{} + +TEST_TEAR_DOWN(ft_toupper) +{} + +TEST(ft_toupper, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(toupper(i), ft_toupper(i)); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htdelone.c b/test_mini/libft/test/src/ht/test_ft_htdelone.c new file mode 100644 index 0000000..5ba4822 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htdelone.c @@ -0,0 +1,68 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/19 02:08:00 by cacharle #+# #+# */ +/* Updated: 2020/02/19 02:46:10 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htdelone); + +TEST_SETUP(ft_htdelone) +{} + +TEST_TEAR_DOWN(ft_htdelone) +{} + +static void st_del(t_ftht_entry *v) +{ + free(v->key); + free(v); +} + +TEST(ft_htdelone, basic) +{ + t_ftht *ht = ft_htnew(3); + + ft_htset(ht, "bonjour", "je", st_del); + ft_htset(ht, "a", "yay", st_del); + ft_htset(ht, "b", "aasdf", st_del); + ft_htset(ht, "c", "a", st_del); + ft_htset(ht, "d", "dd", st_del); + + ft_htdelone(ht, "bonjour", st_del); + void *ptr = ft_htget(ht, "bonjour"); + TEST_ASSERT_NULL(ptr); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "a")); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "b")); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "c")); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "d")); + + ft_htdelone(ht, "a", st_del); + ptr = ft_htget(ht, "a"); + TEST_ASSERT_NULL(ptr); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "b")); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "c")); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "d")); + + ft_htdelone(ht, "b", st_del); + ptr = ft_htget(ht, "b"); + TEST_ASSERT_NULL(ptr); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "c")); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "d")); + + ft_htdelone(ht, "c", st_del); + ptr = ft_htget(ht, "c"); + TEST_ASSERT_NULL(ptr); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "d")); + + ft_htdelone(ht, "d", st_del); + ptr = ft_htget(ht, "d"); + TEST_ASSERT_NULL(ptr); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htdestroy.c b/test_mini/libft/test/src/ht/test_ft_htdestroy.c new file mode 100644 index 0000000..1512a48 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htdestroy.c @@ -0,0 +1,38 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/19 02:45:27 by cacharle #+# #+# */ +/* Updated: 2020/02/19 02:49:36 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htdestroy); + +TEST_SETUP(ft_htdestroy) +{} + +TEST_TEAR_DOWN(ft_htdestroy) +{} + +static void st_del(t_ftht_entry *v) +{ + free(v->key); + free(v); +} + +TEST(ft_htdestroy, basic) +{ + t_ftht *ht = ft_htnew(2); + + ft_htset(ht, "a", "1", st_del); + ft_htset(ht, "b", "2", st_del); + ft_htset(ht, "c", "3", st_del); + ft_htset(ht, "d", "4", st_del); + ft_htdestroy(ht, st_del); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htget.c b/test_mini/libft/test/src/ht/test_ft_htget.c new file mode 100644 index 0000000..386c3dc --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htget.c @@ -0,0 +1,114 @@ +#include "libft_test.h" + +TEST_GROUP(ft_htget); + +static t_ftht *ht; + +TEST_SETUP(ft_htget) +{ + ht = ft_htnew(10); +} + +TEST_TEAR_DOWN(ft_htget) +{ + /* ft_htdestroy_key(ht); */ +} + +int helper_segfault_pid; + +static void st_del(t_ftht_entry *c) +{ + free(c->key); + free(c); +} + +TEST(ft_htget, segfault) +{ + TEST_ASSERT_SEGFAULT(ft_htget((t_ftht*)NULL, "")); + TEST_ASSERT_SEGFAULT(ft_htget(ft_htnew(1), (char*)NULL)); + TEST_ASSERT_SEGFAULT(ft_htget(ft_htnew(1), "")); + TEST_ASSERT_SEGFAULT(ft_htget(ft_htnew(1), "asdkfhjaklsdfhahjsdfk")); +} + +TEST(ft_htget, error_null) +{ + TEST_ASSERT_NULL(ft_htget(NULL, NULL)); + TEST_ASSERT_NULL(ft_htget(ht, NULL)); + TEST_ASSERT_NULL(ft_htget(NULL, "")); + TEST_ASSERT_NULL(ft_htget(ht, "")); + TEST_ASSERT_NULL(ft_htget(ht, "hi")); + TEST_ASSERT_NULL(ft_htget(ht, "asdfkasdflk")); + TEST_ASSERT_NULL(ft_htget(ht, "asdhfalsdhflahsdfhjasklehjfklwhjekrlanklshasdfkasdflk")); +} + +TEST(ft_htget, basic) +{ + ft_htset(ht, strdup("a"), strdup("data1"), st_del); + ft_htset(ht, strdup("b"), strdup("data2"), st_del); + ft_htset(ht, strdup("c"), strdup("data3"), st_del); + + char *s = ft_htget(ht, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data1"); + + s = ft_htget(ht, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data2"); + + s = ft_htget(ht, "c"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data3"); + + ft_htset(ht, strdup("a"), strdup("bonjour1"), st_del); + ft_htset(ht, strdup("b"), strdup("bonjour2"), st_del); + ft_htset(ht, strdup("c"), strdup("bonjour3"), st_del); + + s = ft_htget(ht, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour1"); + + s = ft_htget(ht, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour2"); + + s = ft_htget(ht, "c"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour3"); +} + +TEST(ft_htget, collision) +{ + t_ftht *small = ft_htnew(1); + + ft_htset(small, strdup("a"), strdup("data1"), st_del); + ft_htset(small, strdup("b"), strdup("data2"), st_del); + ft_htset(small, strdup("c"), strdup("data3"), st_del); + + char *s = ft_htget(small, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data1"); + + s = ft_htget(small, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data2"); + + s = ft_htget(small, "c"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data3"); + + ft_htset(small, strdup("a"), strdup("bonjour1"), st_del); + ft_htset(small, strdup("b"), strdup("bonjour2"), st_del); + ft_htset(small, strdup("c"), strdup("bonjour3"), st_del); + + s = ft_htget(small, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour1"); + + s = ft_htget(small, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour2"); + + s = ft_htget(small, "c"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour3"); +} diff --git a/test_mini/libft/test/src/ht/test_ft_hthash.c b/test_mini/libft/test/src/ht/test_ft_hthash.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_hthash.c diff --git a/test_mini/libft/test/src/ht/test_ft_htnew.c b/test_mini/libft/test/src/ht/test_ft_htnew.c new file mode 100644 index 0000000..17bca6a --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htnew.c @@ -0,0 +1,48 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/12 22:30:06 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:15:32 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htnew); + +TEST_SETUP(ft_htnew) +{} + +TEST_TEAR_DOWN(ft_htnew) +{} + +int helper_segfault_pid; + +TEST(ft_htnew, segfault) +{ + TEST_ASSERT_SEGFAULT(ft_htnew(10)); + TEST_ASSERT_SEGFAULT(ft_htnew(0)); + TEST_ASSERT_SEGFAULT(ft_htnew((1 << 14) + 1)); +} + +TEST(ft_htnew, error_null) +{ + TEST_ASSERT_NOT_NULL(ft_htnew(10)); + TEST_ASSERT_NULL(ft_htnew(0)); +} + +TEST(ft_htnew, happy_path) +{ + t_ftht *ht; + + ht = ft_htnew(10); + TEST_ASSERT_NOT_NULL(ht); + TEST_ASSERT_EQUAL(10, ht->size); + TEST_ASSERT_NOT_NULL(ht->buckets); + for (t_ftsize i = 0; i < ht->size; i++) + TEST_ASSERT_NULL(ht->buckets[i]); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htset.c b/test_mini/libft/test/src/ht/test_ft_htset.c new file mode 100644 index 0000000..96d848e --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htset.c @@ -0,0 +1,100 @@ +#include "libft_test.h" + +TEST_GROUP(ft_htset); + +static t_ftht *ht; + +TEST_SETUP(ft_htset) +{ + ht = ft_htnew(10); +} + +TEST_TEAR_DOWN(ft_htset) +{ + /* ft_htdestroy_key(ht); */ +} + +static void st_del(t_ftht_entry *c) +{ + free(c->key); + free(c); +} + +TEST(ft_htset, segfault) +{ + TEST_ASSERT_SEGFAULT(ft_htset(NULL, "", strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), NULL, strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "", NULL, NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "", strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "hi", strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "asdfasdfasdc", strdup(""), NULL)); +} + +TEST(ft_htset, error_null) +{ + TEST_ASSERT_NULL(ft_htset(NULL, "", strdup("1"), NULL)); + TEST_ASSERT_NULL(ft_htset(ht, NULL, strdup("2"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "", strdup("3"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "a", strdup("4"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "b", strdup("5"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "c", strdup("6"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "d", strdup("7"), NULL)); +} + +TEST(ft_htset, happy_path) +{ + t_ftht_entry *content = ft_htset(ht, "bonjour", strdup("content"), NULL); + TEST_ASSERT_NOT_NULL(content); + TEST_ASSERT_NOT_NULL(content->key); + TEST_ASSERT_NOT_NULL(content->value); + TEST_ASSERT_EQUAL_STRING(content->key, "bonjour"); + TEST_ASSERT_EQUAL_STRING(content->value, "content"); +} + +TEST(ft_htset, reset) +{ + t_ftht *small = NULL; + + small = ft_htnew(3); + + t_ftht_entry *content = ft_htset(small, "bonjour", ft_strdup("content"), st_del); + TEST_ASSERT_NOT_NULL(content); + TEST_ASSERT_NOT_NULL(content->key); + TEST_ASSERT_NOT_NULL(content->value); + TEST_ASSERT_EQUAL_STRING(content->key, "bonjour"); + TEST_ASSERT_EQUAL_STRING(content->value, "content"); + + t_ftht_entry *content_re = ft_htset(small, "bonjour", ft_strdup("yo"), st_del); + TEST_ASSERT_NOT_NULL(content_re); + TEST_ASSERT_NOT_NULL(content_re->key); + TEST_ASSERT_NOT_NULL(content_re->value); + TEST_ASSERT_EQUAL_STRING("bonjour", content_re->key); + TEST_ASSERT_EQUAL_STRING("yo", content_re->value); +} + +TEST(ft_htset, collision) +{ + t_ftht *small = NULL; + small = ft_htnew(1); + + t_ftht_entry *content1 = ft_htset(small, "bonjour", strdup("content1"), st_del); + TEST_ASSERT_NOT_NULL(content1); + TEST_ASSERT_NOT_NULL(content1->key); + TEST_ASSERT_NOT_NULL(content1->value); + TEST_ASSERT_EQUAL_STRING(content1->key, "bonjour"); + TEST_ASSERT_EQUAL_STRING(content1->value, "content1"); + + t_ftht_entry *content2 = ft_htset(small, "aurevoir", strdup("content2"), st_del); + TEST_ASSERT_NOT_NULL(content2); + TEST_ASSERT_NOT_NULL(content2->key); + TEST_ASSERT_NOT_NULL(content2->value); + TEST_ASSERT_EQUAL_STRING(content2->key, "aurevoir"); + TEST_ASSERT_EQUAL_STRING(content2->value, "content2"); + + t_ftht_entry *content3 = ft_htset(small, "aloa", strdup("content3"), st_del); + TEST_ASSERT_NOT_NULL(content3); + TEST_ASSERT_NOT_NULL(content3->key); + TEST_ASSERT_NOT_NULL(content3->value); + TEST_ASSERT_EQUAL_STRING(content3->key, "aloa"); + TEST_ASSERT_EQUAL_STRING(content3->value, "content3"); +} diff --git a/test_mini/libft/test/src/ht/test_ftht_entry_new.c b/test_mini/libft/test/src/ht/test_ftht_entry_new.c new file mode 100644 index 0000000..a566600 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ftht_entry_new.c @@ -0,0 +1,43 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htentry_new.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/17 04:07:04 by cacharle #+# #+# */ +/* Updated: 2020/02/17 04:15:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htentry_new); + +TEST_SETUP(ft_htentry_new) +{} + +TEST_TEAR_DOWN(ft_htentry_new) +{} + +TEST(ft_htentry_new, basic) +{ + t_ftht_entry *c = NULL; + + char *k = "bonjour"; + c = ft_htentry_new(k, NULL); + TEST_ASSERT_NOT_NULL(c); + TEST_ASSERT(k != c->key); + TEST_ASSERT_EQUAL_STRING(k, c->key); + TEST_ASSERT_NULL(c->value); + + c = ft_htentry_new(k, k); + TEST_ASSERT_NOT_NULL(c); + TEST_ASSERT(k != c->key); + TEST_ASSERT_EQUAL_STRING(k, c->key); + TEST_ASSERT_EQUAL_PTR(k, c->value); + TEST_ASSERT_EQUAL_STRING(k, (char*)c->value); + + /* free(c->key); */ + /* free(c); */ +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstbsearch.c b/test_mini/libft/test/src/lst/test_ft_lstbsearch.c new file mode 100644 index 0000000..81f2578 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstbsearch.c @@ -0,0 +1,37 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstbsearch); + +TEST_SETUP(ft_lstbsearch) +{} + +TEST_TEAR_DOWN(ft_lstbsearch) +{} + +TEST(ft_lstbsearch, basic) +{ + t_ftlst *found = NULL; + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + + found = ft_lstbsearch(lst, ft_compar_int, &c); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &c); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &b); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &a); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &d); + TEST_ASSERT_NULL(found); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstdelone.c b/test_mini/libft/test/src/lst/test_ft_lstdelone.c new file mode 100644 index 0000000..881a93b --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstdelone.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_lstdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/19 02:01:33 by cacharle #+# #+# */ +/* Updated: 2020/02/19 02:07:27 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_lstdelone); + +TEST_SETUP(ft_lstdelone) +{} + +TEST_TEAR_DOWN(ft_lstdelone) +{} + +TEST(ft_lstdelone, basic) +{ + TEST_PASS(); // how to test free? +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstdestroy.c b/test_mini/libft/test/src/lst/test_ft_lstdestroy.c new file mode 100644 index 0000000..e7b98c5 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstdestroy.c @@ -0,0 +1,14 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstdestroy); + +TEST_SETUP(ft_lstdestroy) +{} + +TEST_TEAR_DOWN(ft_lstdestroy) +{} + +TEST(ft_lstdestroy, basic) +{ + TEST_PASS(); // how to test free? +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstiter.c b/test_mini/libft/test/src/lst/test_ft_lstiter.c new file mode 100644 index 0000000..53b1380 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstiter.c @@ -0,0 +1,52 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstiter); + +TEST_SETUP(ft_lstiter) +{} + +TEST_TEAR_DOWN(ft_lstiter) +{} + +static void square_iter_func(void *data) +{ + int *d = (int*)data; + + *d = *d * *d; +} + +TEST(ft_lstiter, basic) +{ + t_ftlst *lst = NULL; + int a = 2; + int b = 3; + int c = 4; + int d = 5; + + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_EQUAL(4, *(int*)lst->data); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_EQUAL(9, *(int*)lst->data); + TEST_ASSERT_EQUAL(16, *(int*)lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_EQUAL(16, *(int*)lst->data); + TEST_ASSERT_EQUAL(81, *(int*)lst->next->data); + TEST_ASSERT_EQUAL(256, *(int*)lst->next->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&d)); + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_EQUAL(25, *(int*)lst->data); + TEST_ASSERT_EQUAL(256, *(int*)lst->next->data); + TEST_ASSERT_EQUAL(81 * 81, *(int*)lst->next->next->data); + TEST_ASSERT_EQUAL(256 * 256, *(int*)lst->next->next->next->data); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstlast.c b/test_mini/libft/test/src/lst/test_ft_lstlast.c new file mode 100644 index 0000000..82c8096 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstlast.c @@ -0,0 +1,29 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstlast); + +TEST_SETUP(ft_lstlast) +{} + +TEST_TEAR_DOWN(ft_lstlast) +{} + +TEST(ft_lstlast, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL_PTR(lst, ft_lstlast(lst)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + TEST_ASSERT_EQUAL_PTR(lst->next, ft_lstlast(lst)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + TEST_ASSERT_EQUAL_PTR(lst->next->next, ft_lstlast(lst)); + ft_lstpush_front(&lst, ft_lstnew(&d)); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, ft_lstlast(lst)); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstlfind.c b/test_mini/libft/test/src/lst/test_ft_lstlfind.c new file mode 100644 index 0000000..1851436 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstlfind.c @@ -0,0 +1,55 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_lstlfind.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/17 03:08:15 by cacharle #+# #+# */ +/* Updated: 2020/02/17 03:34:40 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_lstlfind); + +TEST_SETUP(ft_lstlfind) +{} + +TEST_TEAR_DOWN(ft_lstlfind) +{} + +TEST(ft_lstlfind, basic) +{ + t_ftlst *found = NULL; + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + + found = ft_lstlfind(lst, ft_compar_int, &c); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found); + found = ft_lstlfind(lst, ft_compar_int, &c); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found); + + found = ft_lstlfind(lst, ft_compar_int, &b); + TEST_ASSERT_EQUAL_PTR(lst->next->next, found); + + found = ft_lstlfind(lst, ft_compar_int, &a); + TEST_ASSERT_EQUAL_PTR(lst, found); + + found = ft_lstlfind(lst, ft_compar_int, &d); + TEST_ASSERT_NULL(found); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstlsearch.c b/test_mini/libft/test/src/lst/test_ft_lstlsearch.c new file mode 100644 index 0000000..83a8f4e --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstlsearch.c @@ -0,0 +1,55 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_lstlsearch.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/17 03:21:46 by cacharle #+# #+# */ +/* Updated: 2020/02/17 03:35:37 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_lstlsearch); + +TEST_SETUP(ft_lstlsearch) +{} + +TEST_TEAR_DOWN(ft_lstlsearch) +{} + +TEST(ft_lstlsearch, basic) +{ + t_ftlst *found = NULL; + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + + found = ft_lstlsearch(lst, ft_compar_int, &c); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found); + found = ft_lstlsearch(lst, ft_compar_int, &c); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found); + + found = ft_lstlsearch(lst, ft_compar_int, &b); + TEST_ASSERT_EQUAL_PTR(lst->next->next, found); + + found = ft_lstlsearch(lst, ft_compar_int, &a); + TEST_ASSERT_EQUAL_PTR(lst, found); + + found = ft_lstlsearch(lst, ft_compar_int, &d); + TEST_ASSERT_EQUAL_PTR(ft_lstlast(lst), found); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstmap.c b/test_mini/libft/test/src/lst/test_ft_lstmap.c new file mode 100644 index 0000000..53c2f7a --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstmap.c @@ -0,0 +1,82 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstmap); + +TEST_SETUP(ft_lstmap) +{} + +TEST_TEAR_DOWN(ft_lstmap) +{} + +static void *f_square(void *data) +{ + int *d = malloc(sizeof(int)); + + *d = *(int*)data; + *d = *d * *d; + return d; +} + +TEST(ft_lstmap, basic) +{ + t_ftlst *lst = NULL; + t_ftlst *mapped = NULL; + int a = 2; + int b = 3; + int c = 4; + int d = 5; + + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NULL(mapped); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + TEST_ASSERT_NOT_NULL(mapped->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->data); + TEST_ASSERT_NULL(mapped->next); + ft_lstdestroy(&mapped, free); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + TEST_ASSERT_NOT_NULL(mapped->data); + TEST_ASSERT_EQUAL(9, *(int*)mapped->data); + TEST_ASSERT_NOT_NULL(mapped->next); + TEST_ASSERT_NOT_NULL(mapped->next->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->next->data); + TEST_ASSERT_NULL(mapped->next->next); + ft_lstdestroy(&mapped, free); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + TEST_ASSERT_NOT_NULL(mapped->data); + TEST_ASSERT_EQUAL(16, *(int*)mapped->data); + TEST_ASSERT_NOT_NULL(mapped->next); + TEST_ASSERT_NOT_NULL(mapped->next->data); + TEST_ASSERT_EQUAL(9, *(int*)mapped->next->data); + TEST_ASSERT_NOT_NULL(mapped->next->next); + TEST_ASSERT_NOT_NULL(mapped->next->next->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->data); + TEST_ASSERT_NULL(mapped->next->next->next); + ft_lstdestroy(&mapped, free); + + ft_lstpush_front(&lst, ft_lstnew(&d)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + TEST_ASSERT_NOT_NULL(mapped->data); + TEST_ASSERT_EQUAL(25, *(int*)mapped->data); + TEST_ASSERT_NOT_NULL(mapped->next); + TEST_ASSERT_NOT_NULL(mapped->next->data); + TEST_ASSERT_EQUAL(16, *(int*)mapped->next->data); + TEST_ASSERT_NOT_NULL(mapped->next->next); + TEST_ASSERT_NOT_NULL(mapped->next->next->data); + TEST_ASSERT_EQUAL(9, *(int*)mapped->next->next->data); + TEST_ASSERT_NOT_NULL(mapped->next->next->next); + TEST_ASSERT_NOT_NULL(mapped->next->next->next->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->next->data); + ft_lstdestroy(&mapped, free); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstnew.c b/test_mini/libft/test/src/lst/test_ft_lstnew.c new file mode 100644 index 0000000..518c885 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstnew.c @@ -0,0 +1,25 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstnew); + +TEST_SETUP(ft_lstnew) +{} + +TEST_TEAR_DOWN(ft_lstnew) +{} + +TEST(ft_lstnew, basic) +{ + t_ftlst *lst; + int a = 4; + + lst = ft_lstnew(&a); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL(a, *(int*)lst->data); + + /* free(lst); */ + lst = ft_lstnew(NULL); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_NULL(lst->data); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstpop_front.c b/test_mini/libft/test/src/lst/test_ft_lstpop_front.c new file mode 100644 index 0000000..827afe6 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstpop_front.c @@ -0,0 +1,31 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstpop_front); + +TEST_SETUP(ft_lstpop_front) +{} + +TEST_TEAR_DOWN(ft_lstpop_front) +{} + +TEST(ft_lstpop_front, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + + ft_lstpop_front(&lst, NULL); + TEST_ASSERT_EQUAL_PTR(&b, lst->data); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + + ft_lstpop_front(&lst, NULL); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + + ft_lstpop_front(&lst, NULL); + TEST_ASSERT_NULL(lst); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstpush_back.c b/test_mini/libft/test/src/lst/test_ft_lstpush_back.c new file mode 100644 index 0000000..9f0d97b --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstpush_back.c @@ -0,0 +1,41 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstpush_back); + +TEST_SETUP(ft_lstpush_back) +{} + +TEST_TEAR_DOWN(ft_lstpush_back) +{} + +TEST(ft_lstpush_back, basic) +{ + t_ftlst *lst; + int a = 1; + int b = 2; + int c = 2; + + lst = ft_lstnew(&a); + TEST_ASSERT_NOT_NULL(lst); + + ft_lstpush_back(&lst, ft_lstnew(&b)); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL(a, *(int*)lst->data); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + TEST_ASSERT_EQUAL(b, *(int*)lst->next->data); + + ft_lstpush_back(&lst, ft_lstnew(&c)); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL(a, *(int*)lst->data); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + TEST_ASSERT_EQUAL(b, *(int*)lst->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next); + TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->data); + TEST_ASSERT_EQUAL(c, *(int*)lst->next->next->data); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstpush_front.c b/test_mini/libft/test/src/lst/test_ft_lstpush_front.c new file mode 100644 index 0000000..4a6af9f --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstpush_front.c @@ -0,0 +1,41 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstpush_front); + +TEST_SETUP(ft_lstpush_front) +{} + +TEST_TEAR_DOWN(ft_lstpush_front) +{} + +TEST(ft_lstpush_front, basic) +{ + t_ftlst *lst; + int a = 1; + int b = 2; + int c = 2; + + lst = ft_lstnew(&a); + TEST_ASSERT_NOT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_EQUAL_PTR(&b, lst->data); + TEST_ASSERT_EQUAL(b, *(int*)lst->data); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + TEST_ASSERT_EQUAL(a, *(int*)lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_EQUAL_PTR(&c, lst->data); + TEST_ASSERT_EQUAL(c, *(int*)lst->data); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + TEST_ASSERT_EQUAL(b, *(int*)lst->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->next->data); + TEST_ASSERT_EQUAL(a, *(int*)lst->next->next->data); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstremove_if.c b/test_mini/libft/test/src/lst/test_ft_lstremove_if.c new file mode 100644 index 0000000..a79016b --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstremove_if.c @@ -0,0 +1,70 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstremove_if); + +TEST_SETUP(ft_lstremove_if) +{} + +TEST_TEAR_DOWN(ft_lstremove_if) +{} + +TEST(ft_lstremove_if, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstpush_back(&lst, ft_lstnew(&a)); + ft_lstpush_back(&lst, ft_lstnew(&b)); + ft_lstpush_back(&lst, ft_lstnew(&c)); + ft_lstpush_back(&lst, ft_lstnew(&d)); + ft_lstpush_back(&lst, ft_lstnew(&d)); + ft_lstpush_back(&lst, ft_lstnew(&d)); + ft_lstpush_back(&lst, ft_lstnew(&a)); + ft_lstpush_back(&lst, ft_lstnew(&a)); + + ft_lstremove_if(&lst, ft_compar_int, &a, NULL); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_NOT_NULL(lst->next->next); + TEST_ASSERT_NOT_NULL(lst->next->next->next); + TEST_ASSERT_NOT_NULL(lst->next->next->next->next); + TEST_ASSERT_NOT_NULL(lst->data); + TEST_ASSERT_NOT_NULL(lst->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next->next->next->data); + TEST_ASSERT_EQUAL(b, *(int*)lst->data); + TEST_ASSERT_EQUAL(c, *(int*)lst->next->data); + TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->data); + TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->data); + TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->next->data); + + ft_lstremove_if(&lst, ft_compar_int, &b, NULL); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_NOT_NULL(lst->next->next); + TEST_ASSERT_NOT_NULL(lst->next->next->next); + TEST_ASSERT_NOT_NULL(lst->data); + TEST_ASSERT_NOT_NULL(lst->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next->data); + TEST_ASSERT_EQUAL(c, *(int*)lst->data); + TEST_ASSERT_EQUAL(d, *(int*)lst->next->data); + TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->data); + TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->data); + + ft_lstremove_if(&lst, ft_compar_int, &d, NULL); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_NOT_NULL(lst->data); + TEST_ASSERT_EQUAL(c, *(int*)lst->data); + + ft_lstremove_if(&lst, ft_compar_int, &d, NULL); + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_NOT_NULL(lst->data); + TEST_ASSERT_EQUAL(c, *(int*)lst->data); + + ft_lstremove_if(&lst, ft_compar_int, &c, NULL); + TEST_ASSERT_NULL(lst); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstreverse.c b/test_mini/libft/test/src/lst/test_ft_lstreverse.c new file mode 100644 index 0000000..a0a7d4e --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstreverse.c @@ -0,0 +1,45 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstreverse); + +TEST_SETUP(ft_lstreverse) +{} + +TEST_TEAR_DOWN(ft_lstreverse) +{} + +TEST(ft_lstreverse, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstreverse(&lst); + TEST_ASSERT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstreverse(&lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstreverse(&lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstreverse(&lst); + TEST_ASSERT_EQUAL_PTR(&b, lst->data); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&d)); + ft_lstreverse(&lst); + TEST_ASSERT_EQUAL_PTR(&c, lst->data); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->next->data); + TEST_ASSERT_EQUAL_PTR(&d, lst->next->next->next->data); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c b/test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c new file mode 100644 index 0000000..e6fc278 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c @@ -0,0 +1,45 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstreverse_ret); + +TEST_SETUP(ft_lstreverse_ret) +{} + +TEST_TEAR_DOWN(ft_lstreverse_ret) +{} + +TEST(ft_lstreverse_ret, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_EQUAL_PTR(&b, lst->data); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&d)); + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_EQUAL_PTR(&c, lst->data); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->next->data); + TEST_ASSERT_EQUAL_PTR(&d, lst->next->next->next->data); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstsize.c b/test_mini/libft/test/src/lst/test_ft_lstsize.c new file mode 100644 index 0000000..d3b78bb --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstsize.c @@ -0,0 +1,37 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstsize); + +TEST_SETUP(ft_lstsize) +{} + +TEST_TEAR_DOWN(ft_lstsize) +{} + +TEST(ft_lstsize, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + + TEST_ASSERT_EQUAL(0, ft_lstsize(lst)); + lst = ft_lstnew(&a); + TEST_ASSERT_EQUAL(1, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(2, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(3, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(4, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(5, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(6, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(7, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(8, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(9, ft_lstsize(lst)); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstsort.c b/test_mini/libft/test/src/lst/test_ft_lstsort.c new file mode 100644 index 0000000..3b771ae --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstsort.c @@ -0,0 +1,38 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstsort); + +TEST_SETUP(ft_lstsort) +{} + +TEST_TEAR_DOWN(ft_lstsort) +{} + +TEST(ft_lstsort, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = -1; + int c = 4; + int d = -3; + + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstpush_front(&lst, ft_lstnew(&d)); + ft_lstsort(&lst, ft_compar_int); + + TEST_ASSERT_NOT_NULL(lst); + TEST_ASSERT_NOT_NULL(lst->next); + TEST_ASSERT_NOT_NULL(lst->next->next); + TEST_ASSERT_NOT_NULL(lst->next->next->next); + TEST_ASSERT_NOT_NULL(lst->data); + TEST_ASSERT_NOT_NULL(lst->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next->data); + TEST_ASSERT_NOT_NULL(lst->next->next->next->data); + + TEST_ASSERT_EQUAL(-3, *(int*)lst->data); + TEST_ASSERT_EQUAL(-1, *(int*)lst->next->data); + TEST_ASSERT_EQUAL(1, *(int*)lst->next->next->data); + TEST_ASSERT_EQUAL(4, *(int*)lst->next->next->next->data); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstsorted_merge.c b/test_mini/libft/test/src/lst/test_ft_lstsorted_merge.c new file mode 100644 index 0000000..9839cd7 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstsorted_merge.c @@ -0,0 +1,40 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstsorted_merge); + +TEST_SETUP(ft_lstsorted_merge) +{} + +TEST_TEAR_DOWN(ft_lstsorted_merge) +{} + +TEST(ft_lstsorted_merge, basic) +{ + t_ftlst *lst1 = NULL; + t_ftlst *lst2 = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + int e = 5; + + ft_lstpush_front(&lst1, ft_lstnew(&a)); + ft_lstpush_front(&lst1, ft_lstnew(&d)); + ft_lstpush_front(&lst1, ft_lstnew(&e)); + ft_lstpush_front(&lst1, ft_lstnew(&d)); + ft_lstpush_front(&lst1, ft_lstnew(&a)); + + ft_lstpush_front(&lst2, ft_lstnew(&e)); + ft_lstpush_front(&lst2, ft_lstnew(&a)); + ft_lstpush_front(&lst2, ft_lstnew(&b)); + ft_lstpush_front(&lst2, ft_lstnew(&d)); + ft_lstpush_front(&lst2, ft_lstnew(&c)); + + ft_lstsort(&lst1, ft_compar_int); + ft_lstsort(&lst2, ft_compar_int); + + lst1 = ft_lstsorted_merge(lst1, lst2, ft_compar_int); + for (; lst1->next != NULL; lst1 = lst1->next) + if (ft_compar_int(lst1->data, lst1->next->data) > 0) + TEST_FAIL(); +} diff --git a/test_mini/libft/test/src/main.c b/test_mini/libft/test/src/main.c new file mode 100644 index 0000000..8884f81 --- /dev/null +++ b/test_mini/libft/test/src/main.c @@ -0,0 +1,85 @@ +#include "libft_test.h" + +static void run_all_test(void) +{ + // ctype + RUN_TEST_GROUP(ft_isalnum); + RUN_TEST_GROUP(ft_isalpha); + RUN_TEST_GROUP(ft_isascii); + RUN_TEST_GROUP(ft_isblank); + RUN_TEST_GROUP(ft_isdigit); + RUN_TEST_GROUP(ft_isprint); + RUN_TEST_GROUP(ft_isspace); + RUN_TEST_GROUP(ft_todigit); + RUN_TEST_GROUP(ft_tolower); + RUN_TEST_GROUP(ft_toupper); + + // mem + RUN_TEST_GROUP(ft_bzero); + RUN_TEST_GROUP(ft_calloc); + RUN_TEST_GROUP(ft_memccpy); + RUN_TEST_GROUP(ft_memchr); + RUN_TEST_GROUP(ft_memcmp); + RUN_TEST_GROUP(ft_memcpy); + RUN_TEST_GROUP(ft_memmem); + RUN_TEST_GROUP(ft_memmove); + RUN_TEST_GROUP(ft_memset); + RUN_TEST_GROUP(ft_memset_pattern4); + RUN_TEST_GROUP(ft_memswap); + + // str + RUN_TEST_GROUP(ft_strlen); + + // ht + RUN_TEST_GROUP(ft_htentry_new); + RUN_TEST_GROUP(ft_htnew); + RUN_TEST_GROUP(ft_htget); + RUN_TEST_GROUP(ft_htset); + RUN_TEST_GROUP(ft_htdelone); + RUN_TEST_GROUP(ft_htdestroy); + + // algo + RUN_TEST_GROUP(ft_bsearch); + RUN_TEST_GROUP(ft_compar_int); + RUN_TEST_GROUP(ft_heapsort); + RUN_TEST_GROUP(ft_is_set); + RUN_TEST_GROUP(ft_lfind); + RUN_TEST_GROUP(ft_lsearch); + RUN_TEST_GROUP(ft_mergesort); + RUN_TEST_GROUP(ft_qsort); + RUN_TEST_GROUP(ft_reverse); + + // lst + RUN_TEST_GROUP(ft_lstpush_back); + RUN_TEST_GROUP(ft_lstpush_front); + RUN_TEST_GROUP(ft_lstbsearch); + RUN_TEST_GROUP(ft_lstlsearch); + RUN_TEST_GROUP(ft_lstlfind); + RUN_TEST_GROUP(ft_lstdestroy); + RUN_TEST_GROUP(ft_lstdelone); + RUN_TEST_GROUP(ft_lstiter); + RUN_TEST_GROUP(ft_lstlast); + RUN_TEST_GROUP(ft_lstmap); + RUN_TEST_GROUP(ft_lstnew); + RUN_TEST_GROUP(ft_lstpop_front); + RUN_TEST_GROUP(ft_lstremove_if); + RUN_TEST_GROUP(ft_lstreverse); + RUN_TEST_GROUP(ft_lstreverse_ret); + RUN_TEST_GROUP(ft_lstsize); + RUN_TEST_GROUP(ft_lstsort); + RUN_TEST_GROUP(ft_lstsorted_merge); + + // vec + RUN_TEST_GROUP(ft_vecdestroy); + RUN_TEST_GROUP(ft_vecgrow); + RUN_TEST_GROUP(ft_veciter); + RUN_TEST_GROUP(ft_vecnew); + RUN_TEST_GROUP(ft_vecpop); + RUN_TEST_GROUP(ft_vecpush); + RUN_TEST_GROUP(ft_vecremove); +} + +int main(int argc, const char **argv) +{ + return UnityMain(argc, argv, run_all_test); +} diff --git a/test_mini/libft/test/src/mem/test_ft_bzero.c b/test_mini/libft/test/src/mem/test_ft_bzero.c new file mode 100644 index 0000000..20e560d --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_bzero.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_bzero.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:20 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:30:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_bzero); + +TEST_SETUP(ft_bzero) +{} + +TEST_TEAR_DOWN(ft_bzero) +{} + +TEST(ft_bzero, basic) +{ + char buf[32] = {'a'}; + + ft_bzero(buf, 32); + for (int i = 0; i < 32; i++) + TEST_ASSERT_EQUAL(0x0, buf[i]); +} diff --git a/test_mini/libft/test/src/mem/test_ft_calloc.c b/test_mini/libft/test/src/mem/test_ft_calloc.c new file mode 100644 index 0000000..0df9b95 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_calloc.c @@ -0,0 +1,33 @@ +#include "libft_test.h" + +TEST_GROUP(ft_calloc); + +TEST_SETUP(ft_calloc) +{} + +TEST_TEAR_DOWN(ft_calloc) +{} + +TEST(ft_calloc, basic) +{ + char *ptr = NULL; + + ptr = ft_calloc(45, sizeof(char)); + TEST_ASSERT_NOT_NULL(ptr); +#ifdef __APPLE__ + TEST_ASSERT_GREATER_THAN(45 * sizeof(char) - 1, malloc_size(ptr)); +#endif + for (int i = 0; i < 45; i++) + TEST_ASSERT_EQUAL(0x0, ptr[i]); + /* free(ptr); */ + + int *ptrint = NULL; + ptrint = ft_calloc(10, sizeof(int)); + TEST_ASSERT_NOT_NULL(ptr); +#ifdef __APPLE__ + TEST_ASSERT_GREATER_THAN(10 * sizeof(int) - 1, malloc_size(ptrint)); +#endif + for (int i = 0; i < 10; i++) + TEST_ASSERT_EQUAL(0x0, ptrint[i]); + /* free(ptrint); */ +} diff --git a/test_mini/libft/test/src/mem/test_ft_memccpy.c b/test_mini/libft/test/src/mem/test_ft_memccpy.c new file mode 100644 index 0000000..39925a1 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memccpy.c @@ -0,0 +1,45 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memccpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:34:13 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:35:17 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memccpy); + +TEST_SETUP(ft_memccpy) +{} + +TEST_TEAR_DOWN(ft_memccpy) +{} + +TEST(ft_memccpy, basic) +{ + char buf[32] = "bonjour"; + char buf2[32] = {0}; + + char *ptr = ft_memccpy(buf2, buf, 0x0, 32); + TEST_ASSERT_EQUAL_PTR(&buf2[8], ptr); + for (int i = 0; i < 32; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf2[i]); + + ptr = ft_memccpy(buf2, buf, 0x1, 32); + TEST_ASSERT_NULL(ptr); + for (int i = 0; i < 32; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf2[i]); + + char buf3[10] = "aurevoir"; + ptr = ft_memccpy(buf, buf3, 'e', 10); + TEST_ASSERT_EQUAL_PTR(buf + 4, ptr); + for (int i = 0; i < 4; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf3[i]); + for (int i = 4; i < 32; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf2[i]); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memchr.c b/test_mini/libft/test/src/mem/test_ft_memchr.c new file mode 100644 index 0000000..135edfb --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memchr.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:33:14 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:38:17 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memchr); + +TEST_SETUP(ft_memchr) +{} + +TEST_TEAR_DOWN(ft_memchr) +{} + +TEST(ft_memchr, basic) +{ + char *a = "bonjour"; + + char *ptr = ft_memchr(a, 'j', sizeof(a)); + TEST_ASSERT_EQUAL_PTR(a + 3, ptr); + + ptr = ft_memchr(a, 'z', sizeof(a)); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memchr(a, '\0', sizeof(a)); + TEST_ASSERT_EQUAL_PTR(a + 7, ptr); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memcmp.c b/test_mini/libft/test/src/mem/test_ft_memcmp.c new file mode 100644 index 0000000..81871a1 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memcmp.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memcmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:16 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:41:08 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memcmp); + +TEST_SETUP(ft_memcmp) +{} + +TEST_TEAR_DOWN(ft_memcmp) +{} + +TEST(ft_memcmp, basic) +{ + char buf1[32] = "bonjour"; + char buf2[32] = "bonjoure"; + + int res = ft_memcmp(buf1, buf2, 32); + TEST_ASSERT_LESS_THAN(0, res); + + res = ft_memcmp(buf2, buf1, 32); + TEST_ASSERT_GREATER_THAN(0, res); + + res = ft_memcmp(buf2, buf1, 7); + TEST_ASSERT_EQUAL(0, res); + res = ft_memcmp(buf2, buf1, 6); + TEST_ASSERT_EQUAL(0, res); + res = ft_memcmp(buf2, buf1, 3); + TEST_ASSERT_EQUAL(0, res); + res = ft_memcmp(buf2, buf1, 0); + TEST_ASSERT_EQUAL(0, res); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memcpy.c b/test_mini/libft/test/src/mem/test_ft_memcpy.c new file mode 100644 index 0000000..3afe817 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memcpy.c @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:33:22 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:27:55 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memcpy); + +TEST_SETUP(ft_memcpy) +{} + +TEST_TEAR_DOWN(ft_memcpy) +{} + +TEST(ft_memcpy, basic) +{ + void *ptr; + unsigned char buf1[32] = {0}; + unsigned char buf2[32] = "bonjour"; + + ptr = ft_memcpy(buf1, buf2, 32); + TEST_ASSERT_NOT_NULL(ptr); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL(0, memcmp(buf1, buf2, 32)); + + ptr = ft_memcpy(buf1, "yo", 3); + TEST_ASSERT_NOT_NULL(ptr); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL(0, memcmp(buf1, "yo", 3)); + TEST_ASSERT_EQUAL(0, memcmp(buf1 + 3, buf2 + 3, 32 - 3)); + + char saved[32]; + + memcpy(saved, buf2, 32); + ptr = ft_memcpy(buf2, "", 0); + TEST_ASSERT_NOT_NULL(ptr); + TEST_ASSERT_EQUAL_PTR(buf2, ptr); + TEST_ASSERT_EQUAL(0, memcmp(buf2, saved, 32)); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memmem.c b/test_mini/libft/test/src/mem/test_ft_memmem.c new file mode 100644 index 0000000..67514a5 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memmem.c @@ -0,0 +1,65 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memmem.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:33:50 by cacharle #+# #+# */ +/* Updated: 2020/02/13 21:04:22 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memmem); + +TEST_SETUP(ft_memmem) +{} + +TEST_TEAR_DOWN(ft_memmem) +{} + +TEST(ft_memmem, basic) +{ + char haystack[32] = "bonjour"; + char *ptr; + + ptr = ft_memmem(haystack, sizeof(haystack), "jour\0", 5); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "jour", 4); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "jo", 2); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "j", 1); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "yo", 2); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "\0", 1); + TEST_ASSERT_EQUAL_PTR(haystack + 7, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "bon", 3); + TEST_ASSERT_EQUAL_PTR(haystack, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "on", 2); + TEST_ASSERT_EQUAL_PTR(haystack + 1, ptr); +} + +TEST(ft_memmem, invalid_len) +{ + char buf[32] = {0}; + + void *ptr = ft_memmem(buf, 2, "jour", 4); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memmem(buf, 0, "jour", 4); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memmem(buf, 2, "jour", 0); + TEST_ASSERT_NULL(ptr); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memmove.c b/test_mini/libft/test/src/mem/test_ft_memmove.c new file mode 100644 index 0000000..158cda9 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memmove.c @@ -0,0 +1,39 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memmove.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:34:21 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:49:07 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memmove); + +TEST_SETUP(ft_memmove) +{} + +TEST_TEAR_DOWN(ft_memmove) +{} + +TEST(ft_memmove, basic) +{ + char buf1[32] = "bonjour"; + + char *ptr = ft_memmove(buf1, buf1 + 2, 29); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL_STRING("njour", buf1); + + ptr = ft_memmove(buf1 + 2, buf1, 29); + TEST_ASSERT_EQUAL_PTR(buf1 + 2, ptr); + TEST_ASSERT_EQUAL_STRING("njour", ptr); + TEST_ASSERT_EQUAL_STRING("njnjour", buf1); + + ptr = ft_memmove(buf1, buf1, 32); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL_STRING("njnjour", ptr); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memset.c b/test_mini/libft/test/src/mem/test_ft_memset.c new file mode 100644 index 0000000..7ec5846 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memset.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memset.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:28 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:21:58 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memset); + +TEST_SETUP(ft_memset) +{} + +TEST_TEAR_DOWN(ft_memset) +{} + +TEST(ft_memset, basic) +{ + int i; + unsigned char buf[32] = {0}; + + ft_memset(buf, 0xfa, 32); + for (i = 0; i < 32; i++) + TEST_ASSERT_EQUAL(0xfa, buf[i]); + + ft_memset(buf, 0x00, 15); + for (i = 0; i < 15; i++) + TEST_ASSERT_EQUAL(0x00, buf[i]); + while (i++ < 31) + TEST_ASSERT_EQUAL(0xfa, buf[i]); + + ft_memset(buf, 0x10, 31); + for (int i = 0; i < 31; i++) + TEST_ASSERT_EQUAL(0x10, buf[i]); + TEST_ASSERT_EQUAL(0xfa, buf[31]); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memset_pattern4.c b/test_mini/libft/test/src/mem/test_ft_memset_pattern4.c new file mode 100644 index 0000000..0e2806a --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memset_pattern4.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memset_pattern4.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:43 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:57:48 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memset_pattern4); + +TEST_SETUP(ft_memset_pattern4) +{} + +TEST_TEAR_DOWN(ft_memset_pattern4) +{} + +TEST(ft_memset_pattern4, basic) +{ + char buf[17] = {0}; + char *pattern4 = "1234"; + + ft_memset_pattern4(buf, pattern4, 16); + TEST_ASSERT_EQUAL_STRING("1234123412341234", buf); + + char buf1[10] = {0}; + ft_memset_pattern4(buf1, "1234", 9); + TEST_ASSERT_EQUAL_STRING("123412341", buf1); + + char buf2[11] = {0}; + ft_memset_pattern4(buf2, "1234", 10); + TEST_ASSERT_EQUAL_STRING("1234123412", buf2); + + char buf3[12] = {0}; + ft_memset_pattern4(buf3, "1234", 11); + TEST_ASSERT_EQUAL_STRING("12341234123", buf3); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memswap.c b/test_mini/libft/test/src/mem/test_ft_memswap.c new file mode 100644 index 0000000..72c3402 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memswap.c @@ -0,0 +1,41 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memswap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:38:27 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:18:14 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memswap); + +TEST_SETUP(ft_memswap) +{} + +TEST_TEAR_DOWN(ft_memswap) +{} + +TEST(ft_memswap, basic) +{ + char buf1[32] = "bonjour"; + char buf2[32] = "aurevoir"; + ft_memswap(buf1, buf2, 32); + TEST_ASSERT_EQUAL_STRING("bonjour", buf2); + TEST_ASSERT_EQUAL_STRING("aurevoir", buf1); + ft_memswap(buf1, buf2, 3); + TEST_ASSERT_EQUAL_STRING("aurjour", buf2); + TEST_ASSERT_EQUAL_STRING("bonevoir", buf1); + ft_memswap(buf1, buf2, 0); + TEST_ASSERT_EQUAL_STRING("aurjour", buf2); + TEST_ASSERT_EQUAL_STRING("bonevoir", buf1); + int a = 1234567; + int b = 7654321; + ft_memswap(&a, &b, sizeof(int)); + TEST_ASSERT_EQUAL(7654321, a); + TEST_ASSERT_EQUAL(1234567, b); +} diff --git a/test_mini/libft/test/src/runner/test_runner_algo.c b/test_mini/libft/test/src/runner/test_runner_algo.c new file mode 100644 index 0000000..8873797 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_algo.c @@ -0,0 +1,59 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_algo.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 21:25:52 by cacharle #+# #+# */ +/* Updated: 2020/02/13 21:37:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + + +TEST_GROUP_RUNNER(ft_bsearch) +{ + RUN_TEST_CASE(ft_bsearch, basic); +} + +TEST_GROUP_RUNNER(ft_compar_int) +{ + RUN_TEST_CASE(ft_compar_int, basic); +} + +TEST_GROUP_RUNNER(ft_heapsort) +{ + RUN_TEST_CASE(ft_heapsort, basic); +} + +TEST_GROUP_RUNNER(ft_is_set) +{ + RUN_TEST_CASE(ft_is_set, basic); +} + +TEST_GROUP_RUNNER(ft_lfind) +{ + RUN_TEST_CASE(ft_lfind, basic); +} + +TEST_GROUP_RUNNER(ft_lsearch) +{ + RUN_TEST_CASE(ft_lsearch, basic); +} + +TEST_GROUP_RUNNER(ft_mergesort) +{ + RUN_TEST_CASE(ft_mergesort, basic); +} + +TEST_GROUP_RUNNER(ft_qsort) +{ + RUN_TEST_CASE(ft_qsort, basic); +} + +TEST_GROUP_RUNNER(ft_reverse) +{ + RUN_TEST_CASE(ft_reverse, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_ctype.c b/test_mini/libft/test/src/runner/test_runner_ctype.c new file mode 100644 index 0000000..7f9148e --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_ctype.c @@ -0,0 +1,64 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_ctype.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/12 22:44:43 by cacharle #+# #+# */ +/* Updated: 2020/02/12 23:13:02 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_isalnum) +{ + RUN_TEST_CASE(ft_isalnum, base); +} + +TEST_GROUP_RUNNER(ft_isalpha) +{ + RUN_TEST_CASE(ft_isalpha, base); +} + +TEST_GROUP_RUNNER(ft_isascii) +{ + RUN_TEST_CASE(ft_isascii, base); +} + +TEST_GROUP_RUNNER(ft_isblank) +{ + RUN_TEST_CASE(ft_isblank, base); +} + +TEST_GROUP_RUNNER(ft_isdigit) +{ + RUN_TEST_CASE(ft_isdigit, base); +} + +TEST_GROUP_RUNNER(ft_isprint) +{ + RUN_TEST_CASE(ft_isprint, base); +} + +TEST_GROUP_RUNNER(ft_isspace) +{ + RUN_TEST_CASE(ft_isspace, base); +} + +TEST_GROUP_RUNNER(ft_todigit) +{ + RUN_TEST_CASE(ft_todigit, base); +} + +TEST_GROUP_RUNNER(ft_tolower) +{ + RUN_TEST_CASE(ft_tolower, base); +} + +TEST_GROUP_RUNNER(ft_toupper) +{ + RUN_TEST_CASE(ft_toupper, base); +} + diff --git a/test_mini/libft/test/src/runner/test_runner_ht.c b/test_mini/libft/test/src/runner/test_runner_ht.c new file mode 100644 index 0000000..1563a72 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_ht.c @@ -0,0 +1,51 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_ht.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/12 22:44:39 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:17:33 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_htentry_new) +{ + RUN_TEST_CASE(ft_htentry_new, basic); +} + +TEST_GROUP_RUNNER(ft_htnew) +{ + RUN_TEST_CASE(ft_htnew, segfault); + RUN_TEST_CASE(ft_htnew, error_null); + RUN_TEST_CASE(ft_htnew, happy_path); +} + +TEST_GROUP_RUNNER(ft_htget) +{ + RUN_TEST_CASE(ft_htget, segfault); + RUN_TEST_CASE(ft_htget, error_null); + RUN_TEST_CASE(ft_htget, basic); +} + +TEST_GROUP_RUNNER(ft_htset) +{ + RUN_TEST_CASE(ft_htset, segfault); + RUN_TEST_CASE(ft_htset, error_null); + RUN_TEST_CASE(ft_htset, happy_path); + RUN_TEST_CASE(ft_htset, reset); + RUN_TEST_CASE(ft_htset, collision); +} + +TEST_GROUP_RUNNER(ft_htdelone) +{ + RUN_TEST_CASE(ft_htdelone, basic); +} + +TEST_GROUP_RUNNER(ft_htdestroy) +{ + RUN_TEST_CASE(ft_htdestroy, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_lst.c b/test_mini/libft/test/src/runner/test_runner_lst.c new file mode 100644 index 0000000..5ae9557 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_lst.c @@ -0,0 +1,103 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_lst.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/15 03:54:05 by cacharle #+# #+# */ +/* Updated: 2020/02/17 03:24:41 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_lstpush_back) +{ + RUN_TEST_CASE(ft_lstpush_back, basic); +} + +TEST_GROUP_RUNNER(ft_lstpush_front) +{ + RUN_TEST_CASE(ft_lstpush_front, basic); +} + +TEST_GROUP_RUNNER(ft_lstbsearch) +{ + RUN_TEST_CASE(ft_lstbsearch, basic); +} + +TEST_GROUP_RUNNER(ft_lstlsearch) +{ + RUN_TEST_CASE(ft_lstlsearch, basic); +} + +TEST_GROUP_RUNNER(ft_lstlfind) +{ + RUN_TEST_CASE(ft_lstlfind, basic); +} + +TEST_GROUP_RUNNER(ft_lstdestroy) +{ + RUN_TEST_CASE(ft_lstdestroy, basic); +} + +TEST_GROUP_RUNNER(ft_lstdelone) +{ + RUN_TEST_CASE(ft_lstdelone, basic); +} + +TEST_GROUP_RUNNER(ft_lstiter) +{ + RUN_TEST_CASE(ft_lstiter, basic); +} + +TEST_GROUP_RUNNER(ft_lstlast) +{ + RUN_TEST_CASE(ft_lstlast, basic); +} + +TEST_GROUP_RUNNER(ft_lstmap) +{ + RUN_TEST_CASE(ft_lstmap, basic); +} + +TEST_GROUP_RUNNER(ft_lstnew) +{ + RUN_TEST_CASE(ft_lstnew, basic); +} + +TEST_GROUP_RUNNER(ft_lstpop_front) +{ + RUN_TEST_CASE(ft_lstpop_front, basic); +} + +TEST_GROUP_RUNNER(ft_lstremove_if) +{ + RUN_TEST_CASE(ft_lstremove_if, basic); +} + +TEST_GROUP_RUNNER(ft_lstreverse) +{ + RUN_TEST_CASE(ft_lstreverse, basic); +} + +TEST_GROUP_RUNNER(ft_lstreverse_ret) +{ + RUN_TEST_CASE(ft_lstreverse_ret, basic); +} + +TEST_GROUP_RUNNER(ft_lstsize) +{ + RUN_TEST_CASE(ft_lstsize, basic); +} + +TEST_GROUP_RUNNER(ft_lstsort) +{ + RUN_TEST_CASE(ft_lstsort, basic); +} + +TEST_GROUP_RUNNER(ft_lstsorted_merge) +{ + RUN_TEST_CASE(ft_lstsorted_merge, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_mem.c b/test_mini/libft/test/src/runner/test_runner_mem.c new file mode 100644 index 0000000..093d064 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_mem.c @@ -0,0 +1,69 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_mem.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:36:16 by cacharle #+# #+# */ +/* Updated: 2020/02/13 20:40:24 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_bzero) +{ + RUN_TEST_CASE(ft_bzero, basic); +} + +TEST_GROUP_RUNNER(ft_calloc) +{ + RUN_TEST_CASE(ft_calloc, basic); +} + +TEST_GROUP_RUNNER(ft_memccpy) +{ + RUN_TEST_CASE(ft_memccpy, basic); +} + +TEST_GROUP_RUNNER(ft_memchr) +{ + RUN_TEST_CASE(ft_memchr, basic); +} + +TEST_GROUP_RUNNER(ft_memcmp) +{ + RUN_TEST_CASE(ft_memcmp, basic); +} + +TEST_GROUP_RUNNER(ft_memcpy) +{ + RUN_TEST_CASE(ft_memcpy, basic); +} + +TEST_GROUP_RUNNER(ft_memmem) +{ + RUN_TEST_CASE(ft_memmem, basic); + RUN_TEST_CASE(ft_memmem, invalid_len); +} + +TEST_GROUP_RUNNER(ft_memmove) +{ + RUN_TEST_CASE(ft_memmove, basic); +} + +TEST_GROUP_RUNNER(ft_memset) +{ + RUN_TEST_CASE(ft_memset, basic); +} + +TEST_GROUP_RUNNER(ft_memset_pattern4) +{ + RUN_TEST_CASE(ft_memset_pattern4, basic); +} + +TEST_GROUP_RUNNER(ft_memswap) +{ + RUN_TEST_CASE(ft_memswap, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_str.c b/test_mini/libft/test/src/runner/test_runner_str.c new file mode 100644 index 0000000..3d829ad --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_str.c @@ -0,0 +1,6 @@ +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_strlen) +{ + RUN_TEST_CASE(ft_strlen, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_vec.c b/test_mini/libft/test/src/runner/test_runner_vec.c new file mode 100644 index 0000000..e0d3008 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_vec.c @@ -0,0 +1,50 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_vec.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:55:53 by charles #+# #+# */ +/* Updated: 2020/04/01 22:49:28 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_vecdestroy) +{ + RUN_TEST_CASE(ft_vecdestroy, basic); +} + +TEST_GROUP_RUNNER(ft_vecgrow) +{ + RUN_TEST_CASE(ft_vecgrow, basic); +} + +TEST_GROUP_RUNNER(ft_veciter) +{ + RUN_TEST_CASE(ft_veciter, basic); +} + +TEST_GROUP_RUNNER(ft_vecnew) +{ + RUN_TEST_CASE(ft_vecnew, basic); +} + +TEST_GROUP_RUNNER(ft_vecpop) +{ + RUN_TEST_CASE(ft_vecpop, basic); +} + +TEST_GROUP_RUNNER(ft_vecpush) +{ + RUN_TEST_CASE(ft_vecpush, basic); +} + +TEST_GROUP_RUNNER(ft_vecremove) +{ + RUN_TEST_CASE(ft_vecremove, basic); +} + diff --git a/test_mini/libft/test/src/str/test_ft_strlen.c b/test_mini/libft/test/src/str/test_ft_strlen.c new file mode 100644 index 0000000..f251fc6 --- /dev/null +++ b/test_mini/libft/test/src/str/test_ft_strlen.c @@ -0,0 +1,24 @@ +#include "libft_test.h" + +TEST_GROUP(ft_strlen); + +TEST_SETUP(ft_strlen) +{} + +TEST_TEAR_DOWN(ft_strlen) +{} + +#define TEST_ASSERT_FT_STRLEN(str) do { \ + if (strlen(str) != ft_strlen(str)) \ + TEST_FAIL(); \ +} while(0); + +TEST(ft_strlen, basic) +{ + TEST_ASSERT_FT_STRLEN(""); + TEST_ASSERT_FT_STRLEN("bonjour"); + TEST_ASSERT_FT_STRLEN("1"); + TEST_ASSERT_FT_STRLEN("asodifuaosidjoiasjdfoijasklfqwkberkjqwerkjqwlkenrmnqwerjkqwehfakjs"); + TEST_ASSERT_FT_STRLEN("im\0hidden"); + TEST_ASSERT_FT_STRLEN("987987\xff\xee\xaasdfioxcv"); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecdestroy.c b/test_mini/libft/test/src/vec/test_ft_vecdestroy.c new file mode 100644 index 0000000..4f121dc --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecdestroy.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 19:55:14 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_vecdestroy); + +TEST_SETUP(ft_vecdestroy) +{} + +TEST_TEAR_DOWN(ft_vecdestroy) +{} + +TEST(ft_vecdestroy, basic) +{ + TEST_PASS(); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecgrow.c b/test_mini/libft/test/src/vec/test_ft_vecgrow.c new file mode 100644 index 0000000..0b40390 --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecgrow.c @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecgrow.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 21:17:13 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_vecgrow); + +TEST_SETUP(ft_vecgrow) +{} + +TEST_TEAR_DOWN(ft_vecgrow) +{} + +TEST(ft_vecgrow, basic) +{ + t_ftvec *vec = ft_vecnew(1); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(2, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(3, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(4, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(6, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(9, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(13, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + + ft_vecdestroy(vec, NULL); +} diff --git a/test_mini/libft/test/src/vec/test_ft_veciter.c b/test_mini/libft/test/src/vec/test_ft_veciter.c new file mode 100644 index 0000000..fac28c1 --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_veciter.c @@ -0,0 +1,52 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_veciter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 20:20:41 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_veciter); + +TEST_SETUP(ft_veciter) +{} + +TEST_TEAR_DOWN(ft_veciter) +{} + +static void iter_func(void *x) +{ + *(int*)x = *(int*)x * *(int*)x; +} + +static void iter_func2(void *x) +{ + *(int*)x = *(int*)x - 100; +} + +TEST(ft_veciter, basic) +{ + int tmp[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + t_ftvec *vec; + + vec = ft_vecnew(10); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(vec->data); + for (int i = 0; i < 10; i++) + vec->data[i] = tmp + i; + vec->size = 10; + ft_veciter(vec, iter_func); + for (int i = 0; i < 10; i++) + TEST_ASSERT_EQUAL(i * i, *(int*)vec->data[i]); + ft_veciter(vec, iter_func2); + for (int i = 0; i < 10; i++) + TEST_ASSERT_EQUAL(i * i - 100, *(int*)vec->data[i]); + + ft_vecdestroy(vec, NULL); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecnew.c b/test_mini/libft/test/src/vec/test_ft_vecnew.c new file mode 100644 index 0000000..579a182 --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecnew.c @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 20:01:37 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_vecnew); + +TEST_SETUP(ft_vecnew) +{} + +TEST_TEAR_DOWN(ft_vecnew) +{} + +TEST(ft_vecnew, basic) +{ + t_ftvec *vec; + + vec = ft_vecnew(0); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(vec->data); + TEST_ASSERT_EQUAL(1, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + ft_vecdestroy(vec, NULL); + + vec = ft_vecnew(10); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(vec->data); + TEST_ASSERT_EQUAL(10, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + ft_vecdestroy(vec, NULL); + + vec = ft_vecnew(256); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(vec->data); + TEST_ASSERT_EQUAL(256, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + ft_vecdestroy(vec, NULL); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecpop.c b/test_mini/libft/test/src/vec/test_ft_vecpop.c new file mode 100644 index 0000000..2ee96d2 --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecpop.c @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecpop.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 20:26:37 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_vecpop); + +TEST_SETUP(ft_vecpop) +{} + +TEST_TEAR_DOWN(ft_vecpop) +{} + +TEST(ft_vecpop, basic) +{ + t_ftvec *vec; + + vec = ft_vecnew(3); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(vec->data); + + vec->size = 3; + for (long i = 0; i < 3; i++) + vec->data[i] = (void*)i; + + ft_vecpop(vec, NULL); + TEST_ASSERT_EQUAL(2, vec->size); + TEST_ASSERT_EQUAL(3, vec->capacity); + ft_vecpop(vec, NULL); + TEST_ASSERT_EQUAL(1, vec->size); + TEST_ASSERT_EQUAL(3, vec->capacity); + ft_vecpop(vec, NULL); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_EQUAL(3, vec->capacity); + ft_vecpop(vec, NULL); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_EQUAL(3, vec->capacity); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecpush.c b/test_mini/libft/test/src/vec/test_ft_vecpush.c new file mode 100644 index 0000000..05efc7a --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecpush.c @@ -0,0 +1,57 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecpush.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 20:23:00 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_vecpush); + +TEST_SETUP(ft_vecpush) +{} + +TEST_TEAR_DOWN(ft_vecpush) +{} + +TEST(ft_vecpush, basic) +{ + t_ftvec *vec; + + vec = ft_vecnew(2); + TEST_ASSERT_NOT_NULL(vec); + TEST_ASSERT_NOT_NULL(vec->data); + + TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)10)); + TEST_ASSERT_EQUAL(1, vec->size); + TEST_ASSERT_EQUAL(2, vec->capacity); + TEST_ASSERT_EQUAL(10, (long)vec->data[0]); + + TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)11)); + TEST_ASSERT_EQUAL(2, vec->size); + TEST_ASSERT_EQUAL(2, vec->capacity); + TEST_ASSERT_EQUAL(11, (long)vec->data[1]); + + TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)12)); + TEST_ASSERT_EQUAL(3, vec->size); + TEST_ASSERT_EQUAL(2 * 1.5, vec->capacity); + TEST_ASSERT_EQUAL(12, (long)vec->data[2]); + + TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)13)); + TEST_ASSERT_EQUAL(4, vec->size); + TEST_ASSERT_EQUAL(2 * 1.5 * 1.5, vec->capacity); + TEST_ASSERT_EQUAL(13, (long)vec->data[3]); + + TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)14)); + TEST_ASSERT_EQUAL(5, vec->size); + TEST_ASSERT_EQUAL(2 * 1.5 * 1.5 * 1.5, vec->capacity); + TEST_ASSERT_EQUAL(14, (long)vec->data[4]); + + ft_vecdestroy(vec, NULL); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecremove.c b/test_mini/libft/test/src/vec/test_ft_vecremove.c new file mode 100644 index 0000000..8cecc19 --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecremove.c @@ -0,0 +1,64 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecremove.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 22:48:58 by charles #+# #+# */ +/* Updated: 2020/04/01 22:56:37 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_vecremove); + +TEST_SETUP(ft_vecremove) +{} + +TEST_TEAR_DOWN(ft_vecremove) +{} + +TEST(ft_vecremove, basic) +{ + t_ftvec *vec; + + vec = ft_vecnew(4); + for (size_t i = 0; i < 4; i++) + vec->data[i] = (void*)(i + 1); + vec->size = 4; + + ft_vecremove(vec, 0, NULL); + TEST_ASSERT_EQUAL(3, vec->size); + TEST_ASSERT_EQUAL(4, vec->capacity); + TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]); + TEST_ASSERT_EQUAL_UINT64(3, (size_t)vec->data[1]); + TEST_ASSERT_EQUAL_UINT64(4, (size_t)vec->data[2]); + + ft_vecremove(vec, 1, NULL); + TEST_ASSERT_EQUAL(2, vec->size); + TEST_ASSERT_EQUAL(4, vec->capacity); + TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]); + TEST_ASSERT_EQUAL_UINT64(4, (size_t)vec->data[1]); + + ft_vecremove(vec, 1, NULL); + TEST_ASSERT_EQUAL(1, vec->size); + TEST_ASSERT_EQUAL(4, vec->capacity); + TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]); + + ft_vecremove(vec, 1, NULL); + TEST_ASSERT_EQUAL(1, vec->size); + TEST_ASSERT_EQUAL(4, vec->capacity); + TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]); + + ft_vecremove(vec, 0, NULL); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_EQUAL(4, vec->capacity); + + ft_vecremove(vec, 0, NULL); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_EQUAL(4, vec->capacity); + + ft_vecdestroy(vec, NULL); +} diff --git a/test_mini/libft/vendor/_unity/LICENSE.txt b/test_mini/libft/vendor/_unity/LICENSE.txt new file mode 100644 index 0000000..d66fba5 --- /dev/null +++ b/test_mini/libft/vendor/_unity/LICENSE.txt @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) <year> 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/test_mini/libft/vendor/_unity/Makefile b/test_mini/libft/vendor/_unity/Makefile new file mode 100644 index 0000000..d9700ea --- /dev/null +++ b/test_mini/libft/vendor/_unity/Makefile @@ -0,0 +1,41 @@ +# **************************************************************************** # +# # +# ::: :::::::: # +# Makefile :+: :+: :+: # +# +:+ +:+ +:+ # +# By: cacharle <marvin@42.fr> +#+ +:+ +#+ # +# +#+#+#+#+#+ +#+ # +# Created: 2020/01/31 07:27:12 by cacharle #+# #+# # +# Updated: 2020/01/31 08:39:24 by cacharle ### ########.fr # +# # +# **************************************************************************** # + +CC = gcc +CCFLAGS = -Iinclude -Wall -Wextra -Werror + +NAME = libunity.a + +INCLUDE = $(shell find include -type f -name "*.h") +SRC = $(shell find src -type f -name "*.c") +OBJ = $(SRC:.c=.o) + +.PHONY: all +all: $(NAME) + +$(NAME): $(OBJ) + @echo "Unity: Linking: $@" + @ar rcs $@ $^ + +%.o: %.c $(INCLUDE) + @echo "Unity: Compiling: $@" + @$(CC) $(CCFLAGS) -c -o $@ $< + +clean: + @echo "Unity: Removing objects" + @rm -f $(OBJ) + +fclean: clean + @echo "Unity: Removing: $(NAME)" + @rm -f $(NAME) + +re: fclean all diff --git a/test_mini/libft/vendor/_unity/README.md b/test_mini/libft/vendor/_unity/README.md new file mode 100644 index 0000000..e6e7ea2 --- /dev/null +++ b/test_mini/libft/vendor/_unity/README.md @@ -0,0 +1,191 @@ +Unity Test API +============== + +[](https://travis-ci.org/ThrowTheSwitch/Unity) +__Copyright (c) 2007 - 2020 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__ + +Getting Started +=============== +The [docs](docs/) folder contains a [getting started guide](docs/UnityGettingStartedGuide.md) +and much more tips about using Unity. + +Unity Assertion Summary +======================= +For the full list, see [UnityAssertionsReference.md](docs/UnityAssertionsReference.md). + +Basic Validity Tests +-------------------- + + TEST_ASSERT_TRUE(condition) + +Evaluates whatever code is in condition and fails if it evaluates to false + + TEST_ASSERT_FALSE(condition) + +Evaluates whatever code is in condition and fails if it evaluates to true + + TEST_ASSERT(condition) + +Another way of calling `TEST_ASSERT_TRUE` + + TEST_ASSERT_UNLESS(condition) + +Another way of calling `TEST_ASSERT_FALSE` + + TEST_FAIL() + TEST_FAIL_MESSAGE(message) + +This test is automatically marked as a failure. The message is output stating why. + +Numerical Assertions: Integers +------------------------------ + + TEST_ASSERT_EQUAL_INT(expected, actual) + TEST_ASSERT_EQUAL_INT8(expected, actual) + TEST_ASSERT_EQUAL_INT16(expected, actual) + TEST_ASSERT_EQUAL_INT32(expected, actual) + TEST_ASSERT_EQUAL_INT64(expected, actual) + +Compare two integers for equality and display errors as signed integers. A cast will be performed +to your natural integer size so often this can just be used. When you need to specify the exact size, +like when comparing arrays, you can use a specific version: + + TEST_ASSERT_EQUAL_UINT(expected, actual) + TEST_ASSERT_EQUAL_UINT8(expected, actual) + TEST_ASSERT_EQUAL_UINT16(expected, actual) + TEST_ASSERT_EQUAL_UINT32(expected, actual) + TEST_ASSERT_EQUAL_UINT64(expected, actual) + +Compare two integers for equality and display errors as unsigned integers. Like INT, there are +variants for different sizes also. + + TEST_ASSERT_EQUAL_HEX(expected, actual) + TEST_ASSERT_EQUAL_HEX8(expected, actual) + TEST_ASSERT_EQUAL_HEX16(expected, actual) + TEST_ASSERT_EQUAL_HEX32(expected, actual) + TEST_ASSERT_EQUAL_HEX64(expected, actual) + +Compares two integers for equality and display errors as hexadecimal. Like the other integer comparisons, +you can specify the size... here the size will also effect how many nibbles are shown (for example, `HEX16` +will show 4 nibbles). + + TEST_ASSERT_EQUAL(expected, actual) + +Another way of calling TEST_ASSERT_EQUAL_INT + + TEST_ASSERT_INT_WITHIN(delta, expected, actual) + +Asserts that the actual value is within plus or minus delta of the expected value. This also comes in +size specific variants. + + + TEST_ASSERT_GREATER_THAN(threshold, actual) + +Asserts that the actual value is greater than the threshold. This also comes in size specific variants. + + + TEST_ASSERT_LESS_THAN(threshold, actual) + +Asserts that the actual value is less than the threshold. This also comes in size specific variants. + + +Arrays +------ + + _ARRAY + +You can append `_ARRAY` to any of these macros to make an array comparison of that type. Here you will +need to care a bit more about the actual size of the value being checked. You will also specify an +additional argument which is the number of elements to compare. For example: + + TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements) + + _EACH_EQUAL + +Another array comparison option is to check that EVERY element of an array is equal to a single expected +value. You do this by specifying the EACH_EQUAL macro. For example: + + TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements) + +Numerical Assertions: Bitwise +----------------------------- + + TEST_ASSERT_BITS(mask, expected, actual) + +Use an integer mask to specify which bits should be compared between two other integers. High bits in the mask are compared, low bits ignored. + + TEST_ASSERT_BITS_HIGH(mask, actual) + +Use an integer mask to specify which bits should be inspected to determine if they are all set high. High bits in the mask are compared, low bits ignored. + + TEST_ASSERT_BITS_LOW(mask, actual) + +Use an integer mask to specify which bits should be inspected to determine if they are all set low. High bits in the mask are compared, low bits ignored. + + TEST_ASSERT_BIT_HIGH(bit, actual) + +Test a single bit and verify that it is high. The bit is specified 0-31 for a 32-bit integer. + + TEST_ASSERT_BIT_LOW(bit, actual) + +Test a single bit and verify that it is low. The bit is specified 0-31 for a 32-bit integer. + +Numerical Assertions: Floats +---------------------------- + + TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) + +Asserts that the actual value is within plus or minus delta of the expected value. + + TEST_ASSERT_EQUAL_FLOAT(expected, actual) + TEST_ASSERT_EQUAL_DOUBLE(expected, actual) + +Asserts that two floating point values are "equal" within a small % delta of the expected value. + +String Assertions +----------------- + + TEST_ASSERT_EQUAL_STRING(expected, actual) + +Compare two null-terminate strings. Fail if any character is different or if the lengths are different. + + TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) + +Compare two strings. Fail if any character is different, stop comparing after len characters. + + TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) + +Compare two null-terminate strings. Fail if any character is different or if the lengths are different. Output a custom message on failure. + + TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) + +Compare two strings. Fail if any character is different, stop comparing after len characters. Output a custom message on failure. + +Pointer Assertions +------------------ + +Most pointer operations can be performed by simply using the integer comparisons above. However, a couple of special cases are added for clarity. + + TEST_ASSERT_NULL(pointer) + +Fails if the pointer is not equal to NULL + + TEST_ASSERT_NOT_NULL(pointer) + +Fails if the pointer is equal to NULL + +Memory Assertions +----------------- + + TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) + +Compare two blocks of memory. This is a good generic assertion for types that can't be coerced into acting like +standard types... but since it's a memory compare, you have to be careful that your data types are packed. + +\_MESSAGE +--------- + +you can append \_MESSAGE to any of the macros to make them take an additional argument. This argument +is a string that will be printed at the end of the failure strings. This is useful for specifying more +information about the problem. + diff --git a/test_mini/libft/vendor/_unity/include/unity.h b/test_mini/libft/vendor/_unity/include/unity.h new file mode 100644 index 0000000..34d7f93 --- /dev/null +++ b/test_mini/libft/vendor/_unity/include/unity.h @@ -0,0 +1,617 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#ifndef UNITY_FRAMEWORK_H +#define UNITY_FRAMEWORK_H +#define UNITY + +#define UNITY_VERSION_MAJOR 2 +#define UNITY_VERSION_MINOR 5 +#define UNITY_VERSION_BUILD 0 +#define UNITY_VERSION ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD) + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "unity_internals.h" + +/*------------------------------------------------------- + * Test Setup / Teardown + *-------------------------------------------------------*/ + +/* These functions are intended to be called before and after each test. + * If using unity directly, these will need to be provided for each test + * executable built. If you are using the test runner generator and/or + * Ceedling, these are optional. */ +void setUp(void); +void tearDown(void); + +/* These functions are intended to be called at the beginning and end of an + * entire test suite. suiteTearDown() is passed the number of tests that + * failed, and its return value becomes the exit code of main(). If using + * Unity directly, you're in charge of calling these if they are desired. + * If using Ceedling or the test runner generator, these will be called + * automatically if they exist. */ +void suiteSetUp(void); +int suiteTearDown(int num_failures); + +/*------------------------------------------------------- + * Test Reset and Verify + *-------------------------------------------------------*/ + +/* These functions are intended to be called before during tests in order + * to support complex test loops, etc. Both are NOT built into Unity. Instead + * the test runner generator will create them. resetTest will run teardown and + * setup again, verifying any end-of-test needs between. verifyTest will only + * run the verification. */ +void resetTest(void); +void verifyTest(void); + +/*------------------------------------------------------- + * Configuration Options + *------------------------------------------------------- + * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above. + + * Integers/longs/pointers + * - Unity attempts to automatically discover your integer sizes + * - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h> + * - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h> + * - If you cannot use the automatic methods above, you can force Unity by using these options: + * - define UNITY_SUPPORT_64 + * - set UNITY_INT_WIDTH + * - set UNITY_LONG_WIDTH + * - set UNITY_POINTER_WIDTH + + * Floats + * - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons + * - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT + * - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats + * - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons + * - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default) + * - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE + * - define UNITY_DOUBLE_TYPE to specify something other than double + * - define UNITY_EXCLUDE_FLOAT_PRINT to trim binary size, won't print floating point values in errors + + * Output + * - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired + * - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure + + * Optimization + * - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge + * - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests. + + * Test Cases + * - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script + + * Parameterized Tests + * - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing + + * Tests with Arguments + * - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity + + *------------------------------------------------------- + * Basic Fail and Ignore + *-------------------------------------------------------*/ + +#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, (message)) +#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL) +#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, (message)) +#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL) +#define TEST_MESSAGE(message) UnityMessage((message), __LINE__) +#define TEST_ONLY() + +/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails. + * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */ +#define TEST_PASS() TEST_ABORT() +#define TEST_PASS_MESSAGE(message) do { UnityMessage((message), __LINE__); TEST_ABORT(); } while(0) + +/* This macro does nothing, but it is useful for build tools (like Ceedling) to make use of this to figure out + * which files should be linked to in order to perform a test. Use it like TEST_FILE("sandwiches.c") */ +#define TEST_FILE(a) + +/*------------------------------------------------------- + * Test Asserts (simple) + *-------------------------------------------------------*/ + +/* Boolean */ +#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE") +#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE") +#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE") +#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE") +#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL") +#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL") + +/* Integers (of all sizes) */ +#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_size_t(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_CHAR(expected, actual) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL) + +/* Integer Greater Than/ Less Than (of all sizes) */ +#define TEST_ASSERT_GREATER_THAN(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_LESS_THAN(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +/* Integer Ranges (of all sizes) */ +#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_size_t_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, NULL) + +/* Integer Array Ranges (of all sizes) */ +#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) + + +/* Structs and Strings */ +#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL) + +/* Arrays */ +#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_size_t_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) + +/* Arrays Compared To Single Value */ +#define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_size_t(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, NULL) + +/* Floating Point (If Enabled) */ +#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL) + +/* Double (If Enabled) */ +#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL) + +/* Shorthand */ +#ifdef UNITY_SHORTHAND_AS_OLD +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") +#endif +#ifdef UNITY_SHORTHAND_AS_INT +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_MEM +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_RAW +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal") +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") +#endif +#ifdef UNITY_SHORTHAND_AS_NONE +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif + +/*------------------------------------------------------- + * Test Asserts (with additional messages) + *-------------------------------------------------------*/ + +/* Boolean */ +#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) +#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) +#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) +#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) +#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, (message)) +#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message)) + +/* Integers (of all sizes) */ +#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_size_t_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, (message)) +#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) +#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message)) + +/* Integer Greater Than/ Less Than (of all sizes) */ +#define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_LESS_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + +/* Integer Ranges (of all sizes) */ +#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_size_t_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, (message)) + +/* Integer Array Ranges (of all sizes) */ +#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_size_t_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) + + +/* Structs and Strings */ +#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message)) + +/* Arrays */ +#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) + +/* Arrays Compared To Single Value*/ +#define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_size_t_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, (message)) + +/* Floating Point (If Enabled) */ +#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message)) + +/* Double (If Enabled) */ +#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message)) + +/* Shorthand */ +#ifdef UNITY_SHORTHAND_AS_OLD +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message)) +#endif +#ifdef UNITY_SHORTHAND_AS_INT +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_MEM +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_RAW +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message) +#endif +#ifdef UNITY_SHORTHAND_AS_NONE +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif + +/* end of UNITY_FRAMEWORK_H */ +#ifdef __cplusplus +} +#endif +#endif diff --git a/test_mini/libft/vendor/_unity/include/unity_fixture.h b/test_mini/libft/vendor/_unity/include/unity_fixture.h new file mode 100644 index 0000000..4cc403e --- /dev/null +++ b/test_mini/libft/vendor/_unity/include/unity_fixture.h @@ -0,0 +1,83 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#ifndef UNITY_FIXTURE_H_ +#define UNITY_FIXTURE_H_ + +#include "unity.h" +#include "unity_internals.h" +#include "unity_fixture_internals.h" + +#ifndef UNITY_FIXTURE_NO_EXTRAS +#include "unity_memory.h" +#endif + +int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)); + + +#define TEST_GROUP(group)\ + static const char* TEST_GROUP_##group = #group + +#define TEST_SETUP(group) void TEST_##group##_SETUP(void);\ + void TEST_##group##_SETUP(void) + +#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN(void);\ + void TEST_##group##_TEAR_DOWN(void) + + +#define TEST(group, name) \ + void TEST_##group##_##name##_(void);\ + void TEST_##group##_##name##_run(void);\ + void TEST_##group##_##name##_run(void)\ + {\ + UnityTestRunner(TEST_##group##_SETUP,\ + TEST_##group##_##name##_,\ + TEST_##group##_TEAR_DOWN,\ + "TEST(" #group ", " #name ")",\ + TEST_GROUP_##group, #name,\ + __FILE__, __LINE__);\ + }\ + void TEST_##group##_##name##_(void) + +#define IGNORE_TEST(group, name) \ + void TEST_##group##_##name##_(void);\ + void TEST_##group##_##name##_run(void);\ + void TEST_##group##_##name##_run(void)\ + {\ + UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")", TEST_GROUP_##group, #name);\ + }\ + void TEST_##group##_##name##_(void) + +/* Call this for each test, insider the group runner */ +#define RUN_TEST_CASE(group, name) \ + { void TEST_##group##_##name##_run(void);\ + TEST_##group##_##name##_run(); } + +/* This goes at the bottom of each test file or in a separate c file */ +#define TEST_GROUP_RUNNER(group)\ + void TEST_##group##_GROUP_RUNNER(void);\ + void TEST_##group##_GROUP_RUNNER(void) + +/* Call this from main */ +#define RUN_TEST_GROUP(group)\ + { void TEST_##group##_GROUP_RUNNER(void);\ + TEST_##group##_GROUP_RUNNER(); } + +/* CppUTest Compatibility Macros */ +#ifndef UNITY_EXCLUDE_CPPUTEST_ASSERTS +/* Sets a pointer and automatically restores it to its old value after teardown */ +#define UT_PTR_SET(ptr, newPointerValue) UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue), __LINE__) +#define TEST_ASSERT_POINTERS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_PTR((expected), (actual)) +#define TEST_ASSERT_BYTES_EQUAL(expected, actual) TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual)) +#define FAIL(message) TEST_FAIL_MESSAGE((message)) +#define CHECK(condition) TEST_ASSERT_TRUE((condition)) +#define LONGS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_INT((expected), (actual)) +#define STRCMP_EQUAL(expected, actual) TEST_ASSERT_EQUAL_STRING((expected), (actual)) +#define DOUBLES_EQUAL(expected, actual, delta) TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual)) +#endif + +#endif /* UNITY_FIXTURE_H_ */ diff --git a/test_mini/libft/vendor/_unity/include/unity_fixture_internals.h b/test_mini/libft/vendor/_unity/include/unity_fixture_internals.h new file mode 100644 index 0000000..1c51aa9 --- /dev/null +++ b/test_mini/libft/vendor/_unity/include/unity_fixture_internals.h @@ -0,0 +1,50 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#ifndef UNITY_FIXTURE_INTERNALS_H_ +#define UNITY_FIXTURE_INTERNALS_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +struct UNITY_FIXTURE_T +{ + int Verbose; + int Silent; + unsigned int RepeatCount; + const char* NameFilter; + const char* GroupFilter; +}; +extern struct UNITY_FIXTURE_T UnityFixture; + +typedef void unityfunction(void); +void UnityTestRunner(unityfunction* setup, + unityfunction* testBody, + unityfunction* teardown, + const char* printableName, + const char* group, + const char* name, + const char* file, unsigned int line); + +void UnityIgnoreTest(const char* printableName, const char* group, const char* name); +int UnityGetCommandLineOptions(int argc, const char* argv[]); +void UnityConcludeFixtureTest(void); + +void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line); +void UnityPointer_UndoAllSets(void); +void UnityPointer_Init(void); +#ifndef UNITY_MAX_POINTERS +#define UNITY_MAX_POINTERS 5 +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* UNITY_FIXTURE_INTERNALS_H_ */ diff --git a/test_mini/libft/vendor/_unity/include/unity_internals.h b/test_mini/libft/vendor/_unity/include/unity_internals.h new file mode 100644 index 0000000..f61cd33 --- /dev/null +++ b/test_mini/libft/vendor/_unity/include/unity_internals.h @@ -0,0 +1,1007 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#ifndef UNITY_INTERNALS_H +#define UNITY_INTERNALS_H + +#ifdef UNITY_INCLUDE_CONFIG_H +#include "unity_config.h" +#endif + +#ifndef UNITY_EXCLUDE_SETJMP_H +#include <setjmp.h> +#endif + +#ifndef UNITY_EXCLUDE_MATH_H +#include <math.h> +#endif + +#ifndef UNITY_EXCLUDE_STDDEF_H +#include <stddef.h> +#endif + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#include <stdarg.h> +#endif + +/* Unity Attempts to Auto-Detect Integer Types + * Attempt 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits + * Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long + * The user may override any of these derived constants: + * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */ +#ifndef UNITY_EXCLUDE_STDINT_H +#include <stdint.h> +#endif + +#ifndef UNITY_EXCLUDE_LIMITS_H +#include <limits.h> +#endif + +/*------------------------------------------------------- + * Guess Widths If Not Specified + *-------------------------------------------------------*/ + +/* Determine the size of an int, if not already specified. + * We cannot use sizeof(int), because it is not yet defined + * at this stage in the translation of the C program. + * Also sizeof(int) does return the size in addressable units on all platforms, + * which may not necessarily be the size in bytes. + * Therefore, infer it from UINT_MAX if possible. */ +#ifndef UNITY_INT_WIDTH + #ifdef UINT_MAX + #if (UINT_MAX == 0xFFFF) + #define UNITY_INT_WIDTH (16) + #elif (UINT_MAX == 0xFFFFFFFF) + #define UNITY_INT_WIDTH (32) + #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF) + #define UNITY_INT_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_INT_WIDTH (32) + #endif /* UINT_MAX */ +#endif + +/* Determine the size of a long, if not already specified. */ +#ifndef UNITY_LONG_WIDTH + #ifdef ULONG_MAX + #if (ULONG_MAX == 0xFFFF) + #define UNITY_LONG_WIDTH (16) + #elif (ULONG_MAX == 0xFFFFFFFF) + #define UNITY_LONG_WIDTH (32) + #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF) + #define UNITY_LONG_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_LONG_WIDTH (32) + #endif /* ULONG_MAX */ +#endif + +/* Determine the size of a pointer, if not already specified. */ +#ifndef UNITY_POINTER_WIDTH + #ifdef UINTPTR_MAX + #if (UINTPTR_MAX <= 0xFFFF) + #define UNITY_POINTER_WIDTH (16) + #elif (UINTPTR_MAX <= 0xFFFFFFFF) + #define UNITY_POINTER_WIDTH (32) + #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF) + #define UNITY_POINTER_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH + #endif /* UINTPTR_MAX */ +#endif + +/*------------------------------------------------------- + * Int Support (Define types based on detected sizes) + *-------------------------------------------------------*/ + +#if (UNITY_INT_WIDTH == 32) + typedef unsigned char UNITY_UINT8; + typedef unsigned short UNITY_UINT16; + typedef unsigned int UNITY_UINT32; + typedef signed char UNITY_INT8; + typedef signed short UNITY_INT16; + typedef signed int UNITY_INT32; +#elif (UNITY_INT_WIDTH == 16) + typedef unsigned char UNITY_UINT8; + typedef unsigned int UNITY_UINT16; + typedef unsigned long UNITY_UINT32; + typedef signed char UNITY_INT8; + typedef signed int UNITY_INT16; + typedef signed long UNITY_INT32; +#else + #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported) +#endif + +/*------------------------------------------------------- + * 64-bit Support + *-------------------------------------------------------*/ + +/* Auto-detect 64 Bit Support */ +#ifndef UNITY_SUPPORT_64 + #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64 + #define UNITY_SUPPORT_64 + #endif +#endif + +/* 64-Bit Support Dependent Configuration */ +#ifndef UNITY_SUPPORT_64 + /* No 64-bit Support */ + typedef UNITY_UINT32 UNITY_UINT; + typedef UNITY_INT32 UNITY_INT; + #define UNITY_MAX_NIBBLES (8) /* Maximum number of nibbles in a UNITY_(U)INT */ +#else + /* 64-bit Support */ + #if (UNITY_LONG_WIDTH == 32) + typedef unsigned long long UNITY_UINT64; + typedef signed long long UNITY_INT64; + #elif (UNITY_LONG_WIDTH == 64) + typedef unsigned long UNITY_UINT64; + typedef signed long UNITY_INT64; + #else + #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported) + #endif + typedef UNITY_UINT64 UNITY_UINT; + typedef UNITY_INT64 UNITY_INT; + #define UNITY_MAX_NIBBLES (16) /* Maximum number of nibbles in a UNITY_(U)INT */ +#endif + +/*------------------------------------------------------- + * Pointer Support + *-------------------------------------------------------*/ + +#if (UNITY_POINTER_WIDTH == 32) + #define UNITY_PTR_TO_INT UNITY_INT32 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32 +#elif (UNITY_POINTER_WIDTH == 64) + #define UNITY_PTR_TO_INT UNITY_INT64 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64 +#elif (UNITY_POINTER_WIDTH == 16) + #define UNITY_PTR_TO_INT UNITY_INT16 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16 +#else + #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported) +#endif + +#ifndef UNITY_PTR_ATTRIBUTE + #define UNITY_PTR_ATTRIBUTE +#endif + +#ifndef UNITY_INTERNAL_PTR + #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void* +#endif + +/*------------------------------------------------------- + * Float Support + *-------------------------------------------------------*/ + +#ifdef UNITY_EXCLUDE_FLOAT + +/* No Floating Point Support */ +#ifndef UNITY_EXCLUDE_DOUBLE +#define UNITY_EXCLUDE_DOUBLE /* Remove double when excluding float support */ +#endif +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +#define UNITY_EXCLUDE_FLOAT_PRINT +#endif + +#else + +/* Floating Point Support */ +#ifndef UNITY_FLOAT_PRECISION +#define UNITY_FLOAT_PRECISION (0.00001f) +#endif +#ifndef UNITY_FLOAT_TYPE +#define UNITY_FLOAT_TYPE float +#endif +typedef UNITY_FLOAT_TYPE UNITY_FLOAT; + +/* isinf & isnan macros should be provided by math.h */ +#ifndef isinf +/* The value of Inf - Inf is NaN */ +#define isinf(n) (isnan((n) - (n)) && !isnan(n)) +#endif + +#ifndef isnan +/* NaN is the only floating point value that does NOT equal itself. + * Therefore if n != n, then it is NaN. */ +#define isnan(n) ((n != n) ? 1 : 0) +#endif + +#endif + +/*------------------------------------------------------- + * Double Float Support + *-------------------------------------------------------*/ + +/* unlike float, we DON'T include by default */ +#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(UNITY_INCLUDE_DOUBLE) + + /* No Floating Point Support */ + #ifndef UNITY_EXCLUDE_DOUBLE + #define UNITY_EXCLUDE_DOUBLE + #else + #undef UNITY_INCLUDE_DOUBLE + #endif + + #ifndef UNITY_EXCLUDE_FLOAT + #ifndef UNITY_DOUBLE_TYPE + #define UNITY_DOUBLE_TYPE double + #endif + typedef UNITY_FLOAT UNITY_DOUBLE; + /* For parameter in UnityPrintFloat(UNITY_DOUBLE), which aliases to double or float */ + #endif + +#else + + /* Double Floating Point Support */ + #ifndef UNITY_DOUBLE_PRECISION + #define UNITY_DOUBLE_PRECISION (1e-12) + #endif + + #ifndef UNITY_DOUBLE_TYPE + #define UNITY_DOUBLE_TYPE double + #endif + typedef UNITY_DOUBLE_TYPE UNITY_DOUBLE; + +#endif + +/*------------------------------------------------------- + * Output Method: stdout (DEFAULT) + *-------------------------------------------------------*/ +#ifndef UNITY_OUTPUT_CHAR + /* Default to using putchar, which is defined in stdio.h */ + #include <stdio.h> + #define UNITY_OUTPUT_CHAR(a) (void)putchar(a) +#else + /* If defined as something else, make sure we declare it here so it's ready for use */ + #ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION + extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION; + #endif +#endif + +#ifndef UNITY_OUTPUT_FLUSH + #ifdef UNITY_USE_FLUSH_STDOUT + /* We want to use the stdout flush utility */ + #include <stdio.h> + #define UNITY_OUTPUT_FLUSH() (void)fflush(stdout) + #else + /* We've specified nothing, therefore flush should just be ignored */ + #define UNITY_OUTPUT_FLUSH() + #endif +#else + /* If defined as something else, make sure we declare it here so it's ready for use */ + #ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION + extern void UNITY_OUTPUT_FLUSH_HEADER_DECLARATION; + #endif +#endif + +#ifndef UNITY_OUTPUT_FLUSH +#define UNITY_FLUSH_CALL() +#else +#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH() +#endif + +#ifndef UNITY_PRINT_EOL +#define UNITY_PRINT_EOL() UNITY_OUTPUT_CHAR('\n') +#endif + +#ifndef UNITY_OUTPUT_START +#define UNITY_OUTPUT_START() +#endif + +#ifndef UNITY_OUTPUT_COMPLETE +#define UNITY_OUTPUT_COMPLETE() +#endif + +#ifdef UNITY_INCLUDE_EXEC_TIME + #if !defined(UNITY_EXEC_TIME_START) && \ + !defined(UNITY_EXEC_TIME_STOP) && \ + !defined(UNITY_PRINT_EXEC_TIME) && \ + !defined(UNITY_TIME_TYPE) + /* If none any of these macros are defined then try to provide a default implementation */ + + #if defined(UNITY_CLOCK_MS) + /* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */ + #define UNITY_TIME_TYPE UNITY_UINT + #define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS() + #define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS() + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #elif defined(_WIN32) + #include <time.h> + #define UNITY_TIME_TYPE clock_t + #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC) + #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) + #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #elif defined(__unix__) + #include <time.h> + #define UNITY_TIME_TYPE struct timespec + #define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t) + #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) + #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = ((Unity.CurrentTestStopTime.tv_sec - Unity.CurrentTestStartTime.tv_sec) * 1000L); \ + execTimeMs += ((Unity.CurrentTestStopTime.tv_nsec - Unity.CurrentTestStartTime.tv_nsec) / 1000000L); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #endif + #endif +#endif + +#ifndef UNITY_EXEC_TIME_START +#define UNITY_EXEC_TIME_START() do{}while(0) +#endif + +#ifndef UNITY_EXEC_TIME_STOP +#define UNITY_EXEC_TIME_STOP() do{}while(0) +#endif + +#ifndef UNITY_TIME_TYPE +#define UNITY_TIME_TYPE UNITY_UINT +#endif + +#ifndef UNITY_PRINT_EXEC_TIME +#define UNITY_PRINT_EXEC_TIME() do{}while(0) +#endif + +/*------------------------------------------------------- + * Footprint + *-------------------------------------------------------*/ + +#ifndef UNITY_LINE_TYPE +#define UNITY_LINE_TYPE UNITY_UINT +#endif + +#ifndef UNITY_COUNTER_TYPE +#define UNITY_COUNTER_TYPE UNITY_UINT +#endif + +/*------------------------------------------------------- + * Internal Structs Needed + *-------------------------------------------------------*/ + +typedef void (*UnityTestFunction)(void); + +#define UNITY_DISPLAY_RANGE_INT (0x10) +#define UNITY_DISPLAY_RANGE_UINT (0x20) +#define UNITY_DISPLAY_RANGE_HEX (0x40) +#define UNITY_DISPLAY_RANGE_CHAR (0x80) + +typedef enum +{ + UNITY_DISPLAY_STYLE_INT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT, +#endif + + UNITY_DISPLAY_STYLE_UINT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT, +#endif + + UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX, + UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX, + UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX, +#endif + + UNITY_DISPLAY_STYLE_CHAR = 1 + UNITY_DISPLAY_RANGE_CHAR + UNITY_DISPLAY_RANGE_INT, + + UNITY_DISPLAY_STYLE_UNKNOWN +} UNITY_DISPLAY_STYLE_T; + +typedef enum +{ + UNITY_WITHIN = 0x0, + UNITY_EQUAL_TO = 0x1, + UNITY_GREATER_THAN = 0x2, + UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO, + UNITY_SMALLER_THAN = 0x4, + UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO, + UNITY_UNKNOWN +} UNITY_COMPARISON_T; + +#ifndef UNITY_EXCLUDE_FLOAT +typedef enum UNITY_FLOAT_TRAIT +{ + UNITY_FLOAT_IS_NOT_INF = 0, + UNITY_FLOAT_IS_INF, + UNITY_FLOAT_IS_NOT_NEG_INF, + UNITY_FLOAT_IS_NEG_INF, + UNITY_FLOAT_IS_NOT_NAN, + UNITY_FLOAT_IS_NAN, + UNITY_FLOAT_IS_NOT_DET, + UNITY_FLOAT_IS_DET, + UNITY_FLOAT_INVALID_TRAIT +} UNITY_FLOAT_TRAIT_T; +#endif + +typedef enum +{ + UNITY_ARRAY_TO_VAL = 0, + UNITY_ARRAY_TO_ARRAY, + UNITY_ARRAY_UNKNOWN +} UNITY_FLAGS_T; + +struct UNITY_STORAGE_T +{ + const char* TestFile; + const char* CurrentTestName; +#ifndef UNITY_EXCLUDE_DETAILS + const char* CurrentDetail1; + const char* CurrentDetail2; +#endif + UNITY_LINE_TYPE CurrentTestLineNumber; + UNITY_COUNTER_TYPE NumberOfTests; + UNITY_COUNTER_TYPE TestFailures; + UNITY_COUNTER_TYPE TestIgnores; + UNITY_COUNTER_TYPE CurrentTestFailed; + UNITY_COUNTER_TYPE CurrentTestIgnored; +#ifdef UNITY_INCLUDE_EXEC_TIME + UNITY_TIME_TYPE CurrentTestStartTime; + UNITY_TIME_TYPE CurrentTestStopTime; +#endif +#ifndef UNITY_EXCLUDE_SETJMP_H + jmp_buf AbortFrame; +#endif +}; + +extern struct UNITY_STORAGE_T Unity; + +/*------------------------------------------------------- + * Test Suite Management + *-------------------------------------------------------*/ + +void UnityBegin(const char* filename); +int UnityEnd(void); +void UnitySetTestFile(const char* filename); +void UnityConcludeTest(void); + +#ifndef RUN_TEST +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum); +#else +#define UNITY_SKIP_DEFAULT_RUNNER +#endif + +/*------------------------------------------------------- + * Details Support + *-------------------------------------------------------*/ + +#ifdef UNITY_EXCLUDE_DETAILS +#define UNITY_CLR_DETAILS() +#define UNITY_SET_DETAIL(d1) +#define UNITY_SET_DETAILS(d1,d2) +#else +#define UNITY_CLR_DETAILS() { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } +#define UNITY_SET_DETAIL(d1) { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } +#define UNITY_SET_DETAILS(d1,d2) { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } + +#ifndef UNITY_DETAIL1_NAME +#define UNITY_DETAIL1_NAME "Function" +#endif + +#ifndef UNITY_DETAIL2_NAME +#define UNITY_DETAIL2_NAME "Argument" +#endif +#endif + +/*------------------------------------------------------- + * Test Output + *-------------------------------------------------------*/ + +void UnityPrint(const char* string); + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintFormatted(const char* format, ...); +#endif + +void UnityPrintLen(const char* string, const UNITY_UINT32 length); +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number); +void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style); +void UnityPrintNumber(const UNITY_INT number_to_print); +void UnityPrintNumberUnsigned(const UNITY_UINT number); +void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print); + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +void UnityPrintFloat(const UNITY_DOUBLE input_number); +#endif + +/*------------------------------------------------------- + * Test Assertion Functions + *------------------------------------------------------- + * Use the macros below this section instead of calling + * these directly. The macros have a consistent naming + * convention and will pull in file and line information + * for you. */ + +void UnityAssertEqualNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, + const UNITY_INT actual, + const UNITY_COMPARISON_T compare, + const char *msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags); + +void UnityAssertBits(const UNITY_INT mask, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualString(const char* expected, + const char* actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualStringLen(const char* expected, + const char* actual, + const UNITY_UINT32 length, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualStringArray( UNITY_INTERNAL_PTR expected, + const char** actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 length, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertNumbersWithin(const UNITY_UINT delta, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, + UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags); + +void UnityFail(const char* message, const UNITY_LINE_TYPE line); +void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +void UnityMessage(const char* message, const UNITY_LINE_TYPE line); + +#ifndef UNITY_EXCLUDE_FLOAT +void UnityAssertFloatsWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertFloatSpecial(const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style); +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style); +#endif + +/*------------------------------------------------------- + * Helpers + *-------------------------------------------------------*/ + +UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size); +#ifndef UNITY_EXCLUDE_FLOAT +UNITY_INTERNAL_PTR UnityFloatToPtr(const float num); +#endif +#ifndef UNITY_EXCLUDE_DOUBLE +UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num); +#endif + +/*------------------------------------------------------- + * Error Strings We Might Need + *-------------------------------------------------------*/ + +extern const char UnityStrOk[]; +extern const char UnityStrPass[]; +extern const char UnityStrFail[]; +extern const char UnityStrIgnore[]; + +extern const char UnityStrErrFloat[]; +extern const char UnityStrErrDouble[]; +extern const char UnityStrErr64[]; +extern const char UnityStrErrShorthand[]; + +/*------------------------------------------------------- + * Test Running Macros + *-------------------------------------------------------*/ + +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) +#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) +#else +#define TEST_PROTECT() 1 +#define TEST_ABORT() return +#endif + +/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */ +#ifndef RUN_TEST +#ifdef __STDC_VERSION__ +#if __STDC_VERSION__ >= 199901L +#define UNITY_SUPPORT_VARIADIC_MACROS +#endif +#endif +#ifdef UNITY_SUPPORT_VARIADIC_MACROS +#define RUN_TEST(...) UnityDefaultTestRun(RUN_TEST_FIRST(__VA_ARGS__), RUN_TEST_SECOND(__VA_ARGS__)) +#define RUN_TEST_FIRST(...) RUN_TEST_FIRST_HELPER(__VA_ARGS__, throwaway) +#define RUN_TEST_FIRST_HELPER(first, ...) (first), #first +#define RUN_TEST_SECOND(...) RUN_TEST_SECOND_HELPER(__VA_ARGS__, __LINE__, throwaway) +#define RUN_TEST_SECOND_HELPER(first, second, ...) (second) +#endif +#endif + +/* If we can't do the tricky version, we'll just have to require them to always include the line number */ +#ifndef RUN_TEST +#ifdef CMOCK +#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num) +#else +#define RUN_TEST(func) UnityDefaultTestRun(func, #func, __LINE__) +#endif +#endif + +#define TEST_LINE_NUM (Unity.CurrentTestLineNumber) +#define TEST_IS_IGNORED (Unity.CurrentTestIgnored) +#define UNITY_NEW_TEST(a) \ + Unity.CurrentTestName = (a); \ + Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)(__LINE__); \ + Unity.NumberOfTests++; + +#ifndef UNITY_BEGIN +#define UNITY_BEGIN() UnityBegin(__FILE__) +#endif + +#ifndef UNITY_END +#define UNITY_END() UnityEnd() +#endif + +#ifndef UNITY_SHORTHAND_AS_INT +#ifndef UNITY_SHORTHAND_AS_MEM +#ifndef UNITY_SHORTHAND_AS_NONE +#ifndef UNITY_SHORTHAND_AS_RAW +#define UNITY_SHORTHAND_AS_OLD +#endif +#endif +#endif +#endif + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ + +#ifdef UNITY_USE_COMMAND_LINE_ARGS +int UnityParseOptions(int argc, char** argv); +int UnityTestMatches(void); +#endif + +/*------------------------------------------------------- + * Basic Fail and Ignore + *-------------------------------------------------------*/ + +#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line)) + +/*------------------------------------------------------- + * Test Asserts + *-------------------------------------------------------*/ + +#define UNITY_TEST_ASSERT(condition, line, message) if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));} +#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (UNITY_LINE_TYPE)(line), (message)) + +#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_EQUAL_CHAR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) +#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line)) + +#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16) (threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32) (threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin( (delta), (UNITY_INT) (expected), (UNITY_INT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 ) (expected), (UNITY_INT)(UNITY_INT8 ) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16) (expected), (UNITY_INT)(UNITY_INT16) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32) (expected), (UNITY_INT)(UNITY_INT32) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin( (delta), (UNITY_INT) (expected), (UNITY_INT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_CHAR_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 ) (expected), (UNITY_INT)(UNITY_INT8 ) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) + + +#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_PTR_TO_INT)(expected), (UNITY_PTR_TO_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER) +#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len, line, message) UnityAssertEqualStringLen((const char*)(expected), (const char*)(actual), (UNITY_UINT32)(len), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), 1, (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) + +#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) + +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT) (expected), (UNITY_POINTER_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_VAL) + +#ifdef UNITY_SUPPORT_64 +#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) +#else +#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#endif + +#ifdef UNITY_EXCLUDE_FLOAT +#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#else +#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray(UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) +#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) +#endif + +#ifdef UNITY_EXCLUDE_DOUBLE +#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#else +#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray(UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) +#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) +#endif + +/* End of UNITY_INTERNALS_H */ +#endif diff --git a/test_mini/libft/vendor/_unity/include/unity_memory.h b/test_mini/libft/vendor/_unity/include/unity_memory.h new file mode 100644 index 0000000..ccdb826 --- /dev/null +++ b/test_mini/libft/vendor/_unity/include/unity_memory.h @@ -0,0 +1,60 @@ +/* ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#ifndef UNITY_MEMORY_OVERRIDES_H_ +#define UNITY_MEMORY_OVERRIDES_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include <stddef.h> + +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC +/* Define this macro to remove the use of stdlib.h, malloc, and free. + * Many embedded systems do not have a heap or malloc/free by default. + * This internal unity_malloc() provides allocated memory deterministically from + * the end of an array only, unity_free() only releases from end-of-array, + * blocks are not coalesced, and memory not freed in LIFO order is stranded. */ + #ifndef UNITY_INTERNAL_HEAP_SIZE_BYTES + #define UNITY_INTERNAL_HEAP_SIZE_BYTES 256 + #endif +#endif + +/* These functions are used by Unity to allocate and release memory + * on the heap and can be overridden with platform-specific implementations. + * For example, when using FreeRTOS UNITY_MALLOC becomes pvPortMalloc() + * and UNITY_FREE becomes vPortFree(). */ +#if !defined(UNITY_MALLOC) || !defined(UNITY_FREE) + #include <stdlib.h> + #define UNITY_MALLOC(size) malloc(size) + #define UNITY_FREE(ptr) free(ptr) +#else + extern void* UNITY_MALLOC(size_t size); + extern void UNITY_FREE(void* ptr); +#endif + +#define malloc unity_malloc +#define calloc unity_calloc +#define realloc unity_realloc +#define free unity_free + +void* unity_malloc(size_t size); +void* unity_calloc(size_t num, size_t size); +void* unity_realloc(void * oldMem, size_t size); +void unity_free(void * mem); + +/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */ +void UnityMalloc_StartTest(void); +void UnityMalloc_EndTest(void); +void UnityMalloc_MakeMallocFailAfterCount(int countdown); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/test_mini/libft/vendor/_unity/src/unity.c b/test_mini/libft/vendor/_unity/src/unity.c new file mode 100644 index 0000000..253c2cf --- /dev/null +++ b/test_mini/libft/vendor/_unity/src/unity.c @@ -0,0 +1,2088 @@ +/* ========================================================================= + Unity Project - A Test Framework for C + Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +============================================================================ */ + +#include "unity.h" +#include <stddef.h> + +#ifdef AVR +#include <avr/pgmspace.h> +#else +#define PROGMEM +#endif + +/* If omitted from header, declare overrideable prototypes here so they're ready for use */ +#ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION +void UNITY_OUTPUT_CHAR(int); +#endif + +/* Helpful macros for us to use here in Assert functions */ +#define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } +#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } +#define RETURN_IF_FAIL_OR_IGNORE if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) return + +struct UNITY_STORAGE_T Unity; + +#ifdef UNITY_OUTPUT_COLOR +const char PROGMEM UnityStrOk[] = "\033[42mOK\033[00m"; +const char PROGMEM UnityStrPass[] = "\033[42mPASS\033[00m"; +const char PROGMEM UnityStrFail[] = "\033[41mFAIL\033[00m"; +const char PROGMEM UnityStrIgnore[] = "\033[43mIGNORE\033[00m"; +#else +const char PROGMEM UnityStrOk[] = "OK"; +const char PROGMEM UnityStrPass[] = "PASS"; +const char PROGMEM UnityStrFail[] = "FAIL"; +const char PROGMEM UnityStrIgnore[] = "IGNORE"; +#endif +static const char PROGMEM UnityStrNull[] = "NULL"; +static const char PROGMEM UnityStrSpacer[] = ". "; +static const char PROGMEM UnityStrExpected[] = " Expected "; +static const char PROGMEM UnityStrWas[] = " Was "; +static const char PROGMEM UnityStrGt[] = " to be greater than "; +static const char PROGMEM UnityStrLt[] = " to be less than "; +static const char PROGMEM UnityStrOrEqual[] = "or equal to "; +static const char PROGMEM UnityStrElement[] = " Element "; +static const char PROGMEM UnityStrByte[] = " Byte "; +static const char PROGMEM UnityStrMemory[] = " Memory Mismatch."; +static const char PROGMEM UnityStrDelta[] = " Values Not Within Delta "; +static const char PROGMEM UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; +static const char PROGMEM UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; +static const char PROGMEM UnityStrNullPointerForActual[] = " Actual pointer was NULL"; +#ifndef UNITY_EXCLUDE_FLOAT +static const char PROGMEM UnityStrNot[] = "Not "; +static const char PROGMEM UnityStrInf[] = "Infinity"; +static const char PROGMEM UnityStrNegInf[] = "Negative Infinity"; +static const char PROGMEM UnityStrNaN[] = "NaN"; +static const char PROGMEM UnityStrDet[] = "Determinate"; +static const char PROGMEM UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; +#endif +const char PROGMEM UnityStrErrShorthand[] = "Unity Shorthand Support Disabled"; +const char PROGMEM UnityStrErrFloat[] = "Unity Floating Point Disabled"; +const char PROGMEM UnityStrErrDouble[] = "Unity Double Precision Disabled"; +const char PROGMEM UnityStrErr64[] = "Unity 64-bit Support Disabled"; +static const char PROGMEM UnityStrBreaker[] = "-----------------------"; +static const char PROGMEM UnityStrResultsTests[] = " Tests "; +static const char PROGMEM UnityStrResultsFailures[] = " Failures "; +static const char PROGMEM UnityStrResultsIgnored[] = " Ignored "; +static const char PROGMEM UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; +static const char PROGMEM UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; + +/*----------------------------------------------- + * Pretty Printers & Test Result Output Handlers + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +/* Local helper function to print characters. */ +static void UnityPrintChar(const char* pch) +{ + /* printable characters plus CR & LF are printed */ + if ((*pch <= 126) && (*pch >= 32)) + { + UNITY_OUTPUT_CHAR(*pch); + } + /* write escaped carriage returns */ + else if (*pch == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (*pch == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)*pch, 2); + } +} + +/*-----------------------------------------------*/ +/* Local helper function to print ANSI escape strings e.g. "\033[42m". */ +#ifdef UNITY_OUTPUT_COLOR +static UNITY_UINT UnityPrintAnsiEscapeString(const char* string) +{ + const char* pch = string; + UNITY_UINT count = 0; + + while (*pch && (*pch != 'm')) + { + UNITY_OUTPUT_CHAR(*pch); + pch++; + count++; + } + UNITY_OUTPUT_CHAR('m'); + count++; + + return count; +} +#endif + +/*-----------------------------------------------*/ +void UnityPrint(const char* string) +{ + const char* pch = string; + + if (pch != NULL) + { + while (*pch) + { +#ifdef UNITY_OUTPUT_COLOR + /* print ANSI escape code */ + if ((*pch == 27) && (*(pch + 1) == '[')) + { + pch += UnityPrintAnsiEscapeString(pch); + continue; + } +#endif + UnityPrintChar(pch); + pch++; + } + } +} + +/*-----------------------------------------------*/ +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintFormatted(const char* format, ...) +{ + const char* pch = format; + va_list va; + va_start(va, format); + + if (pch != NULL) + { + while (*pch) + { + /* format identification character */ + if (*pch == '%') + { + pch++; + + if (pch != NULL) + { + switch (*pch) + { + case 'd': + case 'i': + { + const int number = va_arg(va, int); + UnityPrintNumber((UNITY_INT)number); + break; + } +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + case 'f': + case 'g': + { + const double number = va_arg(va, double); + UnityPrintFloat((UNITY_DOUBLE)number); + break; + } +#endif + case 'u': + { + const unsigned int number = va_arg(va, unsigned int); + UnityPrintNumberUnsigned((UNITY_UINT)number); + break; + } + case 'b': + { + const unsigned int number = va_arg(va, unsigned int); + const UNITY_UINT mask = (UNITY_UINT)0 - (UNITY_UINT)1; + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('b'); + UnityPrintMask(mask, (UNITY_UINT)number); + break; + } + case 'x': + case 'X': + case 'p': + { + const unsigned int number = va_arg(va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, 8); + break; + } + case 'c': + { + const int ch = va_arg(va, int); + UnityPrintChar((const char *)&ch); + break; + } + case 's': + { + const char * string = va_arg(va, const char *); + UnityPrint(string); + break; + } + case '%': + { + UnityPrintChar(pch); + break; + } + default: + { + /* print the unknown format character */ + UNITY_OUTPUT_CHAR('%'); + UnityPrintChar(pch); + break; + } + } + } + } +#ifdef UNITY_OUTPUT_COLOR + /* print ANSI escape code */ + else if ((*pch == 27) && (*(pch + 1) == '[')) + { + pch += UnityPrintAnsiEscapeString(pch); + continue; + } +#endif + else if (*pch == '\n') + { + UNITY_PRINT_EOL(); + } + else + { + UnityPrintChar(pch); + } + + pch++; + } + } + + va_end(va); +} +#endif /* ! UNITY_INCLUDE_PRINT_FORMATTED */ + +/*-----------------------------------------------*/ +void UnityPrintLen(const char* string, const UNITY_UINT32 length) +{ + const char* pch = string; + + if (pch != NULL) + { + while (*pch && ((UNITY_UINT32)(pch - string) < length)) + { + /* printable characters plus CR & LF are printed */ + if ((*pch <= 126) && (*pch >= 32)) + { + UNITY_OUTPUT_CHAR(*pch); + } + /* write escaped carriage returns */ + else if (*pch == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (*pch == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)*pch, 2); + } + pch++; + } + } +} + +/*-----------------------------------------------*/ +void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style) +{ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (style == UNITY_DISPLAY_STYLE_CHAR) + { + /* printable characters plus CR & LF are printed */ + UNITY_OUTPUT_CHAR('\''); + if ((number <= 126) && (number >= 32)) + { + UNITY_OUTPUT_CHAR((int)number); + } + /* write escaped carriage returns */ + else if (number == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (number == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, 2); + } + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrintNumber(number); + } + } + else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) + { + UnityPrintNumberUnsigned((UNITY_UINT)number); + } + else + { + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2)); + } +} + +/*-----------------------------------------------*/ +void UnityPrintNumber(const UNITY_INT number_to_print) +{ + UNITY_UINT number = (UNITY_UINT)number_to_print; + + if (number_to_print < 0) + { + /* A negative number, including MIN negative */ + UNITY_OUTPUT_CHAR('-'); + number = (~number) + 1; + } + UnityPrintNumberUnsigned(number); +} + +/*----------------------------------------------- + * basically do an itoa using as little ram as possible */ +void UnityPrintNumberUnsigned(const UNITY_UINT number) +{ + UNITY_UINT divisor = 1; + + /* figure out initial divisor */ + while (number / divisor > 9) + { + divisor *= 10; + } + + /* now mod and print, then divide divisor */ + do + { + UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); + divisor /= 10; + } while (divisor > 0); +} + +/*-----------------------------------------------*/ +void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print) +{ + int nibble; + char nibbles = nibbles_to_print; + + if ((unsigned)nibbles > UNITY_MAX_NIBBLES) + { + nibbles = UNITY_MAX_NIBBLES; + } + + while (nibbles > 0) + { + nibbles--; + nibble = (int)(number >> (nibbles * 4)) & 0x0F; + if (nibble <= 9) + { + UNITY_OUTPUT_CHAR((char)('0' + nibble)); + } + else + { + UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble)); + } + } +} + +/*-----------------------------------------------*/ +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number) +{ + UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1); + UNITY_INT32 i; + + for (i = 0; i < UNITY_INT_WIDTH; i++) + { + if (current_bit & mask) + { + if (current_bit & number) + { + UNITY_OUTPUT_CHAR('1'); + } + else + { + UNITY_OUTPUT_CHAR('0'); + } + } + else + { + UNITY_OUTPUT_CHAR('X'); + } + current_bit = current_bit >> 1; + } +} + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +/* + * This function prints a floating-point value in a format similar to + * printf("%.7g") on a single-precision machine or printf("%.9g") on a + * double-precision machine. The 7th digit won't always be totally correct + * in single-precision operation (for that level of accuracy, a more + * complicated algorithm would be needed). + */ +void UnityPrintFloat(const UNITY_DOUBLE input_number) +{ +#ifdef UNITY_INCLUDE_DOUBLE + static const int sig_digits = 9; + static const UNITY_INT32 min_scaled = 100000000; + static const UNITY_INT32 max_scaled = 1000000000; +#else + static const int sig_digits = 7; + static const UNITY_INT32 min_scaled = 1000000; + static const UNITY_INT32 max_scaled = 10000000; +#endif + + UNITY_DOUBLE number = input_number; + + /* print minus sign (does not handle negative zero) */ + if (number < 0.0f) + { + UNITY_OUTPUT_CHAR('-'); + number = -number; + } + + /* handle zero, NaN, and +/- infinity */ + if (number == 0.0f) + { + UnityPrint("0"); + } + else if (isnan(number)) + { + UnityPrint("nan"); + } + else if (isinf(number)) + { + UnityPrint("inf"); + } + else + { + UNITY_INT32 n_int = 0, n; + int exponent = 0; + int decimals, digits; + char buf[16] = {0}; + + /* + * Scale up or down by powers of 10. To minimize rounding error, + * start with a factor/divisor of 10^10, which is the largest + * power of 10 that can be represented exactly. Finally, compute + * (exactly) the remaining power of 10 and perform one more + * multiplication or division. + */ + if (number < 1.0f) + { + UNITY_DOUBLE factor = 1.0f; + + while (number < (UNITY_DOUBLE)max_scaled / 1e10f) { number *= 1e10f; exponent -= 10; } + while (number * factor < (UNITY_DOUBLE)min_scaled) { factor *= 10.0f; exponent--; } + + number *= factor; + } + else if (number > (UNITY_DOUBLE)max_scaled) + { + UNITY_DOUBLE divisor = 1.0f; + + while (number > (UNITY_DOUBLE)min_scaled * 1e10f) { number /= 1e10f; exponent += 10; } + while (number / divisor > (UNITY_DOUBLE)max_scaled) { divisor *= 10.0f; exponent++; } + + number /= divisor; + } + else + { + /* + * In this range, we can split off the integer part before + * doing any multiplications. This reduces rounding error by + * freeing up significant bits in the fractional part. + */ + UNITY_DOUBLE factor = 1.0f; + n_int = (UNITY_INT32)number; + number -= (UNITY_DOUBLE)n_int; + + while (n_int < min_scaled) { n_int *= 10; factor *= 10.0f; exponent--; } + + number *= factor; + } + + /* round to nearest integer */ + n = ((UNITY_INT32)(number + number) + 1) / 2; + +#ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO + /* round to even if exactly between two integers */ + if ((n & 1) && (((UNITY_DOUBLE)n - number) == 0.5f)) + n--; +#endif + + n += n_int; + + if (n >= max_scaled) + { + n = min_scaled; + exponent++; + } + + /* determine where to place decimal point */ + decimals = ((exponent <= 0) && (exponent >= -(sig_digits + 3))) ? (-exponent) : (sig_digits - 1); + exponent += decimals; + + /* truncate trailing zeroes after decimal point */ + while ((decimals > 0) && ((n % 10) == 0)) + { + n /= 10; + decimals--; + } + + /* build up buffer in reverse order */ + digits = 0; + while ((n != 0) || (digits < (decimals + 1))) + { + buf[digits++] = (char)('0' + n % 10); + n /= 10; + } + while (digits > 0) + { + if (digits == decimals) { UNITY_OUTPUT_CHAR('.'); } + UNITY_OUTPUT_CHAR(buf[--digits]); + } + + /* print exponent if needed */ + if (exponent != 0) + { + UNITY_OUTPUT_CHAR('e'); + + if (exponent < 0) + { + UNITY_OUTPUT_CHAR('-'); + exponent = -exponent; + } + else + { + UNITY_OUTPUT_CHAR('+'); + } + + digits = 0; + while ((exponent != 0) || (digits < 2)) + { + buf[digits++] = (char)('0' + exponent % 10); + exponent /= 10; + } + while (digits > 0) + { + UNITY_OUTPUT_CHAR(buf[--digits]); + } + } + } +} +#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */ + +/*-----------------------------------------------*/ +static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) +{ +#ifdef UNITY_OUTPUT_FOR_ECLIPSE + UNITY_OUTPUT_CHAR('('); + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(')'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#else +#ifdef UNITY_OUTPUT_FOR_IAR_WORKBENCH + UnityPrint("<SRCREF line="); + UnityPrintNumber((UNITY_INT)line); + UnityPrint(" file=\""); + UnityPrint(file); + UNITY_OUTPUT_CHAR('"'); + UNITY_OUTPUT_CHAR('>'); + UnityPrint(Unity.CurrentTestName); + UnityPrint("</SRCREF> "); +#else +#ifdef UNITY_OUTPUT_FOR_QT_CREATOR + UnityPrint("file://"); + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#else + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(':'); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#endif +#endif +#endif +} + +/*-----------------------------------------------*/ +static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + UNITY_OUTPUT_CHAR(':'); +} + +/*-----------------------------------------------*/ +void UnityConcludeTest(void) +{ + if (Unity.CurrentTestIgnored) + { + Unity.TestIgnores++; + } + else if (!Unity.CurrentTestFailed) + { + UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); + UnityPrint(UnityStrPass); + } + else + { + Unity.TestFailures++; + } + + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; + UNITY_PRINT_EXEC_TIME(); + UNITY_PRINT_EOL(); + UNITY_FLUSH_CALL(); +} + +/*-----------------------------------------------*/ +static void UnityAddMsgIfSpecified(const char* msg) +{ + if (msg) + { + UnityPrint(UnityStrSpacer); +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + UnityPrint(UnityStrSpacer); + } +#endif + UnityPrint(msg); + } +} + +/*-----------------------------------------------*/ +static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual) +{ + UnityPrint(UnityStrExpected); + if (expected != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrint(expected); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } + UnityPrint(UnityStrWas); + if (actual != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrint(actual); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } +} + +/*-----------------------------------------------*/ +static void UnityPrintExpectedAndActualStringsLen(const char* expected, + const char* actual, + const UNITY_UINT32 length) +{ + UnityPrint(UnityStrExpected); + if (expected != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrintLen(expected, length); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } + UnityPrint(UnityStrWas); + if (actual != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrintLen(actual, length); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } +} + +/*----------------------------------------------- + * Assertion & Control Helpers + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_LINE_TYPE lineNumber, + const char* msg) +{ + /* Both are NULL or same pointer */ + if (expected == actual) { return 0; } + + /* print and return true if just expected is NULL */ + if (expected == NULL) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrNullPointerForExpected); + UnityAddMsgIfSpecified(msg); + return 1; + } + + /* print and return true if just actual is NULL */ + if (actual == NULL) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrNullPointerForActual); + UnityAddMsgIfSpecified(msg); + return 1; + } + + return 0; /* return false if neither is NULL */ +} + +/*----------------------------------------------- + * Assertion Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityAssertBits(const UNITY_INT mask, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if ((mask & expected) != (mask & actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected); + UnityPrint(UnityStrWas); + UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (expected != actual) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, + const UNITY_INT actual, + const UNITY_COMPARISON_T compare, + const char *msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + int failed = 0; + RETURN_IF_FAIL_OR_IGNORE; + + if ((threshold == actual) && (compare & UNITY_EQUAL_TO)) { return; } + if ((threshold == actual)) { failed = 1; } + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + } + else /* UINT or HEX */ + { + if (((UNITY_UINT)actual > (UNITY_UINT)threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (((UNITY_UINT)actual < (UNITY_UINT)threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(actual, style); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + UnityPrintNumberByStyle(threshold, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#define UnityPrintPointlessAndBail() \ +{ \ + UnityTestResultsFailBegin(lineNumber); \ + UnityPrint(UnityStrPointless); \ + UnityAddMsgIfSpecified(msg); \ + UNITY_FAIL_AND_BAIL; } + +/*-----------------------------------------------*/ +void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + unsigned int length = style & 0xF; + unsigned int increment = 0; + + RETURN_IF_FAIL_OR_IGNORE; + + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while ((elements > 0) && (elements--)) + { + UNITY_INT expect_val; + UNITY_INT actual_val; + + switch (length) + { + case 1: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + increment = sizeof(UNITY_INT8); + break; + + case 2: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + increment = sizeof(UNITY_INT16); + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + increment = sizeof(UNITY_INT32); + length = 4; + break; + } + + if (expect_val != actual_val) + { + if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) + { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ + UNITY_INT mask = 1; + mask = (mask << 8 * length) - 1; + expect_val &= mask; + actual_val &= mask; + } + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual_val, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + /* Walk through array by incrementing the pointers */ + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); + } + actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); + } +} + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_FLOAT +/* Wrap this define in a function with variable types as float or double */ +#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ + if (isinf(expected) && isinf(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ + if (UNITY_NAN_CHECK) return 1; \ + (diff) = (actual) - (expected); \ + if ((diff) < 0) (diff) = -(diff); \ + if ((delta) < 0) (delta) = -(delta); \ + return !(isnan(diff) || isinf(diff) || ((diff) > (delta))) + /* This first part of this condition will catch any NaN or Infinite values */ +#ifndef UNITY_NAN_NOT_EQUAL_NAN + #define UNITY_NAN_CHECK isnan(expected) && isnan(actual) +#else + #define UNITY_NAN_CHECK 0 +#endif + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + { \ + UnityPrint(UnityStrExpected); \ + UnityPrintFloat(expected); \ + UnityPrint(UnityStrWas); \ + UnityPrintFloat(actual); } +#else + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + UnityPrint(UnityStrDelta) +#endif /* UNITY_EXCLUDE_FLOAT_PRINT */ + +/*-----------------------------------------------*/ +static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) +{ + UNITY_FLOAT diff; + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + ptr_expected++; + } + ptr_actual++; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatsWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + + if (!UnityFloatsWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatSpecial(const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style) +{ + const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; + UNITY_INT should_be_trait = ((UNITY_INT)style & 1); + UNITY_INT is_trait = !should_be_trait; + UNITY_INT trait_index = (UNITY_INT)(style >> 1); + + RETURN_IF_FAIL_OR_IGNORE; + + switch (style) + { + case UNITY_FLOAT_IS_INF: + case UNITY_FLOAT_IS_NOT_INF: + is_trait = isinf(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = isinf(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = isnan(actual) ? 1 : 0; + break; + + case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ + case UNITY_FLOAT_IS_NOT_DET: + is_trait = !isinf(actual) && !isnan(actual); + break; + + default: + trait_index = 0; + trait_names[0] = UnityStrInvalidFloatTrait; + break; + } + + if (is_trait != should_be_trait) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + if (!should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); + UnityPrint(UnityStrWas); +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + UnityPrintFloat((UNITY_DOUBLE)actual); +#else + if (should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); +#endif + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#endif /* not UNITY_EXCLUDE_FLOAT */ + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_DOUBLE +static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) +{ + UNITY_DOUBLE diff; + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + ptr_expected++; + } + ptr_actual++; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (!UnityDoublesWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style) +{ + const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; + UNITY_INT should_be_trait = ((UNITY_INT)style & 1); + UNITY_INT is_trait = !should_be_trait; + UNITY_INT trait_index = (UNITY_INT)(style >> 1); + + RETURN_IF_FAIL_OR_IGNORE; + + switch (style) + { + case UNITY_FLOAT_IS_INF: + case UNITY_FLOAT_IS_NOT_INF: + is_trait = isinf(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = isinf(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = isnan(actual) ? 1 : 0; + break; + + case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ + case UNITY_FLOAT_IS_NOT_DET: + is_trait = !isinf(actual) && !isnan(actual); + break; + + default: + trait_index = 0; + trait_names[0] = UnityStrInvalidFloatTrait; + break; + } + + if (is_trait != should_be_trait) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + if (!should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); + UnityPrint(UnityStrWas); +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + UnityPrintFloat(actual); +#else + if (should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); +#endif + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#endif /* not UNITY_EXCLUDE_DOUBLE */ + +/*-----------------------------------------------*/ +void UnityAssertNumbersWithin(const UNITY_UINT delta, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (actual > expected) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); + } + } + else + { + if ((UNITY_UINT)actual > (UNITY_UINT)expected) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, + UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + unsigned int length = style & 0xF; + unsigned int increment = 0; + + RETURN_IF_FAIL_OR_IGNORE; + + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while ((elements > 0) && (elements--)) + { + UNITY_INT expect_val; + UNITY_INT actual_val; + + switch (length) + { + case 1: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + increment = sizeof(UNITY_INT8); + break; + + case 2: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + increment = sizeof(UNITY_INT16); + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + increment = sizeof(UNITY_INT32); + length = 4; + break; + } + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (actual_val > expect_val) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); + } + } + else + { + if ((UNITY_UINT)actual_val > (UNITY_UINT)expect_val) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); + } + } + + if (Unity.CurrentTestFailed) + { + if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) + { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ + UNITY_INT mask = 1; + mask = (mask << 8 * length) - 1; + expect_val &= mask; + actual_val &= mask; + } + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual_val, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + /* Walk through array by incrementing the pointers */ + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); + } + actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualString(const char* expected, + const char* actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + UNITY_UINT32 i; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if both pointers not null compare the strings */ + if (expected && actual) + { + for (i = 0; expected[i] || actual[i]; i++) + { + if (expected[i] != actual[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expected != actual) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrintExpectedAndActualStrings(expected, actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualStringLen(const char* expected, + const char* actual, + const UNITY_UINT32 length, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + UNITY_UINT32 i; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if both pointers not null compare the strings */ + if (expected && actual) + { + for (i = 0; (i < length) && (expected[i] || actual[i]); i++) + { + if (expected[i] != actual[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expected != actual) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrintExpectedAndActualStringsLen(expected, actual, length); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected, + const char** actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 i = 0; + UNITY_UINT32 j = 0; + const char* expd = NULL; + const char* act = NULL; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if no elements, it's an error */ + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if ((const void*)expected == (const void*)actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + if (flags != UNITY_ARRAY_TO_ARRAY) + { + expd = (const char*)expected; + } + + do + { + act = actual[j]; + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expd = ((const char* const*)expected)[j]; + } + + /* if both pointers not null compare the strings */ + if (expd && act) + { + for (i = 0; expd[i] || act[i]; i++) + { + if (expd[i] != act[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expd != act) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + if (num_elements > 1) + { + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(j); + } + UnityPrintExpectedAndActualStrings(expd, act); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + } while (++j < num_elements); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 length, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; + UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual; + UNITY_UINT32 elements = num_elements; + UNITY_UINT32 bytes; + + RETURN_IF_FAIL_OR_IGNORE; + + if ((elements == 0) || (length == 0)) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + bytes = length; + while (bytes--) + { + if (*ptr_exp != *ptr_act) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrMemory); + if (num_elements > 1) + { + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + } + UnityPrint(UnityStrByte); + UnityPrintNumberUnsigned(length - bytes - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + ptr_exp++; + ptr_act++; + } + if (flags == UNITY_ARRAY_TO_VAL) + { + ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; + } + } +} + +/*-----------------------------------------------*/ + +static union +{ + UNITY_INT8 i8; + UNITY_INT16 i16; + UNITY_INT32 i32; +#ifdef UNITY_SUPPORT_64 + UNITY_INT64 i64; +#endif +#ifndef UNITY_EXCLUDE_FLOAT + float f; +#endif +#ifndef UNITY_EXCLUDE_DOUBLE + double d; +#endif +} UnityQuickCompare; + +UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size) +{ + switch(size) + { + case 1: + UnityQuickCompare.i8 = (UNITY_INT8)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8); + + case 2: + UnityQuickCompare.i16 = (UNITY_INT16)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16); + +#ifdef UNITY_SUPPORT_64 + case 8: + UnityQuickCompare.i64 = (UNITY_INT64)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64); +#endif + + default: /* 4 bytes */ + UnityQuickCompare.i32 = (UNITY_INT32)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32); + } +} + +#ifndef UNITY_EXCLUDE_FLOAT +/*-----------------------------------------------*/ +UNITY_INTERNAL_PTR UnityFloatToPtr(const float num) +{ + UnityQuickCompare.f = num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.f); +} +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +/*-----------------------------------------------*/ +UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num) +{ + UnityQuickCompare.d = num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.d); +} +#endif + +/*----------------------------------------------- + * Control Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityFail(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + UnityPrint(UnityStrSpacer); + } +#endif + if (msg[0] != ' ') + { + UNITY_OUTPUT_CHAR(' '); + } + UnityPrint(msg); + } + + UNITY_FAIL_AND_BAIL; +} + +/*-----------------------------------------------*/ +void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrIgnore); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(msg); + } + UNITY_IGNORE_AND_BAIL; +} + +/*-----------------------------------------------*/ +void UnityMessage(const char* msg, const UNITY_LINE_TYPE line) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint("INFO"); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(msg); + } + UNITY_PRINT_EOL(); +} + +/*-----------------------------------------------*/ +/* If we have not defined our own test runner, then include our default test runner to make life easier */ +#ifndef UNITY_SKIP_DEFAULT_RUNNER +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum) +{ + Unity.CurrentTestName = FuncName; + Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum; + Unity.NumberOfTests++; + UNITY_CLR_DETAILS(); + UNITY_EXEC_TIME_START(); + if (TEST_PROTECT()) + { + setUp(); + Func(); + } + if (TEST_PROTECT()) + { + tearDown(); + } + UNITY_EXEC_TIME_STOP(); + UnityConcludeTest(); +} +#endif + +/*-----------------------------------------------*/ +void UnitySetTestFile(const char* filename) +{ + Unity.TestFile = filename; +} + +/*-----------------------------------------------*/ +void UnityBegin(const char* filename) +{ + Unity.TestFile = filename; + Unity.CurrentTestName = NULL; + Unity.CurrentTestLineNumber = 0; + Unity.NumberOfTests = 0; + Unity.TestFailures = 0; + Unity.TestIgnores = 0; + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; + + UNITY_CLR_DETAILS(); + UNITY_OUTPUT_START(); +} + +/*-----------------------------------------------*/ +int UnityEnd(void) +{ + UNITY_PRINT_EOL(); + UnityPrint(UnityStrBreaker); + UNITY_PRINT_EOL(); + UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests)); + UnityPrint(UnityStrResultsTests); + UnityPrintNumber((UNITY_INT)(Unity.TestFailures)); + UnityPrint(UnityStrResultsFailures); + UnityPrintNumber((UNITY_INT)(Unity.TestIgnores)); + UnityPrint(UnityStrResultsIgnored); + UNITY_PRINT_EOL(); + if (Unity.TestFailures == 0U) + { + UnityPrint(UnityStrOk); + } + else + { + UnityPrint(UnityStrFail); +#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL + UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D'); +#endif + } + UNITY_PRINT_EOL(); + UNITY_FLUSH_CALL(); + UNITY_OUTPUT_COMPLETE(); + return (int)(Unity.TestFailures); +} + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ +#ifdef UNITY_USE_COMMAND_LINE_ARGS + +char* UnityOptionIncludeNamed = NULL; +char* UnityOptionExcludeNamed = NULL; +int UnityVerbosity = 1; + +/*-----------------------------------------------*/ +int UnityParseOptions(int argc, char** argv) +{ + int i; + UnityOptionIncludeNamed = NULL; + UnityOptionExcludeNamed = NULL; + + for (i = 1; i < argc; i++) + { + if (argv[i][0] == '-') + { + switch (argv[i][1]) + { + case 'l': /* list tests */ + return -1; + case 'n': /* include tests with name including this string */ + case 'f': /* an alias for -n */ + if (argv[i][2] == '=') + { + UnityOptionIncludeNamed = &argv[i][3]; + } + else if (++i < argc) + { + UnityOptionIncludeNamed = argv[i]; + } + else + { + UnityPrint("ERROR: No Test String to Include Matches For"); + UNITY_PRINT_EOL(); + return 1; + } + break; + case 'q': /* quiet */ + UnityVerbosity = 0; + break; + case 'v': /* verbose */ + UnityVerbosity = 2; + break; + case 'x': /* exclude tests with name including this string */ + if (argv[i][2] == '=') + { + UnityOptionExcludeNamed = &argv[i][3]; + } + else if (++i < argc) + { + UnityOptionExcludeNamed = argv[i]; + } + else + { + UnityPrint("ERROR: No Test String to Exclude Matches For"); + UNITY_PRINT_EOL(); + return 1; + } + break; + default: + UnityPrint("ERROR: Unknown Option "); + UNITY_OUTPUT_CHAR(argv[i][1]); + UNITY_PRINT_EOL(); + return 1; + } + } + } + + return 0; +} + +/*-----------------------------------------------*/ +int IsStringInBiggerString(const char* longstring, const char* shortstring) +{ + const char* lptr = longstring; + const char* sptr = shortstring; + const char* lnext = lptr; + + if (*sptr == '*') + { + return 1; + } + + while (*lptr) + { + lnext = lptr + 1; + + /* If they current bytes match, go on to the next bytes */ + while (*lptr && *sptr && (*lptr == *sptr)) + { + lptr++; + sptr++; + + /* We're done if we match the entire string or up to a wildcard */ + if (*sptr == '*') + return 1; + if (*sptr == ',') + return 1; + if (*sptr == '"') + return 1; + if (*sptr == '\'') + return 1; + if (*sptr == ':') + return 2; + if (*sptr == 0) + return 1; + } + + /* Otherwise we start in the long pointer 1 character further and try again */ + lptr = lnext; + sptr = shortstring; + } + + return 0; +} + +/*-----------------------------------------------*/ +int UnityStringArgumentMatches(const char* str) +{ + int retval; + const char* ptr1; + const char* ptr2; + const char* ptrf; + + /* Go through the options and get the substrings for matching one at a time */ + ptr1 = str; + while (ptr1[0] != 0) + { + if ((ptr1[0] == '"') || (ptr1[0] == '\'')) + { + ptr1++; + } + + /* look for the start of the next partial */ + ptr2 = ptr1; + ptrf = 0; + do + { + ptr2++; + if ((ptr2[0] == ':') && (ptr2[1] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')) + { + ptrf = &ptr2[1]; + } + } while ((ptr2[0] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')); + + while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ','))) + { + ptr2++; + } + + /* done if complete filename match */ + retval = IsStringInBiggerString(Unity.TestFile, ptr1); + if (retval == 1) + { + return retval; + } + + /* done if testname match after filename partial match */ + if ((retval == 2) && (ptrf != 0)) + { + if (IsStringInBiggerString(Unity.CurrentTestName, ptrf)) + { + return 1; + } + } + + /* done if complete testname match */ + if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1) + { + return 1; + } + + ptr1 = ptr2; + } + + /* we couldn't find a match for any substrings */ + return 0; +} + +/*-----------------------------------------------*/ +int UnityTestMatches(void) +{ + /* Check if this test name matches the included test pattern */ + int retval; + if (UnityOptionIncludeNamed) + { + retval = UnityStringArgumentMatches(UnityOptionIncludeNamed); + } + else + { + retval = 1; + } + + /* Check if this test name matches the excluded test pattern */ + if (UnityOptionExcludeNamed) + { + if (UnityStringArgumentMatches(UnityOptionExcludeNamed)) + { + retval = 0; + } + } + + return retval; +} + +#endif /* UNITY_USE_COMMAND_LINE_ARGS */ +/*-----------------------------------------------*/ diff --git a/test_mini/libft/vendor/_unity/src/unity_fixture.c b/test_mini/libft/vendor/_unity/src/unity_fixture.c new file mode 100644 index 0000000..c3dda79 --- /dev/null +++ b/test_mini/libft/vendor/_unity/src/unity_fixture.c @@ -0,0 +1,310 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#include "unity_fixture.h" +#include "unity_internals.h" +#include <string.h> + +struct UNITY_FIXTURE_T UnityFixture; + +/* If you decide to use the function pointer approach. + * Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h> + * int (*outputChar)(int) = putchar; */ + +void setUp(void) { /*does nothing*/ } +void tearDown(void) { /*does nothing*/ } + +static void announceTestRun(unsigned int runNumber) +{ + UnityPrint("Unity test run "); + UnityPrintNumberUnsigned(runNumber+1); + UnityPrint(" of "); + UnityPrintNumberUnsigned(UnityFixture.RepeatCount); + UNITY_PRINT_EOL(); +} + +int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)) +{ + int result = UnityGetCommandLineOptions(argc, argv); + unsigned int r; + if (result != 0) + return result; + + for (r = 0; r < UnityFixture.RepeatCount; r++) + { + UnityBegin(argv[0]); + announceTestRun(r); + runAllTests(); + if (!UnityFixture.Verbose) UNITY_PRINT_EOL(); + UnityEnd(); + } + + return (int)Unity.TestFailures; +} + +static int selected(const char* filter, const char* name) +{ + if (filter == 0) + return 1; + return strstr(name, filter) ? 1 : 0; +} + +static int testSelected(const char* test) +{ + return selected(UnityFixture.NameFilter, test); +} + +static int groupSelected(const char* group) +{ + return selected(UnityFixture.GroupFilter, group); +} + +void UnityTestRunner(unityfunction* setup, + unityfunction* testBody, + unityfunction* teardown, + const char* printableName, + const char* group, + const char* name, + const char* file, + unsigned int line) +{ + if (testSelected(name) && groupSelected(group)) + { + Unity.TestFile = file; + Unity.CurrentTestName = printableName; + Unity.CurrentTestLineNumber = line; + if (UnityFixture.Verbose) + { + UnityPrint(printableName); + #ifndef UNITY_REPEAT_TEST_NAME + Unity.CurrentTestName = NULL; + #endif + } + else if (UnityFixture.Silent) + { + /* Do Nothing */ + } + else + { + UNITY_OUTPUT_CHAR('.'); + } + + Unity.NumberOfTests++; + UnityPointer_Init(); + + UNITY_EXEC_TIME_START(); + + if (TEST_PROTECT()) + { + setup(); + testBody(); + } + if (TEST_PROTECT()) + { + teardown(); + } + if (TEST_PROTECT()) + { + UnityPointer_UndoAllSets(); + } + UnityConcludeFixtureTest(); + } +} + +void UnityIgnoreTest(const char* printableName, const char* group, const char* name) +{ + if (testSelected(name) && groupSelected(group)) + { + Unity.NumberOfTests++; + Unity.TestIgnores++; + if (UnityFixture.Verbose) + { + UnityPrint(printableName); + UNITY_PRINT_EOL(); + } + else if (UnityFixture.Silent) + { + /* Do Nothing */ + } + else + { + UNITY_OUTPUT_CHAR('!'); + } + } +} + +/*-------------------------------------------------------- */ +/*Automatic pointer restoration functions */ +struct PointerPair +{ + void** pointer; + void* old_value; +}; + +static struct PointerPair pointer_store[UNITY_MAX_POINTERS]; +static int pointer_index = 0; + +void UnityPointer_Init(void) +{ + pointer_index = 0; +} + +void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line) +{ + if (pointer_index >= UNITY_MAX_POINTERS) + { + UNITY_TEST_FAIL(line, "Too many pointers set"); + } + else + { + pointer_store[pointer_index].pointer = pointer; + pointer_store[pointer_index].old_value = *pointer; + *pointer = newValue; + pointer_index++; + } +} + +void UnityPointer_UndoAllSets(void) +{ + while (pointer_index > 0) + { + pointer_index--; + *(pointer_store[pointer_index].pointer) = + pointer_store[pointer_index].old_value; + } +} + +int UnityGetCommandLineOptions(int argc, const char* argv[]) +{ + int i; + UnityFixture.Verbose = 0; + UnityFixture.Silent = 0; + UnityFixture.GroupFilter = 0; + UnityFixture.NameFilter = 0; + UnityFixture.RepeatCount = 1; + + if (argc == 1) + return 0; + + for (i = 1; i < argc; ) + { + if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) + { + /* Usage */ + UnityPrint("Runs a series of unit tests."); + UNITY_PRINT_EOL(); + UNITY_PRINT_EOL(); + UnityPrint("When no flag is specified, all tests are run."); + UNITY_PRINT_EOL(); + UNITY_PRINT_EOL(); + UnityPrint("Optional flags:"); + UNITY_PRINT_EOL(); + UnityPrint(" -v Verbose output: show all tests executed even if they pass"); + UNITY_PRINT_EOL(); + UnityPrint(" -s Silent mode: minimal output showing only test failures"); + UNITY_PRINT_EOL(); + UnityPrint(" -g NAME Only run tests in groups that contain the string NAME"); + UNITY_PRINT_EOL(); + UnityPrint(" -n NAME Only run tests whose name contains the string NAME"); + UNITY_PRINT_EOL(); + UnityPrint(" -r NUMBER Repeatedly run all tests NUMBER times"); + UNITY_PRINT_EOL(); + UnityPrint(" -h, --help Display this help message"); + UNITY_PRINT_EOL(); + UNITY_PRINT_EOL(); +#ifdef UNITY_CUSTOM_HELP_MSG + /* User-defined help message, e.g. to point to project-specific documentation */ + UnityPrint(UNITY_CUSTOM_HELP_MSG); + UNITY_PRINT_EOL(); +#else + /* Default help suffix if a custom one is not defined */ + UnityPrint("More information about Unity: https://www.throwtheswitch.org/unity"); + UNITY_PRINT_EOL(); +#endif + return 1; /* Exit without running the tests */ + } + else if (strcmp(argv[i], "-v") == 0) + { + UnityFixture.Verbose = 1; + i++; + } + else if (strcmp(argv[i], "-s") == 0) + { + UnityFixture.Silent = 1; + i++; + } + else if (strcmp(argv[i], "-g") == 0) + { + i++; + if (i >= argc) + return 1; + UnityFixture.GroupFilter = argv[i]; + i++; + } + else if (strcmp(argv[i], "-n") == 0) + { + i++; + if (i >= argc) + return 1; + UnityFixture.NameFilter = argv[i]; + i++; + } + else if (strcmp(argv[i], "-r") == 0) + { + UnityFixture.RepeatCount = 2; + i++; + if (i < argc) + { + if (*(argv[i]) >= '0' && *(argv[i]) <= '9') + { + unsigned int digit = 0; + UnityFixture.RepeatCount = 0; + while (argv[i][digit] >= '0' && argv[i][digit] <= '9') + { + UnityFixture.RepeatCount *= 10; + UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0'; + } + i++; + } + } + } + else + { + /* ignore unknown parameter */ + i++; + } + } + return 0; +} + +void UnityConcludeFixtureTest(void) +{ + if (Unity.CurrentTestIgnored) + { + Unity.TestIgnores++; + UNITY_PRINT_EOL(); + } + else if (!Unity.CurrentTestFailed) + { + if (UnityFixture.Verbose) + { + UnityPrint(" "); + UnityPrint(UnityStrPass); + UNITY_EXEC_TIME_STOP(); + UNITY_PRINT_EXEC_TIME(); + UNITY_PRINT_EOL(); + } + } + else /* Unity.CurrentTestFailed */ + { + Unity.TestFailures++; + UNITY_PRINT_EOL(); + } + + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; +} diff --git a/test_mini/libft/vendor/_unity/unity_memory.c b/test_mini/libft/vendor/_unity/unity_memory.c new file mode 100644 index 0000000..e4dc665 --- /dev/null +++ b/test_mini/libft/vendor/_unity/unity_memory.c @@ -0,0 +1,202 @@ +/* ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#include "unity.h" +#include "unity_memory.h" +#include <string.h> + +#define MALLOC_DONT_FAIL -1 +static int malloc_count; +static int malloc_fail_countdown = MALLOC_DONT_FAIL; + +void UnityMalloc_StartTest(void) +{ + malloc_count = 0; + malloc_fail_countdown = MALLOC_DONT_FAIL; +} + +void UnityMalloc_EndTest(void) +{ + malloc_fail_countdown = MALLOC_DONT_FAIL; + if (malloc_count != 0) + { + UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!"); + } +} + +void UnityMalloc_MakeMallocFailAfterCount(int countdown) +{ + malloc_fail_countdown = countdown; +} + +/* These definitions are always included from unity_fixture_malloc_overrides.h */ +/* We undef to use them or avoid conflict with <stdlib.h> per the C standard */ +#undef malloc +#undef free +#undef calloc +#undef realloc + +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC +static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES]; +static size_t heap_index; +#else +#include <stdlib.h> +#endif + +typedef struct GuardBytes +{ + size_t size; + size_t guard_space; +} Guard; + +#define UNITY_MALLOC_ALIGNMENT (UNITY_POINTER_WIDTH / 8) +static const char end[] = "END"; + +static size_t unity_size_round_up(size_t size) +{ + size_t rounded_size; + + rounded_size = ((size + UNITY_MALLOC_ALIGNMENT - 1) / UNITY_MALLOC_ALIGNMENT) * UNITY_MALLOC_ALIGNMENT; + + return rounded_size; +} + +void* unity_malloc(size_t size) +{ + char* mem; + Guard* guard; + size_t total_size; + + total_size = sizeof(Guard) + unity_size_round_up(size + sizeof(end)); + + if (malloc_fail_countdown != MALLOC_DONT_FAIL) + { + if (malloc_fail_countdown == 0) + return NULL; + malloc_fail_countdown--; + } + + if (size == 0) return NULL; +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES) + { + guard = NULL; + } + else + { + /* We know we can get away with this cast because we aligned memory already */ + guard = (Guard*)(void*)(&unity_heap[heap_index]); + heap_index += total_size; + } +#else + guard = (Guard*)UNITY_MALLOC(total_size); +#endif + if (guard == NULL) return NULL; + malloc_count++; + guard->size = size; + guard->guard_space = 0; + mem = (char*)&(guard[1]); + memcpy(&mem[size], end, sizeof(end)); + + return (void*)mem; +} + +static int isOverrun(void* mem) +{ + Guard* guard = (Guard*)mem; + char* memAsChar = (char*)mem; + guard--; + + return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0; +} + +static void release_memory(void* mem) +{ + Guard* guard = (Guard*)mem; + guard--; + + malloc_count--; +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + { + size_t block_size; + + block_size = unity_size_round_up(guard->size + sizeof(end)); + + if (mem == unity_heap + heap_index - block_size) + { + heap_index -= (sizeof(Guard) + block_size); + } + } +#else + UNITY_FREE(guard); +#endif +} + +void unity_free(void* mem) +{ + int overrun; + + if (mem == NULL) + { + return; + } + + overrun = isOverrun(mem); + release_memory(mem); + if (overrun) + { + UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()"); + } +} + +void* unity_calloc(size_t num, size_t size) +{ + void* mem = unity_malloc(num * size); + if (mem == NULL) return NULL; + memset(mem, 0, num * size); + return mem; +} + +void* unity_realloc(void* oldMem, size_t size) +{ + Guard* guard = (Guard*)oldMem; + void* newMem; + + if (oldMem == NULL) return unity_malloc(size); + + guard--; + if (isOverrun(oldMem)) + { + release_memory(oldMem); + UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()"); + } + + if (size == 0) + { + release_memory(oldMem); + return NULL; + } + + if (guard->size >= size) return oldMem; + +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */ + { + size_t old_total_size = unity_size_round_up(guard->size + sizeof(end)); + + if ((oldMem == unity_heap + heap_index - old_total_size) && + ((heap_index - old_total_size + unity_size_round_up(size + sizeof(end))) <= UNITY_INTERNAL_HEAP_SIZE_BYTES)) + { + release_memory(oldMem); /* Not thread-safe, like unity_heap generally */ + return unity_malloc(size); /* No memcpy since data is in place */ + } + } +#endif + newMem = unity_malloc(size); + if (newMem == NULL) return NULL; /* Do not release old memory */ + memcpy(newMem, oldMem, guard->size); + release_memory(oldMem); + return newMem; +} diff --git a/test_mini/main.c b/test_mini/main.c new file mode 100644 index 0000000..88a5127 --- /dev/null +++ b/test_mini/main.c @@ -0,0 +1,12 @@ + +#include "lexer.h" +#include "parse/parse.h" + +int main(void) +{ + int i = -1; + + lexer("echo \'bonjour\' \"ssss\'"); + exit(0); + return (0); +} diff --git a/test_mini/parse/parse.c b/test_mini/parse/parse.c new file mode 100644 index 0000000..4f2be38 --- /dev/null +++ b/test_mini/parse/parse.c @@ -0,0 +1,25 @@ + +#include "parse.h" +#include <stdio.h> + + +t_return *parse(t_return *nw, char **input) +{ + int i; + + i = 0; + verif_part(input, ';'); + //printf("%s\n","salut"); + return (nw); +} + +t_return *parse_nw(char **input) +{ + t_return *nw; + + if (!(nw = malloc(sizeof(t_ast)))) + exit(0); + nw->rest = input; + parse(nw, input); + return (nw); +} diff --git a/test_mini/parse/parse.h b/test_mini/parse/parse.h new file mode 100644 index 0000000..b5fe817 --- /dev/null +++ b/test_mini/parse/parse.h @@ -0,0 +1,89 @@ + + +# include <stdlib.h> +# include <stdlib.h> +# include <stdbool.h> + + +typedef enum e_sep +{ + SEP_END, + SEP_PIPE, + SEP_AND, + SEP_OR, +} t_sep; + +struct s_ast; + +/* +** \brief Line struct +** \param left AST to the left of separator +** \param right AST to the right of separator +** \param sep Type of separator +*/ + +typedef struct s_line +{ + struct s_ast *left; + struct s_ast *right; + struct s_ast *parent; + t_sep sep; +} t_line; + +/* +** \brief Command struct +** \param argv Array of string, +** all arguments beginning with executable name +** \param in STDIN redirection filename +** \param out STDOUT redirection filename +** \param is_append True if out redirection is append to file +*/ + +typedef struct s_cmd +{ + char *str; + char *in; + char *out; + bool is_append; +} t_cmd; + +/* +** \brief AST node tag (type) +** \param TAG_CMD Command AST node +** \param TAG_LINE Line AST node +*/ + +typedef enum e_ast_tag +{ + TAG_CMD, + TAG_LINE, +} t_ast_tag; + +/* +** \brief AST node struct +** \param tag Node tag +** \param cmd Command struct +** \param line Line struct +*/ + +typedef struct s_ast +{ + t_ast_tag tag; + union + { + t_line line; + t_cmd cmd; + } ; +} t_ast; + +typedef struct s_return +{ + t_ast *result; + char **rest; +} t_return; + +t_return *parse_nw(char **input); +t_return *parse(t_return *nw, char **input); + +/* utils*/ +int verif_part(char **input, char chr); diff --git a/test_mini/parse/utils_parse.c b/test_mini/parse/utils_parse.c new file mode 100644 index 0000000..c469810 --- /dev/null +++ b/test_mini/parse/utils_parse.c @@ -0,0 +1,35 @@ + + +#include <stdio.h> + +static int pass_parenthese(char **input, int i, int j) +{ + while(input[i][j++]) + if (input[i][j] == ')') + return (i); + return (i); +} + +int verif_part(char **input, char chr) +{ + int i; + int j; + + i = 0; + while (input[i]) + { + + j = 0; + while (input[i][j]) + { + if (input[i][j] == '(') + pass_parenthese(input, i, j); + if (input[i][j] == chr) + return (i); + j++; + } + + i++; + } + return (0); +} diff --git a/test_mini/speudo_code b/test_mini/speudo_code new file mode 100644 index 0000000..c6ad4c1 --- /dev/null +++ b/test_mini/speudo_code @@ -0,0 +1,52 @@ + + +is_space + +t_lex *lexer(char *input) +{ + char **out; + int j; + int i; + + i = 0; + j = 0; + if (!input) + return (0); + i = lexer_count_nb_element(input); + if (!(out = malloc(sizeof(char *) * i + 1))) + return (0); + out[i + 1] = NULL; + out = lexer_malloc_len_elem(input,i, out); + return(out); + +} + + +t_ftlst *lexer(char *input) +{ + int i; + int j; + char *temp; + enum e_token_tag token; + + i = -1; + j = 0; + if (!input) + return (0); + while(input[++i]) + { + if(lexer_sep(input[i])) + { + printf("%d\n", i - j); + token = ret_token_sep(input, i); + temp = malloc(sizeof(char) * i - j + 1); + ft_strlcpy(temp, &input[j], i - j); + j = i; + printf("%s\n", &input[i]); + } + + } + printf("%s\n", temp); + free(temp); + return (0); +} |