From 7592daf50fd3abd524c670a60fefc6aca6ed18e4 Mon Sep 17 00:00:00 2001 From: poppni99154 Date: Wed, 10 Dec 2025 21:08:51 +0100 Subject: [PATCH] Test --- .../NeuronalesNetz_Aufgabenstellung.pdf | Bin 0 -> 64661 bytes NeuronalesNetz | 1 + doblespiel/.idea/.gitignore | 8 + doblespiel/.idea/doblespiel.iml | 2 + doblespiel/.idea/editor.xml | 580 ++++ doblespiel/.idea/misc.xml | 6 + doblespiel/.idea/modules.xml | 8 + doblespiel/.idea/vcs.xml | 6 + doblespiel/Spiel_Aufgabenstellung.pdf | Bin 0 -> 50274 bytes doblespiel/bintree.c | 36 + doblespiel/bintree.h | 27 + doblespiel/doble_initial.exe | Bin 0 -> 66659 bytes doblespiel/highscore.c | 134 + doblespiel/highscore.h | 25 + doblespiel/highscores.txt | 2 + doblespiel/linux/libdoble_complete.a | Bin 0 -> 20738 bytes doblespiel/macos-arm64/libdoble_complete.a | Bin 0 -> 15680 bytes doblespiel/macos-x86_64/libdoble_complete.a | Bin 0 -> 15424 bytes doblespiel/main.c | 90 + doblespiel/makefile | 49 + doblespiel/makefile_linux.variables | 2 + doblespiel/makefile_mac.variables | 3 + doblespiel/makefile_windows.variables | 2 + doblespiel/numbers.c | 26 + doblespiel/numbers.h | 12 + doblespiel/stack.c | 57 + doblespiel/stack.h | 30 + doblespiel/timer.c | 55 + doblespiel/timer.h | 13 + doblespiel/unity/LICENSE.txt | 21 + doblespiel/unity/unity.c | 2622 +++++++++++++++++ doblespiel/unity/unity.h | 698 +++++ doblespiel/unity/unity_internals.h | 1271 ++++++++ doblespiel/windows/libdoble_complete.a | Bin 0 -> 14140 bytes info2Praktikum-Wortsalat | 1 + 35 files changed, 5787 insertions(+) create mode 100644 Aufgabenstellungen/NeuronalesNetz_Aufgabenstellung.pdf create mode 160000 NeuronalesNetz create mode 100644 doblespiel/.idea/.gitignore create mode 100644 doblespiel/.idea/doblespiel.iml create mode 100644 doblespiel/.idea/editor.xml create mode 100644 doblespiel/.idea/misc.xml create mode 100644 doblespiel/.idea/modules.xml create mode 100644 doblespiel/.idea/vcs.xml create mode 100644 doblespiel/Spiel_Aufgabenstellung.pdf create mode 100644 doblespiel/bintree.c create mode 100644 doblespiel/bintree.h create mode 100644 doblespiel/doble_initial.exe create mode 100644 doblespiel/highscore.c create mode 100644 doblespiel/highscore.h create mode 100644 doblespiel/highscores.txt create mode 100644 doblespiel/linux/libdoble_complete.a create mode 100644 doblespiel/macos-arm64/libdoble_complete.a create mode 100644 doblespiel/macos-x86_64/libdoble_complete.a create mode 100644 doblespiel/main.c create mode 100644 doblespiel/makefile create mode 100644 doblespiel/makefile_linux.variables create mode 100644 doblespiel/makefile_mac.variables create mode 100644 doblespiel/makefile_windows.variables create mode 100644 doblespiel/numbers.c create mode 100644 doblespiel/numbers.h create mode 100644 doblespiel/stack.c create mode 100644 doblespiel/stack.h create mode 100644 doblespiel/timer.c create mode 100644 doblespiel/timer.h create mode 100644 doblespiel/unity/LICENSE.txt create mode 100644 doblespiel/unity/unity.c create mode 100644 doblespiel/unity/unity.h create mode 100644 doblespiel/unity/unity_internals.h create mode 100644 doblespiel/windows/libdoble_complete.a create mode 160000 info2Praktikum-Wortsalat diff --git a/Aufgabenstellungen/NeuronalesNetz_Aufgabenstellung.pdf b/Aufgabenstellungen/NeuronalesNetz_Aufgabenstellung.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b4c6ce546ac738d0aab89b1d7cac75941e645a4f GIT binary patch literal 64661 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 LBcr6U6z2Z`B%8Q2 literal 0 HcmV?d00001 diff --git a/NeuronalesNetz b/NeuronalesNetz new file mode 160000 index 0000000..3caafac --- /dev/null +++ b/NeuronalesNetz @@ -0,0 +1 @@ +Subproject commit 3caafaca8cace298d106815f80f8ff1575a51226 diff --git a/doblespiel/.idea/.gitignore b/doblespiel/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/doblespiel/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/doblespiel/.idea/doblespiel.iml b/doblespiel/.idea/doblespiel.iml new file mode 100644 index 0000000..4c94235 --- /dev/null +++ b/doblespiel/.idea/doblespiel.iml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/doblespiel/.idea/editor.xml b/doblespiel/.idea/editor.xml new file mode 100644 index 0000000..1f0ef49 --- /dev/null +++ b/doblespiel/.idea/editor.xml @@ -0,0 +1,580 @@ + + + + + \ No newline at end of file diff --git a/doblespiel/.idea/misc.xml b/doblespiel/.idea/misc.xml new file mode 100644 index 0000000..369389b --- /dev/null +++ b/doblespiel/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/doblespiel/.idea/modules.xml b/doblespiel/.idea/modules.xml new file mode 100644 index 0000000..f6d71ac --- /dev/null +++ b/doblespiel/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/doblespiel/.idea/vcs.xml b/doblespiel/.idea/vcs.xml new file mode 100644 index 0000000..6c0b863 --- /dev/null +++ b/doblespiel/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/doblespiel/Spiel_Aufgabenstellung.pdf b/doblespiel/Spiel_Aufgabenstellung.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6894f3f207c69deb4b9056c800f1593606bcf316 GIT binary patch literal 50274 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 z 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
}%_&+pS%ahpaAb!UV#hNv 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 +#include "stack.h" +#include "bintree.h" + +//TODO: binären Suchbaum implementieren +/* * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv), + * `clearTree`: gibt den gesamten Baum frei (rekursiv), + * `treeSize`: zählt die Knoten im Baum (rekursiv), + * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */ + +// Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates +// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added). +TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate) +{ + +} + +// Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction. +// Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element, +// push the top node and push all its left nodes. +void *nextTreeData(TreeNode *root) +{ + +} + +// Releases all memory resources (including data copies). +void clearTree(TreeNode *root) +{ + +} + +// Returns the number of entries in the tree given by root. +unsigned int treeSize(const TreeNode *root) +{ + +} \ No newline at end of file diff --git a/doblespiel/bintree.h b/doblespiel/bintree.h new file mode 100644 index 0000000..25e16b2 --- /dev/null +++ b/doblespiel/bintree.h @@ -0,0 +1,27 @@ +#ifndef BINTREE_H +#define BINTREE_H + +#include + +typedef int (*CompareFctType)(const void *arg1, const void *arg2); + +typedef struct node +{ + void *data; + struct node *left; + struct node *right; +} TreeNode; + +// Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates +// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added). +TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate); +// Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction. +// Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element, +// push the top node and push all its left nodes. +void *nextTreeData(TreeNode *root); +// Releases all memory resources (including data copies). +void clearTree(TreeNode *root); +// Returns the number of entries in the tree given by root. +unsigned int treeSize(const TreeNode *root); + +#endif \ No newline at end of file diff --git a/doblespiel/doble_initial.exe b/doblespiel/doble_initial.exe new file mode 100644 index 0000000000000000000000000000000000000000..1d28fc0793da637626c2b43d01e63f1616d64e16 GIT binary patch literal 66659 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

(lI@XU39sNea5 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 literal 0 HcmV?d00001 diff --git a/doblespiel/highscore.c b/doblespiel/highscore.c new file mode 100644 index 0000000..fe8a458 --- /dev/null +++ b/doblespiel/highscore.c @@ -0,0 +1,134 @@ +#include +#include +#include +#include "highscore.h" +#include "bintree.h" + +#define MAX_LINE_LEN 100 +#define MAX_PLAYER_NAME_LEN 20 + +typedef struct +{ + char name[MAX_PLAYER_NAME_LEN]; + int score; +} HighscoreEntry; + +static TreeNode *highscoreTree = NULL; + +// Compare two highscore entries by score (descending), then by name (ascending). +static int compareHighscoreEntries(const void *arg1, const void *arg2) +{ + const HighscoreEntry *entry1 = (const HighscoreEntry *)arg1; + const HighscoreEntry *entry2 = (const HighscoreEntry *)arg2; + + int result = entry2->score - entry1->score; + + if(result == 0) + result = strcmp(entry1->name, entry2->name); + + return result; +} + +// Create a new highscore entry from name and score. +static HighscoreEntry createHighscoreEntry(const char *name, int score) +{ + HighscoreEntry entry = {"", score}; + + if(name != NULL) + { + strncpy(entry.name, name, MAX_PLAYER_NAME_LEN); + entry.name[MAX_PLAYER_NAME_LEN-1] = '\0'; + } + + return entry; +} + +// Calculate score based on time used and number of shown numbers. +static int calculateScore(double timeInSeconds, unsigned int len) +{ + return (1000.0 - timeInSeconds) * len; +} + +// Load highscores from file into memory. +void loadHighscores(const char *path) +{ + FILE *file = fopen(path, "r"); + + if(file != NULL) + { + char buffer[MAX_LINE_LEN+1]; + + while(fgets(buffer, MAX_LINE_LEN+1, file) != NULL) + { + char *name = strtok(buffer, ";\n"); + char *scoreStr = strtok(NULL, ";\n"); + + if(name != NULL && scoreStr != NULL) + { + HighscoreEntry entry = createHighscoreEntry(name, strtol(scoreStr, NULL, 10)); + highscoreTree = addToTree(highscoreTree, &entry, sizeof(entry), compareHighscoreEntries, NULL); + } + } + + fclose(file); + } +} + +// Add a new highscore entry and return the calculated score. +int addHighscore(const char *name, double timeInSeconds, unsigned int len) +{ + HighscoreEntry entry = createHighscoreEntry(name, calculateScore(timeInSeconds, len)); + highscoreTree = addToTree(highscoreTree, &entry, sizeof(entry), compareHighscoreEntries, NULL); + + return entry.score; +} + +// Print highscores (up to NUMBER_OF_SHOWN_HIGHSCORES) in a formatted table. +void showHighscores() +{ + const char *blanks = " "; + const char *stripes = "------------------------------------------------------------------------------------------------------------------------"; + const char *header = "H I G H S C O R E S"; + const int lineWidth = MAX_PLAYER_NAME_LEN + MAX_PLAYER_NAME_LEN + 5; + + int blankSpace = (int)(lineWidth - strlen(header)) / 2; + + HighscoreEntry *entry = nextTreeData(highscoreTree); + + printf("+%*.*s+\n", lineWidth, lineWidth, stripes); + printf("|%*.*s%s%*.*s|\n", blankSpace, blankSpace, blanks, header, blankSpace, blankSpace, blanks); + printf("+%*.*s+\n", lineWidth, lineWidth, stripes); + + for(int i = 0; i < NUMBER_OF_SHOWN_HIGHSCORES && entry != NULL; i++) + { + printf("| %-*s | %*d |\n", MAX_PLAYER_NAME_LEN, entry->name, MAX_PLAYER_NAME_LEN, entry->score); + printf("+%*.*s+\n", lineWidth, lineWidth, stripes); + entry = nextTreeData(NULL); + } +} + +// Save highscores to file (up to NUMBER_OF_SHOWN_HIGHSCORES). +void saveHighscores(const char *path) +{ + FILE *file = fopen(path, "w"); + + if(file != NULL) + { + HighscoreEntry *entry = nextTreeData(highscoreTree); + + for(int i = 0; i < NUMBER_OF_SHOWN_HIGHSCORES && entry != NULL; i++) + { + fprintf(file, "%s;%d\n", entry->name, entry->score); + entry = nextTreeData(NULL); + } + + fclose(file); + } +} + +// Free all memory used for highscores. +void clearHighscores() +{ + clearTree(highscoreTree); + highscoreTree = NULL; +} \ No newline at end of file diff --git a/doblespiel/highscore.h b/doblespiel/highscore.h new file mode 100644 index 0000000..7774ae7 --- /dev/null +++ b/doblespiel/highscore.h @@ -0,0 +1,25 @@ +#ifndef HIGHSCORE_H +#define HIGHSCORE_H + +#define NUMBER_OF_SHOWN_HIGHSCORES 10 + +// When called, loads highscores from disk into static module variable. One highscore entry should consist of a player +// name and the achieved score. +void loadHighscores(const char *path); + +// Adds current player name, time and number of shown numbers as a highscore entry. Returns the achieved score. +int addHighscore(const char *name, double timeInSeconds, unsigned int len); + +// Show currently available highscores, but only up to NUMBER_OF_SHOWN_HIGHSCORES. +void showHighscores(); + +// Save currently available highscores to disk, but only up to NUMBER_OF_SHOWN_HIGHSCORES. One line should start with +// the player name and end with the score. Both values are separated by a semicolon (;). The scores should be organized +// in descending order, starting in the first line with the highest score and ending in the last line with the lowest +// score. +void saveHighscores(const char *path); + +// Release all memory used to organize the highscores. +void clearHighscores(); + +#endif diff --git a/doblespiel/highscores.txt b/doblespiel/highscores.txt new file mode 100644 index 0000000..35890fa --- /dev/null +++ b/doblespiel/highscores.txt @@ -0,0 +1,2 @@ +player_name;4960 +player1;3999 diff --git a/doblespiel/linux/libdoble_complete.a b/doblespiel/linux/libdoble_complete.a new file mode 100644 index 0000000000000000000000000000000000000000..5acef16de6be097609dc487ec16cf7d94e07e8bc GIT binary patch literal 20738 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 OUNBnQm)ukP|GxnfV<5Hw literal 0 HcmV?d00001 diff --git a/doblespiel/macos-arm64/libdoble_complete.a b/doblespiel/macos-arm64/libdoble_complete.a new file mode 100644 index 0000000000000000000000000000000000000000..82caf26e6c7b65f4670feae592f36eed25820736 GIT binary patch literal 15680 zcmc&*e{fXSb-v3QSP2MVl4+FI(}Ns0Bw@Bvp+GwMMf(Ox&c@cYrMaA3|>ilFvdQ%P$rD9+3HdC|Cfp z{6V0zQmKsKav;lvf#h=)80|>LW9hxwSjQn1?d$EsPk*LcMYDX3b$0IS-ItEXC7XFo z#gAtBwlkKEAtT=QCZ1)MbUc=gKi=Q-bUd9=(Sz~q&i=k+q63jCn#sn}*?ozgc$)9M zee#ML+7bu5GabEYTSpGH?X_q_$DyWPa8c@C{^u9J!8o8d&Ce~sZc+{&gxm2H z^;`9y#yKW_Kyy&a(ij%SN0L=Ennia{^N2?G?b^R@nznD250PcR?^lX4;U`D1AsX%I z?dgkkWTXA5BZ*XJG#b(K)uvlMLlUtBeDJ5COint#Q19{ zR|6b?Fm1pEcy{AqAYVR|)7@r}HyozUsdp!j&l#RPsZI@@tiLwCKur`DgeSn@bYZ@l zD9#U01bpg~;_{bQ0=GlXy8OxLwabWaoNLnaD989A#7`do!Z3KA8uLegI(3q~eZ!Nj z>J)jYIl1>VUq8zEEBUgn%ZP9Ene=+_C*K0%CXYWf41QJlvRsiofnHg4++3uie)3`c znkVv>@oZJ^QpPC{pYzJJ+3+^?Sed5Ku4?UMx?2{@qkuYXzh0Y~TJEkN@j5(dfJ0gq zBwp<|u@&jBN^Y6j73t^~9UkEClG5j4BJsOZ(s!Deit>F(M`Vy|9_CuG4;TQ-+zsYH zBg?#Y!LXns2+-*v;Af;R#;q0Fwr@LWO#T7M!}-1#?^eEfLfiIoO=h|cd?jt$dk1J& zvfAjOWu?|DciB>|SMe^hcAJH{w-ZZjPb``2?NG^VPv0i}+iYr{Y5$vPUEI8Nn{0sX zwNEEf+y!K1H2kWqk0We|W74@kwzwN+qD#L^WU;v*c>+S)^^xla!;P+wJ7q?YAJ?V= z27)qFu8&V=xL?{3jqZGC-$RzdxQHB>JEdS{VT89yv#qynBG;I3b08P_<jcPHEVH|{Y?2~-$DPn`>t_r zS>Ne2?m4;V2)^-GT1oE z%sQFh<{bjxJm!OLE85>S$FxE7gp4+yZ8K@+_hBw*zS0+l2lh?K$T|v`Uz5jOdV=M7-aRJZ@hi+R-4@9IsePAz zvtvW~-FvoIzromzl83Fs_L=63Iv^wK;5W1Y`iRb}P~XRu@uPvcYAN&RK0_IIy=Z?a zv?Bw8tb(OzCGo0YqAJqEvMRnaLpt?VhMDw{q@=g&T$S~|E$K&RNFPBu^#36BY~oJf zV&F%R3xAPI_(4?gg3#{^z72$i96T@dn8DC@flClSB=Ijv{ArYwiP zoQK9*UzXnHp)p2f>Be4;#JjSOL%)KFstsqYjzyzA@t%&pW6_Ro*w${Vxk+1+9^2cP z-6d;UR5x1Z#_V<*1WmNy4kS~9t7%EMg3O& z=Yo9E12PzvrcS~~hWCc`yA~HemTiZkb1SR9N&DCG8Dd$4G0bC3PjwaiWJ+7nboy-e z?+P@A`dDKCynt?fjQseJA=^xy>}G>|4IesJKSKL2e=a(LHTp33_@eB4j4Sv9Xa7)D zw_!03dXHC<4mnO2uveWyIqy4$OzSXAcdzRex?wBi!M-`Q-0TCz<>ArcR?1d$sJQ** zmFI6Ubv8nWDlSu_$gB5@;xf_kux}5D{FH%Z+mN^Bxtdjhz*{Q=L=`y1y=HuiI)y!Y zl>74^p$!y!#_xR~Nhix9{ zMTY-^@F?+~3D(#&@+uV9uca0gpydG0C z-_8f7<1S;q4RAg^SM#DC1L{0({bIh!OZ|lU9Qn-o)${*q^-9JwZXA5vV@h6n&WL^i zo@Mi@hJEbEI9S`lHJ_ksnSS$QjOLhrqfF4{M==J61OJ{FpdSd~)?Kt~H>*SE9q<`U^@`ES*Nzk`2 zcknIeMF!pWdNqpuoqn3>Jou(;o`A~TT0|av2X#|G%2B8fk6IrTWYggV0~Pv}#H$Zx zNbd$ihN}iD%I}v|vfbpXNT>e9kmHY2TJA~d@DkFg*ZdNEsJC1NA}T`t3K*hZg*7vn z2U5>j2&7(h0`(F11F83{0|tPrfh@nmU^YsByG}sA5Qjq!q^*H*WsE=(0!hdo055!&`A>d@)7{~i|F_Q&6ohCp^7qCd&44^d9iwtv3_nmldzI$qrLu!rWE zgggDHhd$$>>7R1v=ZEa3PkZRJhgQ)}dkC;6mg?;7*#%$GF%>H32Owdm2^z`9Exo%Z{)R4s~12`MkS5^HflZGfNYJSBd7VW6&8N2!Og67hB z0R>54=e!_*aaIl<1nNrz?vB;5(?4NJYh)ROW}&G!@Ub7*jrzkbkqH9%k>!4T9Qcl^ z=u62&HlB_pTbM|HTlx6|zas{GV>(dJ$6qN}xoku#QiZ2H`Jl*4+U_M>6Dfo^>cDx&tUksT_Zuk)h~b?`4ux^*er3AwK}J!Ib< z^WvQ@O5)XDpx1X7&3b9?+WbwV(P}$SA!FHkPr10>J3s~; z^HPrKU`|$NJYemBxBn2&V)d#>xBr$Z)?u=B_amF4&ER^ocH-9U+e+(Qw>`;qS&G%p z0k~(|265f9Yua?9rr*BJ4na82G6;i0+jUP54B~He-D{QtiPS;K;ax{tM6Qq>TrM)MAk8nu%(jl&ezNkhpj$p$jb+Gn zG?mF(vSOX@XNMzjJ~D)6F;-_=mj{KPoy_~ekMdoBvL`Z^HF>smc?Fcd4Jbc?5BME4 z&b=;w7V&&&Yp=os{qCm2)JZ?iJr?0C*nbN0VZG%#2>S%*8HKf2FV}`AP;F_wF4RM> zua~uwcC6Ss$WwO_@r7^rPMukp+XF#PgP%E{o+tJY(k!p>W$;xa&-gNwS;cp;-t&(w|hvjyxEw6Th7eR>bk^2_6+8mJpLHY#QhcL z9<&=TV=vR^OR%#IAMAs^v5@1-g#t@qyDo(-3fr*pwsM=a&E;#SO?eV$_80yBvszxX zss1tbIm%aNi@Ekxd!|J@m+hwipJx!-M!OBR7TUZXsBJRX*7PS}KRjG?*@*NXjHB;Z zXF>b`h=cv-J~!Yw+FZ;hU*&wl*cO(l$#K|i98W!V%fgei-^deZ40_D+upznU>o~Mc zj}>I~jun=+_jLOy6UK}ER$QgDA7r*MDy*X1yD(02J_X&PFkemL86BS=o@9B{H>p}; zYc9?Y|L~!(v*u3d4Jr_W>2q{V>5f6`9JDt8-DZxoSDoUwW5+g+^P1B8$u-yVb8~z0 zt!qYxPCj*wvV(rFi0=%2{oy0faRQ6p!kN|@JvZ21=DC7zaOmV6`rHTh|EUdV>jvm0 zjWxQD29XD6ma7dv|5GFXjd_*_ehmB`#`_i2MfyXDzd}Sjd2Ix*Ch!V^*S(9>#63&F z`!?{teVX^Q3{TD^!|69#@6bM{eCvUczT-1e9 zwn2Y)GViEkQ}1>ALcv3+@HfI~b$_kG?XllVP{H3)P;Jg5&hI*H&R(b0dBWM_>~i+1 zdm1)0ZOGhHt4`>bhKz<2pq+-`hKvK)(CL6aq8c*yH+0UTVdx&V=Y(E$%f_n{CR;`N z2N+-m(ReD-cZ>EhVzO1F2Sk}_VS1JONMT8*E`m@|-rjGys*@|zwIPYL<{8o*=!;+) zSpkGi5Udk=p~28cP<9-|zYSamd=t19I0jsba<3Za{b0z?-?UNsncMbde0i+mxT*Menm00`AK*bXGW zCk-Ch3j7_!k6}LGPFFAo#85@(uLOp611U!fkma@-JkSW_IIaLvo+Uuavk*vmur3lq zO47M_QJ#;0l;?fmdf*GdM&JoS&U=Uy=`*P9q|FMVW#_z80 z9Z&inc<4X#(BJpayoccCXRouDZkLPSx(lupUPSj?Jl9t*OL?o@RQKLw7l(GK2-zoa ze;^sfGiQ}*q9)4X7@ddfLrcmxzQS)U5m}=mDSber99vM1!RNVgLw2g1k=mqq#t7*{{O;v z>Wy>tu-EHHcqh0KHhTWt8p=EpsFD5?-wf@i0Bt8c_I{=9Pw+3_kP6ntV+8*z68{tPWU{1t&ksPAsMYk@WttsTj!VkUMlzQbwAI1ltCW5?oYCl%|7f4)|gc7;q+ z7XPaBkjC?di!n zoxOd1@nqI{rZ~i+T5A~-yvxj8jpmQV^Psf>lFn%PS ziKkG`9XLS{JgcMmK$wu{PnC4LC%lgiua?gH4a=}}^L_*FFa~*l6m~$c09*llA9y?P z9U$$Sw+)8!5>GpXcFvH&P!4!2^6vw}_Z{2`q}}iU5Nld#n`BSQv5gFxJ!3{p?V78DsU80rIJO-?2a9^icpwgdB8 z+b_JALHp$viB~{$ZsdPWCxym<%>OzN`$mL%CNR_q#KNTSYtU}m2O6S9b{hd5)pAHcy)NmfIeA3hA^5?7nyp(?Ktm&5LrAzE$W&La!2Fp5dyOd*u+gxcoe%Bo0TPF8yRC*2R-}}EO2Zqm`u!Sy;@nSWl8J@ zHcUhXYZEQoEzSf=8ffZHhnCDVGfqreL-~-gi%iA|b|F;Bc-n334BFt#2v;3M>W2P) z_ny0Y`ytD2|Hz$v@4WMI&pr3!-Fxo2Z?C&89E)_^UUPlJ;wAO=L~6KY`OP;sHr%pe zg>5gZZvaEH8|v$qFI{TeOP4f?aBEE{RJY;&<|gMZd&9l!H#$ug(q3GT;__c-S=Rs# zUTj%^DmZ{OT4h-`2>nZ>UujwQ3;YS-rX`m3m&B3(7lMPN^jrqW{8tG4J|N{@6PN>J z{;h!S=PWBO@H2qS7X+j|qky4ES2P^kkO)V%S)tyZUfh!L4l9)4W4NttW6#D|G%8~H zu{*jm!KbEhA`C%1ZRmW2BC%*V5xpn5eM>YJw?bQ^iKb+4S7!u7D-=(JV~LHO+oLf) z_w>pmN^m>3cElq+F;hqZhmNkE@B|-tJp549%a3>T?C|29-Mz_#w!jK)4|jGW3q*`f zs4x1tVaY@{+l79qd>O&ce0^K^&kp+4I3ZQKZP>nAWN6pHk0 z?+r&1p=9@t&hEBQXl;|>5e7xiULnqfA++THl+DmIv0NjeP_!e|9t&@e8ob!PoaoDG zwsk=C32I$xSsmt?kYjuKn0qyJi#3G>^L(kkW3oh7R#@H+9(F ze5k$7ckM1!oapmY-y43AjIvQE8-+5yl%j0ZO;gvXI~1&DX7!vp?4L}ZDlZNBRNpu> z&Cyw4Mz9*z0vgk`UDUHj*~7XGIeh&s$;)O`>N2b-YVC|}KIFSLXnE}y*(;T7-?*vC zc>d(4pMHvpqX4Q@=`IbV_k{>x`f4)%UJ<=r!?OH2;omd~-!C~9Pr_&4F;zXX-m2Q^ zukv4ZarGYLnFku@Y3p~W3zFDpS*tJiKQZmjSu@E)qFfWM1?M5x1-W%1C-teQ?`g<& zh@8}`qTH*H>lHbvUzyxZs0+q@;231_iUhU*!u9|M2U4IPH;Bw^6&Ms~3j|R7>j5u^ zpy@9T5Fc>UzHATTdjXj^jES4XN8&jl)B<|g7VY=qvf`)}sAx%2t5LgNgY*K^(}tyD zd$_BsC!*%_%Io$d^ZAlxjk3(Q)@jOoGYr44)pwXEY z$mG*6xS7|dYxa51>;HiHl8O45_eChWnuM}>eM_9{yh))@)9Q_@4Q5%!4mGg|SyU^m zv`SO06P(AH2Gt$?jCzu^2?fZzA}yc=rdlUjd@kVv(j_@OVK<=EeHLI+1R{TF{(Zn|6lvJh^)j6mkxBGs%&{TnXMV=IR>7bB2dh zq4{?;n$rux3gj65^jO+?FV**+<@>XM=3+wMiS>bN63WV;tc)`}631larVr}1z^%@w zAgr=wJ=y$a*={S!=FhKT8QM0VE)KS_FY*gCTDkQ9!gS;<9kN!wa8pL54%cr!q}LtK zy7~qebJHqjVSNTP^bxP+dD$x}k znsF8d5_dC-OjD!{)HESvA*qF(F2ah592KNt8%9L0znDdu_F34T+9_#ouk4p7KSz5b zf2fLrdw^kP%m6}d%BdL5zsrF$;ZT&chw^iz{+!~KB!=zC36m|e(?9Y~0cq5QWQ;eV zoQP7tW5^kUD%0&nYJUbz7dc~TXG}`+kGxqRWt_3pU=?_HC~;4$#d@A8o%XDHp&Vg} zB}Oc&?vPu?mS z3ULDXS!z)&^Czc>6NsL@G!AL5_* zOno(C7l4)gKfVgImCo3OCbKV2_nkFc=~UlYxFUB$Q^q-)9(tWUHA1~=N3GY_1wb1H z(?g0bfIea-c~*;ho|PY^)?OV0!17(Tek=boog9M=D*uq9CeMs>YNa#gOZA|*At%T2 zHsqYZ9j;*x9>q#LDfvwE*unp(YWSCrKT5q>m2NpfAIQxnPrO3o-7IEC%UYXta@shA zK=S{D^&mq*1Q;UCr_!?rP?%a~Pvv)mH{nGo$FIacQ2r9^Rr*kDaxC343il%IoX#|# z-dDA5726;h0*$HG&6lbJ4e!=#y;cG>BveBYEyk<=-v161aBfe;P50n0r+M8>GRb($+q_B(`i-5GX+G63xUzX{z&YtlaagKR z!)l&<(m7eE<`+~!&IrWO5N_mcRwL6q;zn9dt(^W%-)`=FP(u)!Pl1Psjv7o8J@qYb zPYDlkBo({zUE5^oxKA3Jmvjx4ubl4*thg9hXK8x=THJ)55;_X` zG|!m|GPr|%))OKk#fqtW@zOw2zouI+YRD3bl35q`YHAt(m{4joEaT^79sKGf`KR); zEb*Vj{xbh$9`vFatxX~)^{6P<1-YEa?ZvZ772;0xvo?wUB=xGOkA7BA;zUxvGPxtD z|0VEC?gpekbQd6gwGFu8RSL`iq#yGfT8@5IP~hhQtAUTA3@jai4*;3(5Fq73fDj36 z07MF`!Hxb^5D=p>umBJvBG3;AxtXm3g92@V0E+*4K>9)bBp~6j$S=A}aMPc+0QdSq zZGxNeK!1`tOiJUyi+`^Kf3yVOS%Uv{3C=i}SKo6bIQ!7c=lJpBR;bM!nye3ZxAkmy z5Tkn73OyL_i6yL1duLZyOLymk$*AU3q*s)OH;?sBb#pUfejl0qG|&DHQ7JOhjYhu0~A>g^JHXOeZT}3nEA0?}*Ez zGElcS74$VMSL9NCeyOJ|nTDavtAi_mH-$pyjt`o4GWIdA*S?}L3f@%lK{G!GsR(J@ z)EASBbd3PbpUOY%6$3i7xYdZtdhNSV|IiOR*j_wGst5G?hb)R04P+Umbq8t6M1SH9 z4mLNtjKU+l;Q*$@AF3A_6K%<;I6c;K1YF=?-FV#Xd^`9BA6&@hVK*}iGq2^|c*K4A zosT!1eBrsnw)=4&g2Qh5xSRg5d+^tHxCcME*sVJ5Rvm%YIpSL|D}^lo>3h@}Y4>e8 z*bc(uAhi3wcF?!rNV{*&;2GbhgJ*pHS@c`a_#VLX6;94gt>Vjq*dvaQEq7>!8CrPc zLPcJl&LMKn;1)*Z0>Z3}_ff#=-&MC-Jy@e}pq1~$&;xX73Dukex(ytaQ_~b7D|$Iv-@Kn30p9hE^(JluGF^*{c?wCNyia-n zAHgZgHlEe1Rp7$+ze{gkj;|q@T5CGYNxo+XT$=cb*!YP|LpjS-Z=`Mf)xkkW`3uU|=7IL&*Oy`&&o@nNd< zVUJme#gG@FkM`v-tBB1-Ri0{n*dqgBlhFs~)mz^ST_0>Lpd6d~5JYgH)4M*ftIWks z8bmHQsr}|-r}rVFn^AqQ>UYz-JIG1BMu7e1FG0*JPPT84 zn|X%h*P|e4@f1G__#rcron3Ya?RME ztRu)M9`wBR3fn;|&-{oyY<{z^?Zkr+^?673M$W0}6AVrX)ZUD2ntn{%gZGI!2SU@JIBJY{)XJ_AnbaInzwg?Iri8Bh0( z!Gh*-dIoFo3ZH?i0d;3w-@+qjeD}k@xM^_WJTT~HXVgJTRVF**dHpyFY7O3AP)86M z2}mR98l?{&P=p(gybNjUFFyW6HLvHKjYqKbpt7re4vAMNoqm6x9-f(GF4KbEXdcJu z=|~e!QJWNww#=^D5Amk-?0IgwXIwO-$DFU?I1Mj0xA4+r7=t?g__(s8sIAz-psI?TLPbs%DuS36D^e7C;`Rmu7Vas} zpq-J7i@Gd(9y6p=!fWfuM8N60>a8{>w3D1i>Qhl|^Ms>05i$xs6^vOcYb@n&{2p#r z;P;d)*Z!it#&+!u_MP^<_Ilf~H&~12FRWV_UsPj#T|LZ?EAVyT_WZ!YxDBwd%?7^1 znjc>|zl~G$l?7?~IkK`PHL{Kb>-&0>C!&RLd! zopR_9@#J%!AS1H2OOr+}FG=cI)GC?N9Jb^v0p6o?3aiSTa( zMBfEICv?By(*%DV%E;dbNWCuz{*2%W!P^DD50Lioe3|7g1H2meb;7?|;H3h8g>j4D zoPWj*FIeF30I?3N@}5J((FvrrT5YG5TG^UVfC3?T3dgs?RUd=n5w z)qX=@pTN5TSzZ8;`Thuy?KuY!zgosjS?+W|sI2`6g^~ViRV>;Y5N=rDDM0Lr15W~? zoH;uMj|1Sjw`nRLZLIh#By_h&^vQb;9i0K0$T+J1=<1uR6gWY@!VEEAk6~g ze%I_@LZGoOW`5!R=yHr9vmg1u@KH&opX1_w*vvO|f}8jMUcmuWx&wF0oB4zBX0^XY zV=z673+zI=28b8`K?#3a3IF2~{_zr=@d&TJ{t|q!1YcaD|Lqb!`_HTI8zuPnN^thS zSKfTaU-+tC;?L~}5%2^2k`M0HrvlYR4{L%r)zC9re zA+@s^&Hn_Yg7?D-o)}R2zlwEovMm4B7;;!NPR+-s`F1T*Ww9z~fJSUquxasQv+}@% zR*}!&1QPa~n+f!09kS|!$6bq(Csx= zVLpx5CGfAN`#PicL!HsCsQuM&2c~;F-qS^}HTp=jb8Euh5skG)yKl9v`=VWu4lQMG z>)F0NVYl`4_C~uB_Cq}}@HaqFM|caew&7`8Pb?PQmJs>QZhL;+@~(D!Lv&lRyDhq) z`$iPd&c|*WcYA))UYG2qd^Gk5tVz_>SZkx5Z7{nto*=usGt!YTYU}LvL_4?IJHpXe zl>DvH9npBS8~F+;s-MuZ#i>`&hcqnXj|!ju9#R>f9mh1;K4o0|b}7HiAD@T3O}K*M zw~HMW<+xAzw#bP+Wpeai@rnh$21tK(10enUwSZ`jz@31Y>jJj{;x~uiO%lIe@GAf@ z^#?veO{)QOfPTRDbI(}HIOcK{J?3@~Iuf12|=^Ko*a9=0d(ARvmEX$u5UcoI(u`hE%P1Yk#IL$ M$>Q%NiX6%R1&uu5!vFvP literal 0 HcmV?d00001 diff --git a/doblespiel/main.c b/doblespiel/main.c new file mode 100644 index 0000000..34163d0 --- /dev/null +++ b/doblespiel/main.c @@ -0,0 +1,90 @@ +#include +#include +#include "numbers.h" +#include "timer.h" +#include "highscore.h" + +// Read an unsigned integer from stdin with prompt (retries until valid). +int inputNumber(const char *promptText) +{ + unsigned int number; + int numberOfInputs = 0; + + while(numberOfInputs != 1) + { + printf("%s", promptText); + numberOfInputs = scanf("%u", &number); + while(getchar() != '\n') {} // clear input buffer + } + + return number; +} + +// Print an array of numbers. +void showNumbers(const unsigned int *numbers, unsigned int len) +{ + if(numbers != NULL) + { + printf("Numbers:"); + + for(int i = 0; i < len; i++) + printf(" %5d", numbers[i]); + + printf("\n"); + } +} + +// Main game loop: generate numbers, ask user for duplicate, measure time, update highscores. +int main(int argc, char *argv[]) +{ + int exitCode = EXIT_FAILURE; + + if(argc != 2) + { + fprintf(stderr, "Usage: %s \n", argv[0]); + exitCode = EXIT_FAILURE; + } + else + { + const char *highscorePath = "highscores.txt"; + const char *playerName = argv[1]; + unsigned int *numbers = NULL; + unsigned int duplicate = 0; + double measuredSeconds; + unsigned int userInput; + unsigned int numberOfElements = 0; + + // ask until valid number of elements (3..1000) + while(numberOfElements < 3 || numberOfElements > 1000) + numberOfElements = inputNumber("Wie viele Zahlen sollen gezeigt werden: "); + + // create numbers and show them + numbers = createNumbers(numberOfElements); + showNumbers(numbers, numberOfElements); + + // measure time while user guesses the duplicate + startTimer(); + userInput = inputNumber("Welche Zahl kommt doppelt vor: "); + measuredSeconds = stopTimer(); + + duplicate = getDuplicate(numbers, numberOfElements); + + // check result and update highscores + if(userInput == duplicate) + { + int score = addHighscore(playerName, measuredSeconds, numberOfElements); + printf("Sie haben die korrekte Zahl in %.6lf Sekunde(n) gefunden und %u Punkte erzielt.\n", measuredSeconds, score); + } + else + printf("Leider ist %u nicht korrekt. Richtig waere %u gewesen.\n", userInput, duplicate); + + loadHighscores(highscorePath); + showHighscores(); + saveHighscores(highscorePath); + clearHighscores(); + + exitCode = EXIT_SUCCESS; + } + + return exitCode; +} \ No newline at end of file diff --git a/doblespiel/makefile b/doblespiel/makefile new file mode 100644 index 0000000..1f15f75 --- /dev/null +++ b/doblespiel/makefile @@ -0,0 +1,49 @@ +CC = gcc +FLAGS = -g -Wall -lm + +ifeq ($(OS),Windows_NT) + include makefile_windows.variables +else + UNAME = $(shell uname) + ifeq ($(UNAME),Linux) + include makefile_linux.variables + else + include makefile_mac.variables + endif +endif + +raylibfolder = ./raylib +unityfolder = ./unity + +# -------------------------- +# Initiales Programm bauen (zum ausprobieren) +# -------------------------- +doble_initial: + $(CC) -o doble_initial $(BINARIES)/libdoble_complete.a + +# -------------------------- +# Selbst implementiertes Programm bauen +# -------------------------- +program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o + +doble : main.o $(program_obj_files) + $(CC) $(FLAGS) $^ -o doble + +$(program_obj_filesobj_files): %.o: %.c + $(CC) -c $(FLAGS) $^ -o $@ + +# -------------------------- +# Unit Tests +# -------------------------- +unitTests: + echo "needs to be implemented" + +# -------------------------- +# Clean +# -------------------------- +clean: +ifeq ($(OS),Windows_NT) + del /f *.o doble +else + rm -f *.o doble +endif \ No newline at end of file diff --git a/doblespiel/makefile_linux.variables b/doblespiel/makefile_linux.variables new file mode 100644 index 0000000..6268874 --- /dev/null +++ b/doblespiel/makefile_linux.variables @@ -0,0 +1,2 @@ +LDFLAGS = -lGL -lX11 -lm +BINARIES = ./linux \ No newline at end of file diff --git a/doblespiel/makefile_mac.variables b/doblespiel/makefile_mac.variables new file mode 100644 index 0000000..1c2b240 --- /dev/null +++ b/doblespiel/makefile_mac.variables @@ -0,0 +1,3 @@ +LDFLAGS = -framework OpenGL -framework CoreFoundation -framework CoreGraphics -framework IOKit -framework Cocoa -framework CoreVideo +ARCH := $(shell uname -m) +BINARIES = ./macos-$(ARCH) \ No newline at end of file diff --git a/doblespiel/makefile_windows.variables b/doblespiel/makefile_windows.variables new file mode 100644 index 0000000..68f36d4 --- /dev/null +++ b/doblespiel/makefile_windows.variables @@ -0,0 +1,2 @@ +LDFLAGS = -lopengl32 -lgdi32 -lwinmm +BINARIES = ./windows \ No newline at end of file diff --git a/doblespiel/numbers.c b/doblespiel/numbers.c new file mode 100644 index 0000000..f59d9a2 --- /dev/null +++ b/doblespiel/numbers.c @@ -0,0 +1,26 @@ +#include +#include +#include +#include +#include "numbers.h" +#include "bintree.h" + +//TODO: getDuplicate und createNumbers implementieren +/* * * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen. + * Sicherstellen, dass beim Befüllen keine Duplikate entstehen. + * Duplizieren eines zufälligen Eintrags im Array. + * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */ + +// Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries. +// Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while +// creating random numbers. +unsigned int *createNumbers(unsigned int len) +{ + +} + +// Returns only the only number in numbers which is present twice. Returns zero on errors. +unsigned int getDuplicate(const unsigned int numbers[], unsigned int len) +{ + +} \ No newline at end of file diff --git a/doblespiel/numbers.h b/doblespiel/numbers.h new file mode 100644 index 0000000..2315581 --- /dev/null +++ b/doblespiel/numbers.h @@ -0,0 +1,12 @@ +#ifndef NUMBERS_H +#define NUMBERS_H + +// Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries. +// Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while +// creating random numbers. +unsigned int *createNumbers(unsigned int len); + +// Returns only the only number in numbers which is present twice. Returns zero on errors. +unsigned int getDuplicate(const unsigned int *numbers, unsigned int len); + +#endif \ No newline at end of file diff --git a/doblespiel/stack.c b/doblespiel/stack.c new file mode 100644 index 0000000..33c3316 --- /dev/null +++ b/doblespiel/stack.c @@ -0,0 +1,57 @@ +#include +#include "stack.h" + +//TODO: grundlegende Stackfunktionen implementieren: +/* * `push`: legt ein Element oben auf den Stack, + * `pop`: entfernt das oberste Element, + * `top`: liefert das oberste Element zurück, + * `clearStack`: gibt den gesamten Speicher frei. */ + +// Pushes data as pointer onto the stack. +StackNode *push(StackNode *stack, void *data) +{ + +StackNode *newNode = malloc(sizeof(StackNode)); +if (newNode == NULL) + { + return stack; + } + +newNode->data = data; +newNode->next = stack; +return newNode; + +} + +// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be +// freed by caller.) //gibt den Kopf des neuen obersten zurück +StackNode *pop(StackNode *stack) + +{ + if(stack ==NULL) //hat stack speicher? + { + return NULL;} + + StackNode *nächsterknoten = stack->next; + +free(stack); +return nächsterknoten;//obersten zurückgeben, war 2. +} + +// Returns the data of the top element. +void *top(StackNode *stack) +{ + if (stack == NULL){return NULL;} +return stack->data; +} + +// Clears stack and releases all memory. +void clearStack(StackNode *stack) +{ +while (stack != NULL) + { + StackNode *next = stack->next; + free(stack); +stack = next; +} +} \ No newline at end of file diff --git a/doblespiel/stack.h b/doblespiel/stack.h new file mode 100644 index 0000000..dd05465 --- /dev/null +++ b/doblespiel/stack.h @@ -0,0 +1,30 @@ +#ifndef STACK_H +#define STACK_H + +/* A stack is a special type of queue which uses the LIFO (last in, first out) principle. +This means that with each new element all other elements are pushed deeper into the stack. +The latest element is taken from the stack. */ + +#include + +//TODO: passenden Datentyp als struct anlegen + +typedef struct StackNode { + void *data; //zeiger auf einen beliebigen Datentyp + struct StackNode* next; + } StackNode; + +// Pushes data as pointer onto the stack. +StackNode *push(StackNode *stack, void *data); + +// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be +// freed by caller.) +StackNode *pop(StackNode *stack); + +// Returns the data of the top element. +void *top(StackNode *stack); + +// Clears stack and releases all memory. +void clearStack(StackNode *stack); + +#endif diff --git a/doblespiel/timer.c b/doblespiel/timer.c new file mode 100644 index 0000000..fd8f6c1 --- /dev/null +++ b/doblespiel/timer.c @@ -0,0 +1,55 @@ +#include "timer.h" + +#if __APPLE__ +#include +static struct timespec start = {0, 0}; + +// Starts the timer. +void startTimer() +{ + clock_gettime(CLOCK_MONOTONIC, &start); +} + +// Returns the time in seconds since startTimer() was called. +double stopTimer() +{ + struct timespec end; + + clock_gettime(CLOCK_MONOTONIC, &end); + + unsigned long long delta_us = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000; + + double measuredSeconds = (double)delta_us / 1000000.; + + if(start.tv_nsec > 0) { + start.tv_nsec = 0; + start.tv_sec = 0; + } + else + measuredSeconds = -1; + + return measuredSeconds; +} +#else +#include +static clock_t startClocks = 0; + +// Starts the timer. +void startTimer() +{ + startClocks = clock(); +} + +// Returns the time in seconds since startTimer() was called. +double stopTimer() +{ + double measuredSeconds = (clock() - (double)startClocks) / CLOCKS_PER_SEC; + + if(startClocks > 0) + startClocks = 0; + else + measuredSeconds = -1; + + return measuredSeconds; +} +#endif \ No newline at end of file diff --git a/doblespiel/timer.h b/doblespiel/timer.h new file mode 100644 index 0000000..180f8ac --- /dev/null +++ b/doblespiel/timer.h @@ -0,0 +1,13 @@ +#ifndef TIMER_H +#define TIMER_H + +// Usage of time.h: clock() returns the number of clock ticks since program start. CLOCKS_PER_SECONDS represents the +// number of clock ticks per second. + +// Starts the timer. +void startTimer(); + +// Returns the time in seconds since startTimer() was called. +double stopTimer(); + +#endif diff --git a/doblespiel/unity/LICENSE.txt b/doblespiel/unity/LICENSE.txt new file mode 100644 index 0000000..3e3aad5 --- /dev/null +++ b/doblespiel/unity/LICENSE.txt @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2007-25 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/doblespiel/unity/unity.c b/doblespiel/unity/unity.c new file mode 100644 index 0000000..3ea455d --- /dev/null +++ b/doblespiel/unity/unity.c @@ -0,0 +1,2622 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" + +#ifndef UNITY_PROGMEM +#define UNITY_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 do { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) +#define UNITY_IGNORE_AND_BAIL do { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) +#define RETURN_IF_FAIL_OR_IGNORE do { if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) { TEST_ABORT(); } } while (0) + +struct UNITY_STORAGE_T Unity; + +#ifdef UNITY_OUTPUT_COLOR +const char UNITY_PROGMEM UnityStrOk[] = "\033[42mOK\033[0m"; +const char UNITY_PROGMEM UnityStrPass[] = "\033[42mPASS\033[0m"; +const char UNITY_PROGMEM UnityStrFail[] = "\033[41mFAIL\033[0m"; +const char UNITY_PROGMEM UnityStrIgnore[] = "\033[43mIGNORE\033[0m"; +#else +const char UNITY_PROGMEM UnityStrOk[] = "OK"; +const char UNITY_PROGMEM UnityStrPass[] = "PASS"; +const char UNITY_PROGMEM UnityStrFail[] = "FAIL"; +const char UNITY_PROGMEM UnityStrIgnore[] = "IGNORE"; +#endif +static const char UNITY_PROGMEM UnityStrNull[] = "NULL"; +static const char UNITY_PROGMEM UnityStrSpacer[] = ". "; +static const char UNITY_PROGMEM UnityStrExpected[] = " Expected "; +static const char UNITY_PROGMEM UnityStrWas[] = " Was "; +static const char UNITY_PROGMEM UnityStrGt[] = " to be greater than "; +static const char UNITY_PROGMEM UnityStrLt[] = " to be less than "; +static const char UNITY_PROGMEM UnityStrOrEqual[] = "or equal to "; +static const char UNITY_PROGMEM UnityStrNotEqual[] = " to be not equal to "; +static const char UNITY_PROGMEM UnityStrElement[] = " Element "; +static const char UNITY_PROGMEM UnityStrByte[] = " Byte "; +static const char UNITY_PROGMEM UnityStrMemory[] = " Memory Mismatch."; +static const char UNITY_PROGMEM UnityStrDelta[] = " Values Not Within Delta "; +static const char UNITY_PROGMEM UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; +static const char UNITY_PROGMEM UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; +static const char UNITY_PROGMEM UnityStrNullPointerForActual[] = " Actual pointer was NULL"; +#ifndef UNITY_EXCLUDE_FLOAT +static const char UNITY_PROGMEM UnityStrNot[] = "Not "; +static const char UNITY_PROGMEM UnityStrInf[] = "Infinity"; +static const char UNITY_PROGMEM UnityStrNegInf[] = "Negative Infinity"; +static const char UNITY_PROGMEM UnityStrNaN[] = "NaN"; +static const char UNITY_PROGMEM UnityStrDet[] = "Determinate"; +static const char UNITY_PROGMEM UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; +#endif +const char UNITY_PROGMEM UnityStrErrShorthand[] = "Unity Shorthand Support Disabled"; +const char UNITY_PROGMEM UnityStrErrFloat[] = "Unity Floating Point Disabled"; +const char UNITY_PROGMEM UnityStrErrDouble[] = "Unity Double Precision Disabled"; +const char UNITY_PROGMEM UnityStrErr64[] = "Unity 64-bit Support Disabled"; +const char UNITY_PROGMEM UnityStrErrDetailStack[] = "Unity Detail Stack Support Disabled"; +static const char UNITY_PROGMEM UnityStrBreaker[] = "-----------------------"; +static const char UNITY_PROGMEM UnityStrResultsTests[] = " Tests "; +static const char UNITY_PROGMEM UnityStrResultsFailures[] = " Failures "; +static const char UNITY_PROGMEM UnityStrResultsIgnored[] = " Ignored "; +#ifndef UNITY_EXCLUDE_DETAILS +#ifdef UNITY_DETAIL_STACK_SIZE +static const char* UNITY_PROGMEM UnityStrDetailLabels[] = UNITY_DETAIL_LABEL_NAMES; +static const UNITY_COUNTER_TYPE UNITY_PROGMEM UnityStrDetailLabelsCount = sizeof(UnityStrDetailLabels) / sizeof(const char*); +static const char UNITY_PROGMEM UnityStrErrDetailStackEmpty[] = " Detail Stack Empty"; +static const char UNITY_PROGMEM UnityStrErrDetailStackFull[] = " Detail Stack Full"; +static const char UNITY_PROGMEM UnityStrErrDetailStackLabel[] = " Detail Label Outside Of UNITY_DETAIL_LABEL_NAMES: "; +static const char UNITY_PROGMEM UnityStrErrDetailStackPop[] = " Detail Pop With Unexpected Arguments"; +#else +static const char UNITY_PROGMEM UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; +static const char UNITY_PROGMEM UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; +#endif +#endif +/*----------------------------------------------- + * 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++; + } + } +} +/*-----------------------------------------------*/ +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 UnityPrintIntNumberByStyle(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); + } + } +} + +void UnityPrintUintNumberByStyle(const UNITY_UINT number, const UNITY_DISPLAY_STYLE_T style) +{ + if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) + { + UnityPrintNumberUnsigned(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 (UNITY_IS_NAN(number)) + { + UnityPrint("nan"); + } + else if (UNITY_IS_INF(number)) + { + UnityPrint("inf"); + } + else + { + UNITY_INT32 n_int = 0; + UNITY_INT32 n; + int exponent = 0; + int decimals; + int 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)) + { + buf[digits++] = (char)('0' + n % 10); + n /= 10; + } + + /* print out buffer (backwards) */ + 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("'); + UnityPrint(Unity.CurrentTestName); + UnityPrint(" "); +#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) +{ +#ifdef UNITY_PRINT_TEST_CONTEXT + UnityPrint(UnityStrSpacer); + UNITY_PRINT_TEST_CONTEXT(); +#endif +#ifndef UNITY_EXCLUDE_DETAILS +#ifdef UNITY_DETAIL_STACK_SIZE + { + UNITY_COUNTER_TYPE c; + for (c = 0; (c < Unity.CurrentDetailStackSize) && (c < UNITY_DETAIL_STACK_SIZE); c++) { + const char* label; + if ((Unity.CurrentDetailStackLabels[c] == UNITY_DETAIL_NONE) || (Unity.CurrentDetailStackLabels[c] > UnityStrDetailLabelsCount)) { + break; + } + label = UnityStrDetailLabels[Unity.CurrentDetailStackLabels[c]]; + UnityPrint(UnityStrSpacer); + if ((label[0] == '#') && (label[1] != 0)) { + UnityPrint(label + 2); + UNITY_OUTPUT_CHAR(' '); + if ((label[1] & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) { + UnityPrintIntNumberByStyle((UNITY_INT)Unity.CurrentDetailStackValues[c], label[1]); + } else { + UnityPrintUintNumberByStyle((UNITY_UINT)Unity.CurrentDetailStackValues[c], label[1]); + } + } else if (Unity.CurrentDetailStackValues[c] != 0){ + UnityPrint(label); + UNITY_OUTPUT_CHAR(' '); + UnityPrint((const char*)Unity.CurrentDetailStackValues[c]); + } + } + } +#else + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrSpacer); + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + } +#endif +#endif + if (msg) + { + UnityPrint(UnityStrSpacer); + 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 UnityAssertEqualIntNumber(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); + UnityPrintIntNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintIntNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +void UnityAssertEqualUintNumber(const UNITY_UINT expected, + const UNITY_UINT 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); + UnityPrintUintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintUintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} +/*-----------------------------------------------*/ +void UnityAssertIntGreaterOrLessOrEqualNumber(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)) { failed = 1; } + + if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintIntNumberByStyle(actual, style); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + if (compare == UNITY_NOT_EQUAL) { UnityPrint(UnityStrNotEqual); } + UnityPrintIntNumberByStyle(threshold, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +void UnityAssertUintGreaterOrLessOrEqualNumber(const UNITY_UINT threshold, + const UNITY_UINT 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)) { failed = 1; } + + /* UINT or HEX */ + if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintUintNumberByStyle(actual, style); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + if (compare == UNITY_NOT_EQUAL) { UnityPrint(UnityStrNotEqual); } + UnityPrintUintNumberByStyle(threshold, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#define UnityPrintPointlessAndBail() \ +do { \ + UnityTestResultsFailBegin(lineNumber); \ + UnityPrint(UnityStrPointless); \ + UnityAddMsgIfSpecified(msg); \ + UNITY_FAIL_AND_BAIL; \ +} while (0) + +/*-----------------------------------------------*/ +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) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + 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; + if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) + { + expect_val &= 0x000000FF; + actual_val &= 0x000000FF; + } + 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; + if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) + { + expect_val &= 0x0000FFFF; + actual_val &= 0x0000FFFF; + } + 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; +#ifdef UNITY_SUPPORT_64 + if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) + { + expect_val &= 0x00000000FFFFFFFF; + actual_val &= 0x00000000FFFFFFFF; + } +#endif + 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); + UnityPrintIntNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintIntNumberByStyle(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 (UNITY_IS_INF(expected) && UNITY_IS_INF(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 !(UNITY_IS_NAN(diff) || UNITY_IS_INF(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 UNITY_IS_NAN(expected) && UNITY_IS_NAN(actual) +#else + #define UNITY_NAN_CHECK 0 +#endif + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + do { \ + UnityPrint(UnityStrExpected); \ + UnityPrintFloat(expected); \ + UnityPrint(UnityStrWas); \ + UnityPrintFloat(actual); \ + } while (0) +#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 UnityAssertWithinFloatArray(const UNITY_FLOAT delta, + 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; + UNITY_FLOAT in_delta = delta; + UNITY_FLOAT current_element_delta = delta; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if (UNITY_IS_INF(in_delta)) + { + return; /* Arrays will be force equal with infinite delta */ + } + + if (UNITY_IS_NAN(in_delta)) + { + /* Delta must be correct number */ + 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; + } + + /* fix delta sign if need */ + if (in_delta < 0) + { + in_delta = -in_delta; + } + + while (elements--) + { + current_element_delta = *ptr_expected * UNITY_FLOAT_PRECISION; + + if (current_element_delta < 0) + { + /* fix delta sign for correct calculations */ + current_element_delta = -current_element_delta; + } + + if (!UnityFloatsWithin(in_delta + current_element_delta, *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 UnityAssertFloatsNotWithin(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); + UnityPrint(UnityStrExpected); + UnityPrintFloat((UNITY_DOUBLE)expected); + UnityPrint(UnityStrNotEqual); + UnityPrintFloat((UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, + const UNITY_FLOAT actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + int failed; + + RETURN_IF_FAIL_OR_IGNORE; + + failed = 0; + + /* Checking for "not success" rather than failure to get the right result for NaN */ + if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + + if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin(threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintFloat(actual); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + UnityPrintFloat(threshold); + 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 = UNITY_IS_INF(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = UNITY_IS_INF(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = UNITY_IS_NAN(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 = !UNITY_IS_INF(actual) && !UNITY_IS_NAN(actual); + break; + + case UNITY_FLOAT_INVALID_TRAIT: /* Supress warning */ + default: /* including UNITY_FLOAT_INVALID_TRAIT */ + 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 UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, + 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; + UNITY_DOUBLE in_delta = delta; + UNITY_DOUBLE current_element_delta = delta; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if (UNITY_IS_INF(in_delta)) + { + return; /* Arrays will be force equal with infinite delta */ + } + + if (UNITY_IS_NAN(in_delta)) + { + /* Delta must be correct number */ + 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; + } + + /* fix delta sign if need */ + if (in_delta < 0) + { + in_delta = -in_delta; + } + + while (elements--) + { + current_element_delta = *ptr_expected * UNITY_DOUBLE_PRECISION; + + if (current_element_delta < 0) + { + /* fix delta sign for correct calculations */ + current_element_delta = -current_element_delta; + } + + if (!UnityDoublesWithin(in_delta + current_element_delta, *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 UnityAssertDoublesNotWithin(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); + UnityPrint(UnityStrExpected); + UnityPrintFloat((UNITY_DOUBLE)expected); + UnityPrint(UnityStrNotEqual); + UnityPrintFloat((UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, + const UNITY_DOUBLE actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + int failed; + + RETURN_IF_FAIL_OR_IGNORE; + + failed = 0; + + /* Checking for "not success" rather than failure to get the right result for NaN */ + if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + + if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin(threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintFloat(actual); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + UnityPrintFloat(threshold); + 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 = UNITY_IS_INF(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = UNITY_IS_INF(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = UNITY_IS_NAN(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 = !UNITY_IS_INF(actual) && !UNITY_IS_NAN(actual); + break; + + case UNITY_FLOAT_INVALID_TRAIT: /* Supress warning */ + default: /* including UNITY_FLOAT_INVALID_TRAIT */ + 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 UnityAssertIntNumbersWithin(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 (actual > 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); + UnityPrintIntNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrExpected); + UnityPrintIntNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintIntNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +void UnityAssertUintNumbersWithin(const UNITY_UINT delta, + const UNITY_UINT expected, + const UNITY_UINT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (actual > expected) + { + Unity.CurrentTestFailed = ((actual - expected) > delta); + } + else + { + Unity.CurrentTestFailed = ((expected - actual) > delta); + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintUintNumberByStyle(delta, style); + UnityPrint(UnityStrExpected); + UnityPrintUintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintUintNumberByStyle(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) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + 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: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + increment = sizeof(UNITY_INT8); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT8*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT8*)actual; + increment = sizeof(UNITY_UINT8); + } + break; + + case 2: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + increment = sizeof(UNITY_INT16); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT16*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT16*)actual; + increment = sizeof(UNITY_UINT16); + } + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT64*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT64*)actual; + increment = sizeof(UNITY_UINT64); + } + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + increment = sizeof(UNITY_INT32); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT32*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT32*)actual; + increment = sizeof(UNITY_UINT32); + } + 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); + UnityPrintIntNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintIntNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintIntNumberByStyle(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 + { /* fail if either null but not if both */ + 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 + { /* fail if either null but not if both */ + 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) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + 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) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + if (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); + UnityPrintIntNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); + UnityPrint(UnityStrWas); + UnityPrintIntNumberByStyle(*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 + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED + +/*----------------------------------------------- + * printf length modifier helpers + *-----------------------------------------------*/ + +enum UnityLengthModifier { + UNITY_LENGTH_MODIFIER_NONE, + UNITY_LENGTH_MODIFIER_LONG_LONG, + UNITY_LENGTH_MODIFIER_LONG, +}; + +#define UNITY_EXTRACT_ARG(NUMBER_T, NUMBER, LENGTH_MOD, VA, ARG_T) \ +do { \ + switch (LENGTH_MOD) \ + { \ + case UNITY_LENGTH_MODIFIER_LONG_LONG: \ + { \ + NUMBER = (NUMBER_T)va_arg(VA, long long ARG_T); \ + break; \ + } \ + case UNITY_LENGTH_MODIFIER_LONG: \ + { \ + NUMBER = (NUMBER_T)va_arg(VA, long ARG_T); \ + break; \ + } \ + case UNITY_LENGTH_MODIFIER_NONE: \ + default: \ + { \ + NUMBER = (NUMBER_T)va_arg(VA, ARG_T); \ + break; \ + } \ + } \ +} while (0) + +static enum UnityLengthModifier UnityLengthModifierGet(const char *pch, int *length) +{ + enum UnityLengthModifier length_mod; + switch (pch[0]) + { + case 'l': + { + if (pch[1] == 'l') + { + *length = 2; + length_mod = UNITY_LENGTH_MODIFIER_LONG_LONG; + } + else + { + *length = 1; + length_mod = UNITY_LENGTH_MODIFIER_LONG; + } + break; + } + case 'h': + { + // short and char are converted to int + length_mod = UNITY_LENGTH_MODIFIER_NONE; + if (pch[1] == 'h') + { + *length = 2; + } + else + { + *length = 1; + } + break; + } + case 'j': + case 'z': + case 't': + case 'L': + { + // Not supported, but should gobble up the length specifier anyway + length_mod = UNITY_LENGTH_MODIFIER_NONE; + *length = 1; + break; + } + default: + { + length_mod = UNITY_LENGTH_MODIFIER_NONE; + *length = 0; + } + } + return length_mod; +} + +/*----------------------------------------------- + * printf helper function + *-----------------------------------------------*/ +static void UnityPrintFVA(const char* format, va_list va) +{ + const char* pch = format; + if (pch != NULL) + { + while (*pch) + { + /* format identification character */ + if (*pch == '%') + { + pch++; + + if (pch != NULL) + { + int length_mod_size; + enum UnityLengthModifier length_mod = UnityLengthModifierGet(pch, &length_mod_size); + pch += length_mod_size; + + switch (*pch) + { + case 'd': + case 'i': + { + UNITY_INT number; + UNITY_EXTRACT_ARG(UNITY_INT, number, length_mod, 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': + { + UNITY_UINT number; + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + UnityPrintNumberUnsigned(number); + break; + } + case 'b': + { + UNITY_UINT number; + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + const UNITY_UINT mask = (UNITY_UINT)0 - (UNITY_UINT)1; + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('b'); + UnityPrintMask(mask, number); + break; + } + case 'x': + case 'X': + { + UNITY_UINT number; + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex(number, UNITY_MAX_NIBBLES); + break; + } + case 'p': + { + UNITY_UINT number; + char nibbles_to_print = 8; + if (UNITY_POINTER_WIDTH == 64) + { + length_mod = UNITY_LENGTH_MODIFIER_LONG_LONG; + nibbles_to_print = 16; + } + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, nibbles_to_print); + 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++; + } + } +} + +void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint("INFO"); + if(format != NULL) + { + UnityPrint(": "); + va_list va; + va_start(va, format); + UnityPrintFVA(format, va); + va_end(va); + } + UNITY_PRINT_EOL(); +} +#endif /* ! UNITY_INCLUDE_PRINT_FORMATTED */ + + +/*----------------------------------------------- + * Control Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityFail(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + UnityAddMsgIfSpecified(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++; + #ifndef UNITY_EXCLUDE_DETAILS + #ifdef UNITY_DETAIL_STACK_SIZE + Unity.CurrentDetailStackSize = 0; + #else + UNITY_CLR_DETAILS(); + #endif + #endif + 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); +} + +/*----------------------------------------------- + * Details Stack + *-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_DETAILS +#ifdef UNITY_DETAIL_STACK_SIZE +void UnityPushDetail(UNITY_DETAIL_LABEL_TYPE label, UNITY_DETAIL_VALUE_TYPE value, const UNITY_LINE_TYPE line) { + if (Unity.CurrentDetailStackSize >= UNITY_DETAIL_STACK_SIZE) { + UnityTestResultsFailBegin(line); + UnityPrint(UnityStrErrDetailStackFull); + UnityAddMsgIfSpecified(NULL); + UNITY_FAIL_AND_BAIL; + } + if (label >= UnityStrDetailLabelsCount) { + UnityTestResultsFailBegin(line); + UnityPrint(UnityStrErrDetailStackLabel); + UnityPrintNumberUnsigned(label); + UnityAddMsgIfSpecified(NULL); + UNITY_FAIL_AND_BAIL; + } + Unity.CurrentDetailStackLabels[Unity.CurrentDetailStackSize] = label; + Unity.CurrentDetailStackValues[Unity.CurrentDetailStackSize++] = value; +} +void UnityPopDetail(UNITY_DETAIL_LABEL_TYPE label, UNITY_DETAIL_VALUE_TYPE value, const UNITY_LINE_TYPE line) { + if (Unity.CurrentDetailStackSize == 0) { + UnityTestResultsFailBegin(line); + UnityPrint(UnityStrErrDetailStackEmpty); + UnityAddMsgIfSpecified(NULL); + UNITY_FAIL_AND_BAIL; + } + if ((Unity.CurrentDetailStackLabels[Unity.CurrentDetailStackSize-1] != label) || (Unity.CurrentDetailStackValues[Unity.CurrentDetailStackSize-1] != value)) { + UnityTestResultsFailBegin(line); + UnityPrint(UnityStrErrDetailStackPop); + UnityAddMsgIfSpecified(NULL); + UNITY_FAIL_AND_BAIL; + } + Unity.CurrentDetailStackSize--; +} +#endif +#endif + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ +#ifdef UNITY_USE_COMMAND_LINE_ARGS + +char* UnityOptionIncludeNamed = NULL; +char* UnityOptionExcludeNamed = NULL; +int UnityVerbosity = 1; +int UnityStrictMatch = 0; + +/*-----------------------------------------------*/ +int UnityParseOptions(int argc, char** argv) +{ + int i; + UnityOptionIncludeNamed = NULL; + UnityOptionExcludeNamed = NULL; + UnityStrictMatch = 0; + + 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 */ + UnityStrictMatch = (argv[i][1] == 'n'); /* strictly match this string if -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(); + /* Now display help */ + /* FALLTHRU */ + case 'h': + UnityPrint("Options: "); UNITY_PRINT_EOL(); + UnityPrint("-l List all tests and exit"); UNITY_PRINT_EOL(); + UnityPrint("-f NAME Filter to run only tests whose name includes NAME"); UNITY_PRINT_EOL(); + UnityPrint("-n NAME Run only the test named NAME"); UNITY_PRINT_EOL(); + UnityPrint("-h show this Help menu"); UNITY_PRINT_EOL(); + UnityPrint("-q Quiet/decrease verbosity"); UNITY_PRINT_EOL(); + UnityPrint("-v increase Verbosity"); UNITY_PRINT_EOL(); + UnityPrint("-x NAME eXclude tests whose name includes NAME"); UNITY_PRINT_EOL(); + UNITY_OUTPUT_FLUSH(); + return 1; + } + } + } + + return 0; +} + +/*-----------------------------------------------*/ +static int IsStringInBiggerString(const char* longstring, const char* shortstring) +{ + const char* lptr = longstring; + const char* sptr = shortstring; + const char* lnext = lptr; + + if (*sptr == '*') + { + return UnityStrictMatch ? 0 : 1; + } + + while (*lptr) + { + lnext = lptr + 1; + + /* If they current bytes match, go on to the next bytes */ + while (*lptr && *sptr && (*lptr == *sptr)) + { + lptr++; + sptr++; + + switch (*sptr) + { + case '*': /* we encountered a wild-card */ + return UnityStrictMatch ? 0 : 1; + + case ',': /* we encountered the end of match string */ + case '"': + case '\'': + case 0: + return (!UnityStrictMatch || (*lptr == 0)) ? 1 : 0; + + case ':': /* we encountered the end of a partial match */ + return 2; + + default: + break; + } + } + + // If we didn't match and we're on strict matching, we already know we failed + if (UnityStrictMatch) + { + return 0; + } + + /* Otherwise we start in the long pointer 1 character further and try again */ + lptr = lnext; + sptr = shortstring; + } + + return 0; +} + +/*-----------------------------------------------*/ +static 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/doblespiel/unity/unity.h b/doblespiel/unity/unity.h new file mode 100644 index 0000000..7c749c2 --- /dev/null +++ b/doblespiel/unity/unity.h @@ -0,0 +1,698 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_FRAMEWORK_H +#define UNITY_FRAMEWORK_H +#define UNITY + +#define UNITY_VERSION_MAJOR 2 +#define UNITY_VERSION_MINOR 6 +#define UNITY_VERSION_BUILD 2 +#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 or 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 + * - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in + * - 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(...), TEST_RANGE(...) and/or TEST_MATRIX(...) 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() +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#define TEST_PRINTF(message, ...) UnityPrintF(__LINE__, (message), ##__VA_ARGS__) +#endif + +/* 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) + +/*------------------------------------------------------- + * Build Directives + *------------------------------------------------------- + + * These macros do nothing, but they are useful for additional build context. + * Tools (like Ceedling) can scan for these directives and make use of them for + * per-test-executable #include search paths and linking. */ + +/* Add source files to a test executable's compilation and linking. Ex: TEST_SOURCE_FILE("sandwiches.c") */ +#define TEST_SOURCE_FILE(a) + +/* Customize #include search paths for a test executable's compilation. Ex: TEST_INCLUDE_PATH("src/module_a/inc") */ +#define TEST_INCLUDE_PATH(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") +#define TEST_ASSERT_EMPTY(pointer) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, " Expected Empty") +#define TEST_ASSERT_NOT_EMPTY(pointer) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, " Expected Non-Empty") + +/* 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_UINT)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(0), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(0), (actual), __LINE__, NULL) + +/* Integer Not Equal To (of all sizes) */ +#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (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_FLOAT_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_NOT_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_NOT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __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_GREATER_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual) UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __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_DOUBLE_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_NOT_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_NOT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __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_GREATER_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __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)) +#define TEST_ASSERT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, (message)) +#define TEST_ASSERT_NOT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_EMPTY((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 Not Equal To (of all sizes) */ +#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (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_NOT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __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_GREATER_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __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_NOT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __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_GREATER_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __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/doblespiel/unity/unity_internals.h b/doblespiel/unity/unity_internals.h new file mode 100644 index 0000000..a66859a --- /dev/null +++ b/doblespiel/unity/unity_internals.h @@ -0,0 +1,1271 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_INTERNALS_H +#define UNITY_INTERNALS_H + +#ifdef UNITY_INCLUDE_CONFIG_H +#include "unity_config.h" +#endif + +#ifndef UNITY_EXCLUDE_SETJMP_H +#include +#endif + +#ifndef UNITY_EXCLUDE_MATH_H +#include +#endif + +#ifndef UNITY_EXCLUDE_STDDEF_H +#include +#endif + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#include +#endif + +/* Unity Attempts to Auto-Detect Integer Types + * Attempt 1: UINT_MAX, ULONG_MAX in , or default to 32 bits + * Attempt 2: UINTPTR_MAX in , 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 +#endif + +#ifndef UNITY_EXCLUDE_LIMITS_H +#include +#endif + +#if defined(__GNUC__) || defined(__clang__) + #define UNITY_FUNCTION_ATTR(a) __attribute__((a)) +#else + #define UNITY_FUNCTION_ATTR(a) /* ignore */ +#endif + +/* UNITY_NORETURN is only required if we have setjmp.h. */ +#ifndef UNITY_EXCLUDE_SETJMP_H + #ifndef UNITY_NORETURN + #if defined(__cplusplus) + #if __cplusplus >= 201103L + #define UNITY_NORETURN [[ noreturn ]] + #endif + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && __STDC_VERSION__ < 202311L + /* _Noreturn keyword is used from C11 but deprecated in C23. */ + #if defined(_WIN32) && defined(_MSC_VER) + /* We are using MSVC compiler on Windows platform. */ + /* Not all Windows SDKs supports , but compiler can support C11: */ + /* https://devblogs.microsoft.com/cppblog/c11-and-c17-standard-support-arriving-in-msvc/ */ + /* Not sure, that Mingw compilers has Windows SDK headers at all. */ + #include + #endif + + /* Using Windows SDK predefined macro for detecting supported SDK with MSVC compiler. */ + /* Mingw GCC should work without that fixes. */ + /* Based on: */ + /* https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt?view=msvc-170 */ + /* NTDDI_WIN10_FE is equal to Windows 10 SDK 2104 */ + #if defined(_MSC_VER) && ((!defined(NTDDI_WIN10_FE)) || WDK_NTDDI_VERSION < NTDDI_WIN10_FE) + /* Based on tests and: */ + /* https://docs.microsoft.com/en-us/cpp/c-language/noreturn?view=msvc-170 */ + /* https://en.cppreference.com/w/c/language/_Noreturn */ + #define UNITY_NORETURN _Noreturn + #else /* Using newer Windows SDK or not MSVC compiler */ + #if defined(__GNUC__) + /* The header collides with __attribute(noreturn)__ from GCC. */ + #define UNITY_NORETURN _Noreturn + #else + #include + #define UNITY_NORETURN noreturn + #endif + #endif + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L + /* Since C23, the keyword _Noreturn has been replaced by the attribute noreturn, based on: */ + /* https://en.cppreference.com/w/c/language/attributes/noreturn */ + #define UNITY_NORETURN [[ noreturn ]] + #elif defined(__IAR_SYSTEMS_ICC__) && (__IAR_SYSTEMS_ICC__ >= 8) + /* For IAR compilers supporting at least C99 use the IAR specific '__noreturn' keyword */ + /* Based on tests and: */ + /* https://wwwfiles.iar.com/arm/webic/doc/EWARM_DevelopmentGuide.ENU.pdf */ + /* https://wwwfiles.iar.com/AVR/webic/doc/EWAVR_CompilerGuide.pdf */ + /* https://wwwfiles.iar.com/msp430/webic/doc/EW430_CompilerReference.pdf */ + #define UNITY_NORETURN __noreturn + #endif + #endif + #ifndef UNITY_NORETURN + #define UNITY_NORETURN UNITY_FUNCTION_ATTR(__noreturn__) + #endif +#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 + +/* optionally define UNITY_COMPARE_PTRS_ON_ZERO_ARRAY */ + +/*------------------------------------------------------- + * 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; + +/* isnan macro should be provided by math.h. Override if not macro */ +#ifndef UNITY_IS_NAN +#ifndef isnan +/* NaN is the only floating point value that does NOT equal itself. + * Therefore if n != n, then it is NaN. */ +#define UNITY_IS_NAN(n) ((n != n) ? 1 : 0) +#else +#define UNITY_IS_NAN(n) isnan(n) +#endif +#endif + +/* isinf macro should be provided by math.h. Override if not macro */ +#ifndef UNITY_IS_INF +#ifndef isinf +/* The value of Inf - Inf is NaN */ +#define UNITY_IS_INF(n) (UNITY_IS_NAN((n) - (n)) && !UNITY_IS_NAN(n)) +#else +#define UNITY_IS_INF(n) isinf(n) +#endif +#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 + #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 + #define UNITY_OUTPUT_FLUSH() (void)fflush(stdout) + #else + /* We've specified nothing, therefore flush should just be ignored */ + #define UNITY_OUTPUT_FLUSH() (void)0 + #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 + #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__) || defined(__APPLE__) + #include + #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 { /* nothing*/ } while (0) +#endif + +#ifndef UNITY_EXEC_TIME_STOP +#define UNITY_EXEC_TIME_STOP() do { /* nothing*/ } 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 { /* nothing*/ } 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_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_NOT_EQUAL = 0x8 +} 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; + +#ifndef UNITY_EXCLUDE_DETAILS +#ifdef UNITY_DETAIL_STACK_SIZE +#ifndef UNITY_DETAIL_LABEL_TYPE +#define UNITY_DETAIL_LABEL_TYPE uint8_t +#endif +#ifndef UNITY_DETAIL_VALUE_TYPE +#define UNITY_DETAIL_VALUE_TYPE UNITY_PTR_TO_INT +#endif +#endif +#endif + +struct UNITY_STORAGE_T +{ + const char* TestFile; + const char* CurrentTestName; +#ifndef UNITY_EXCLUDE_DETAILS +#ifdef UNITY_DETAIL_STACK_SIZE + UNITY_DETAIL_LABEL_TYPE CurrentDetailStackLabels[UNITY_DETAIL_STACK_SIZE]; + UNITY_DETAIL_VALUE_TYPE CurrentDetailStackValues[UNITY_DETAIL_STACK_SIZE]; + UNITY_COUNTER_TYPE CurrentDetailStackSize; +#else + const char* CurrentDetail1; + const char* CurrentDetail2; +#endif +#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 +#ifndef UNITY_DETAIL1_NAME +#define UNITY_DETAIL1_NAME "Function" +#endif + +#ifndef UNITY_DETAIL2_NAME +#define UNITY_DETAIL2_NAME "Argument" +#endif + +#ifdef UNITY_DETAIL_STACK_SIZE +/* stack based implementation */ +#ifndef UNITY_DETAIL_LABEL_NAMES +/* Note: If the label name string starts with '#', the second byte is interpreted as UNITY_DISPLAY_STYLE_T, + * and the detail value will be printed as number (e.g. "#\x24Line" to output "Line "). + * Otherwise, the detail value must be a pointer to a string that is valid until it is pop'ed. + */ +#define UNITY_DETAIL_LABEL_NAMES {0, UNITY_DETAIL1_NAME, UNITY_DETAIL2_NAME} +typedef enum +{ + UNITY_DETAIL_NONE = 0, + UNITY_DETAIL_D1 = 1, + UNITY_DETAIL_D2 = 2 +} UNITY_DETAIL_LABEL_T; +#endif +void UnityPushDetail(UNITY_DETAIL_LABEL_TYPE label, UNITY_DETAIL_VALUE_TYPE value, const UNITY_LINE_TYPE line); +void UnityPopDetail(UNITY_DETAIL_LABEL_TYPE label, UNITY_DETAIL_VALUE_TYPE value, const UNITY_LINE_TYPE line); + +#define UNITY_CLR_DETAILS() do { \ + if(Unity.CurrentDetailStackSize && \ + Unity.CurrentDetailStackLabels[Unity.CurrentDetailStackSize - 1] == UNITY_DETAIL_D2) { \ + Unity.CurrentDetailStackLabels[--Unity.CurrentDetailStackSize] = UNITY_DETAIL_NONE;} \ + if(Unity.CurrentDetailStackSize && \ + Unity.CurrentDetailStackLabels[Unity.CurrentDetailStackSize - 1] == UNITY_DETAIL_D1) { \ + Unity.CurrentDetailStackLabels[--Unity.CurrentDetailStackSize] = UNITY_DETAIL_NONE;} \ + } while (0) +#define UNITY_SET_DETAIL(d1) do { UNITY_CLR_DETAILS(); \ + UnityPushDetail(UNITY_DETAIL_D1, (UNITY_DETAIL_VALUE_TYPE)(d1), __LINE__); \ + } while (0) +#define UNITY_SET_DETAILS(d1,d2) do { UNITY_CLR_DETAILS(); \ + UnityPushDetail(UNITY_DETAIL_D1, (UNITY_DETAIL_VALUE_TYPE)(d1), __LINE__); \ + UnityPushDetail(UNITY_DETAIL_D2, (UNITY_DETAIL_VALUE_TYPE)(d2), __LINE__); \ + } while (0) + +#else +/* just two hardcoded slots */ +#define UNITY_CLR_DETAILS() do { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } while (0) +#define UNITY_SET_DETAIL(d1) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } while (0) +#define UNITY_SET_DETAILS(d1,d2) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } while (0) +#endif +#endif + +#ifdef UNITY_PRINT_TEST_CONTEXT +void UNITY_PRINT_TEST_CONTEXT(void); +#endif + +/*------------------------------------------------------- + * Test Output + *-------------------------------------------------------*/ + +void UnityPrint(const char* string); + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...); +#endif + +void UnityPrintLen(const char* string, const UNITY_UINT32 length); +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number); +void UnityPrintIntNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style); +void UnityPrintUintNumberByStyle(const UNITY_UINT 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 UnityAssertEqualIntNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertEqualUintNumber(const UNITY_UINT expected, + const UNITY_UINT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertIntGreaterOrLessOrEqualNumber(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 UnityAssertUintGreaterOrLessOrEqualNumber(const UNITY_UINT threshold, + const UNITY_UINT 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 UnityAssertIntNumbersWithin(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 UnityAssertUintNumbersWithin(const UNITY_UINT delta, + const UNITY_UINT expected, + const UNITY_UINT 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); + +#ifndef UNITY_EXCLUDE_SETJMP_H +UNITY_NORETURN void UnityFail(const char* message, const UNITY_LINE_TYPE line); +UNITY_NORETURN void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +#else +void UnityFail(const char* message, const UNITY_LINE_TYPE line); +void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +#endif + +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 UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, + const UNITY_FLOAT actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE linenumber); + +void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, + 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 UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, + const UNITY_DOUBLE actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE linenumber); + +void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, + 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 + *-------------------------------------------------------*/ + +#ifdef UNITY_TEST_PROTECT +#define TEST_PROTECT() UNITY_TEST_PROTECT() +#else +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) +#else +#define TEST_PROTECT() 1 +#endif +#endif + +#ifdef UNITY_TEST_ABORT +#define TEST_ABORT() UNITY_TEST_ABORT() +#else +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) +#else +#define TEST_ABORT() return +#endif +#endif + +/* Automatically enable variadic macros support, if it not enabled before */ +#ifndef UNITY_SUPPORT_VARIADIC_MACROS + #ifdef __STDC_VERSION__ + #if __STDC_VERSION__ >= 199901L + #define UNITY_SUPPORT_VARIADIC_MACROS + #endif + #endif +#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 UNITY_SUPPORT_VARIADIC_MACROS +#define RUN_TEST(...) RUN_TEST_AT_LINE(__VA_ARGS__, __LINE__, throwaway) +#define RUN_TEST_AT_LINE(func, line, ...) UnityDefaultTestRun(func, #func, line) +#endif +#endif + +/* Enable default macros for masking param tests test cases */ +#ifdef UNITY_SUPPORT_TEST_CASES + #ifdef UNITY_SUPPORT_VARIADIC_MACROS + #if !defined(TEST_CASE) && !defined(UNITY_EXCLUDE_TEST_CASE) + #define TEST_CASE(...) + #endif + #if !defined(TEST_RANGE) && !defined(UNITY_EXCLUDE_TEST_RANGE) + #define TEST_RANGE(...) + #endif + #if !defined(TEST_MATRIX) && !defined(UNITY_EXCLUDE_TEST_MATRIX) + #define TEST_MATRIX(...) + #endif + #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) do { if (condition) { /* nothing*/ } else { UNITY_TEST_FAIL((line), (message)); } } while (0) +#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (line), (message)) +#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (line), (message)) +#define UNITY_TEST_ASSERT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) == 0), (line), (message)) +#define UNITY_TEST_ASSERT_NOT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) != 0), (line), (message)) + +#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualIntNumber((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) UnityAssertEqualIntNumber((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) UnityAssertEqualIntNumber((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) UnityAssertEqualIntNumber((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) UnityAssertEqualUintNumber((UNITY_UINT)(expected), (UNITY_UINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualUintNumber((UNITY_UINT)(UNITY_UINT8)(expected), (UNITY_UINT)(UNITY_UINT8)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualUintNumber((UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualUintNumber((UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualUintNumber((UNITY_UINT)(UNITY_UINT8)(expected), (UNITY_UINT)(UNITY_UINT8)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualUintNumber((UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualUintNumber((UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_EQUAL_CHAR(expected, actual, line, message) UnityAssertEqualIntNumber((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_NOT_EQUAL_INT(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT) (threshold), (UNITY_UINT) (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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT) (threshold), (UNITY_UINT) (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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT8 )(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT16)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(UNITY_UINT32)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertIntNumbersWithin( (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) UnityAssertIntNumbersWithin((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) UnityAssertIntNumbersWithin((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) UnityAssertIntNumbersWithin((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) UnityAssertUintNumbersWithin( (delta), (UNITY_UINT) (expected), (UNITY_UINT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertUintNumbersWithin((UNITY_UINT8 )(delta), (UNITY_UINT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_UINT)(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) UnityAssertUintNumbersWithin((UNITY_UINT16)(delta), (UNITY_UINT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_UINT)(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) UnityAssertUintNumbersWithin((UNITY_UINT32)(delta), (UNITY_UINT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_UINT)(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) UnityAssertUintNumbersWithin((UNITY_UINT8 )(delta), (UNITY_UINT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_UINT)(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) UnityAssertUintNumbersWithin((UNITY_UINT16)(delta), (UNITY_UINT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_UINT)(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) UnityAssertUintNumbersWithin((UNITY_UINT32)(delta), (UNITY_UINT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_UINT)(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) UnityAssertIntNumbersWithin((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_UINT8 )(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) UnityAssertEqualIntNumber((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) UnityAssertEqualIntNumber((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) UnityAssertEqualIntNumber((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) UnityAssertEqualIntNumber((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) UnityAssertIntNumbersWithin((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) UnityAssertUintNumbersWithin((delta), (UNITY_UINT)(expected), (UNITY_UINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertUintNumbersWithin((delta), (UNITY_UINT)(expected), (UNITY_UINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(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) UnityAssertIntGreaterOrLessOrEqualNumber((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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(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) UnityAssertUintGreaterOrLessOrEqualNumber((UNITY_UINT)(threshold), (UNITY_UINT)(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_FLOAT_NOT_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_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, 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_GREATER_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, 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_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsNotWithin((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_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)(delta), (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, (const UNITY_FLOAT*)(expected), (const 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) UnityAssertWithinFloatArray((UNITY_FLOAT)0, UnityFloatToPtr(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#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_DOUBLE_NOT_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_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, 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_GREATER_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, 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_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesNotWithin((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_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)(delta), (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, (const UNITY_DOUBLE*)(expected), (const 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) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, UnityDoubleToPtr(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#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 + +#if !defined(UNITY_EXCLUDE_DETAILS) && defined(UNITY_DETAIL_STACK_SIZE) +#define UNITY_DETAIL_PUSH(label, value) UnityPushDetail((UNITY_DETAIL_LABEL_TYPE)(label), (UNITY_DETAIL_VALUE_TYPE)(value), __LINE__) +#define UNITY_DETAIL_POP(label, value) UnityPopDetail((UNITY_DETAIL_LABEL_TYPE)(label), (UNITY_DETAIL_VALUE_TYPE)(value), __LINE__) +#else +#define UNITY_DETAIL_PUSH(label, value) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDetailStack) +#define UNITY_DETAIL_POP(label, value) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDetailStack) +#endif + +/* End of UNITY_INTERNALS_H */ +#endif diff --git a/doblespiel/windows/libdoble_complete.a b/doblespiel/windows/libdoble_complete.a new file mode 100644 index 0000000000000000000000000000000000000000..728bb8f4ab6565bf5927777ae6397da54dbb2417 GIT binary patch literal 14140 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