From dff4c782dbf4bd346c46effb8a04f65a2cdd0608 Mon Sep 17 00:00:00 2001 From: Benedikt Date: Tue, 16 Dec 2025 10:13:02 +0100 Subject: [PATCH] fertig --- Spiel_Aufgabenstellung.pdf | Bin 0 -> 50274 bytes bintree.c | 116 ++ bintree.h | 27 + bintree.md | 100 ++ bintree.o | Bin 0 -> 5465 bytes bintreeTest.c | 119 ++ doble.exe | Bin 0 -> 81083 bytes doble_initial.exe | Bin 0 -> 66659 bytes highscore.c | 134 ++ highscore.h | 25 + highscore.o | Bin 0 -> 8751 bytes highscores.txt | 3 + linux/libdoble_complete.a | Bin 0 -> 20738 bytes macos-arm64/libdoble_complete.a | Bin 0 -> 15680 bytes macos-x86_64/libdoble_complete.a | Bin 0 -> 15424 bytes main.c | 90 + main.o | Bin 0 -> 5953 bytes makefile | 64 + makefile_linux.variables | 2 + makefile_mac.variables | 3 + makefile_windows.variables | 2 + number.md | 30 + numbers.c | 105 ++ numbers.h | 12 + numbers.o | Bin 0 -> 5848 bytes numbersTest.c | 93 ++ runBintreeTest.exe | Bin 0 -> 105098 bytes runNumbersTest.exe | Bin 0 -> 109675 bytes runStackTest.exe | Bin 0 -> 104164 bytes stack.c | 61 + stack.h | 30 + stack.o | Bin 0 -> 3927 bytes stackTest.c | 260 +++ test_stack.c | 80 + timer.c | 55 + timer.h | 13 + timer.o | Bin 0 -> 3086 bytes unity/LICENSE.txt | 21 + unity/unity.c | 2622 ++++++++++++++++++++++++++++++ unity/unity.h | 698 ++++++++ unity/unity_internals.h | 1271 +++++++++++++++ windows/libdoble_complete.a | Bin 0 -> 14140 bytes 42 files changed, 6036 insertions(+) create mode 100644 Spiel_Aufgabenstellung.pdf create mode 100644 bintree.c create mode 100644 bintree.h create mode 100644 bintree.md create mode 100644 bintree.o create mode 100644 bintreeTest.c create mode 100644 doble.exe create mode 100644 doble_initial.exe create mode 100644 highscore.c create mode 100644 highscore.h create mode 100644 highscore.o create mode 100644 highscores.txt create mode 100644 linux/libdoble_complete.a create mode 100644 macos-arm64/libdoble_complete.a create mode 100644 macos-x86_64/libdoble_complete.a create mode 100644 main.c create mode 100644 main.o create mode 100644 makefile create mode 100644 makefile_linux.variables create mode 100644 makefile_mac.variables create mode 100644 makefile_windows.variables create mode 100644 number.md create mode 100644 numbers.c create mode 100644 numbers.h create mode 100644 numbers.o create mode 100644 numbersTest.c create mode 100644 runBintreeTest.exe create mode 100644 runNumbersTest.exe create mode 100644 runStackTest.exe create mode 100644 stack.c create mode 100644 stack.h create mode 100644 stack.o create mode 100644 stackTest.c create mode 100644 test_stack.c create mode 100644 timer.c create mode 100644 timer.h create mode 100644 timer.o create mode 100644 unity/LICENSE.txt create mode 100644 unity/unity.c create mode 100644 unity/unity.h create mode 100644 unity/unity_internals.h create mode 100644 windows/libdoble_complete.a diff --git a/Spiel_Aufgabenstellung.pdf b/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. */ + +static StackNode *iteratorStack = NULL; + +// 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) +{ + if (root == NULL) + { + // Neue Node anlegen + TreeNode *newNode = malloc(sizeof(TreeNode)); + if (!newNode) return NULL; + + newNode->data = malloc(dataSize); + if(!newNode->data) + { + free(newNode); + return NULL; + } + + memcpy(newNode->data, data, dataSize); + + newNode->left = NULL; + newNode->right = NULL; + + if (isDuplicate) + *isDuplicate = 0; + + return newNode; + } + + int cmp = compareFct(data, root->data); + + if (cmp == 0) + { + if (isDuplicate) + *isDuplicate = 1; + return root; // Einfügen verhindern + } + + if (cmp < 0) + root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate); + else + root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate); + + return root; +} + +// 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) +{ + if (root != NULL) + { + clearStack(iteratorStack); + iteratorStack = NULL; + + // Root + alle linken Nachfolger pushen + TreeNode *current = root; + while (current != NULL) + { + iteratorStack = push(iteratorStack, current); + current = current->left; + } + } + + // Wenn Stack leer -> fertig + if (iteratorStack == NULL) + return NULL; + + // Top-Node holen + TreeNode *node = (TreeNode *)top(iteratorStack); + iteratorStack = pop(iteratorStack); + + // rechten Teilbaum + linke Kette pushen + TreeNode *right = node->right; + while (right != NULL) + { + iteratorStack = push(iteratorStack, right); + right = right->left; + } + + return node->data; +} + +// Releases all memory resources (including data copies). +void clearTree(TreeNode *root) +{ + if (root != NULL) + { + clearTree(root->left); + clearTree(root->right); + + free(root->data); + free(root); + } +} + +// Returns the number of entries in the tree given by root. +unsigned int treeSize(const TreeNode *root) +{ + if (root == NULL) + return 0; + + return 1 + treeSize(root->left) + treeSize(root->right); +} \ No newline at end of file diff --git a/bintree.h b/bintree.h new file mode 100644 index 0000000..25e16b2 --- /dev/null +++ b/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/bintree.md b/bintree.md new file mode 100644 index 0000000..2669dec --- /dev/null +++ b/bintree.md @@ -0,0 +1,100 @@ +1) static StackNode *iteratorStack = NULL + -> Stack für nextTreeData + -> wird verwendet um nach und nach die Zahlen von klein nach groß auszugeben + -> muss da so stehen, weil ansonsten nextTreeData immer von vorne anfängt + +2) addToTree -> soll ein Element an die richtige Stelle im Baum hinzufügen + -> wenn keine root angegeben ist (wenn entweder kein Baum vorhanden ist, oder die richtige Stelle gefunden wurde) soll ein neue Node erstellt werden. + -> Speicher reservieren + -> data nach newNode.data kopieren (memcpy) kopiert einfach nur den Inhalt ohne ihn zu interpretieren + -> pointer links und rechts werden NULL gesetzt, da keine anderen Datan vorhanden sind + -> isDublicate = 0, da kein Dublikat vorhanden sein kann + + -> root.data wird mit data verglichen (größer, kleiner, gleich), um zu entscheiden, ob rechts oder links eingefügt werden soll + -> gleich -> Dublikat -> einfügen verhindern + -> größer -> rechts einfügen + -> kleiner -> links einfügen + + -> eingefügt wird, in dem addToTree erneut aufgerufen wird, aber jetzt als root root.left/root.right übergeben wird + -> es wird erneut verglichen und wieder in den rechten, bzw. linken Teilbaum eingefügt, solange bis richtige Stelle im Baum erreicht ist -> einfügen des Wertes + +3) nextTreeData + -> soll nacheinander die Werte des Binärbaums der größe nach ausgeben + -> Diese Funktion beruht auf einem richtigen Binär Baum (werte stehen an der richtigen Stelle) + -> dabei wird der iteratorStack verwendet, auf diesem sind immer Teilbereiche unseres Binärbaums vorhanden (in sortierter Reihenfolge), allerdings ist er nie vollständig, sondern wird im laufe des Programms immer durch fehlende Werte ergänzt + + -> wenn root != NULL -> neuer Beginn bei einem ggf. anderen Baum + -> iteratorStack wird gelöscht um eventuelle "Rückstände" zu beseitigen + -> danach werden erstmal immer die jeweils linken Nodes in den Stack gepusht + -> im Stack liegt nun die kleinste Node ganz oben, danach werden die Werte immer größer, allerdings fehlen noch Werte dazwischen + + -> anschließend wird sich die oberste Node aus dem Stack geholt und aus dem Stack entfernt -> Die ist der kleinste Wert im Baum und soll somit auch als erste zurückgegeben werden + -> jetzt wird auf dem Stack der rechte Teilbaum von unseren kleinsten Wert im Baum auf den Stack gepusht -> diese Werte sind alle größer als unsere Node, jedoch kleiner als die davor vorletzte Node im Stack -> DER STACK IST ALSO IMMER NOCH NACH DER GRÖßE SORTIERT + -> unser Stack hat jetzt den nächst größeren Wert im Baum als top Node -> ausgangssituation für nächsten Aufruf + -> gepeicherte node wird verwendet um node.data auszugeben + + + + Beispiel Baum: + + 12 + / \ + 8 15 + / \ \ + 5 9 17 + / \ + 16 20 + + 1) erst alle linken Nodes pushen -> 5 + 8 + 12 + + 2) top Node (5) speichern und aus Stack entfernen -> 8 + 12 + + 3) rechte Node und alle jeweils linken Nodes pushen -> 8 + 12 + 4) -> 5 wird ausgegeben (gepeicherte Node) + 5) neuer Aufruf + 6) top Node speichern (8) und aus Stack entfernen -> 12 + 7) rechte Node und alle jeweils linken Nodes pushen -> 9 + 12 + 8) -> 8 wird ausgegeben (gespeicherte Node) + 9) neuer Aufruf + 10) top Node speichern (9) und aus Stack entfernen -> 12 + 11) rechte Node und alle jeweils linken Nodes pushen -> 12 + 12) -> 9 wird ausgegeben (gespeicherte Node) + 13) neuer Aufruf + 14) top Node speichern (12) und aus Stack entfernen -> NULL + 15) rechte Node und alle jeweils linken Nodes pushen -> 15 + 16) -> 12 wird ausgegeben (gespeicherte Node) + 17) neuer Aufruf + 18) top Node speichern (15) und aus Stack entfernen -> NULL + 19) rechte Node und alle jeweils linken Nodes pushen -> 16 + 17 + 20) -> 15 wird ausgegeben (gespeicherte Node) + 21) neuer Aufruf + 22) top Node speichern (16) und aus Stack entfernen -> 17 + 23) rechte Node und alle jeweils linken Nodes pushen -> 17 + 24) -> 16 wird ausgegeben (gespeicherte Node) + 25) neuer Aufruf + 26) top Node speichern (17) und aus Stack entfernen -> NULL + 27) rechte Node und alle jeweils linken Nodes pushen -> 20 + 28) -> 17 wird ausgegeben (gespeicherte Node) + 29) neuer Aufruf + 30) top Node speichern (20) und aus Stack entfernen -> NULL + 31) rechte Node und alle jeweils linken Nodes pushen -> NULL + 32) -> 20 wird ausgegeben (gespeicherte Node) + 33) neuer Aufruf -> Stack = NULL -> fertig + + +4) treeSize + -> rekursiver Aufruf der Funktion + + -> es wird jeweils die jeweils linke und rechte Node als neue root genommen + -> aufruf mit treeSize(root->left / root -> right) + -> es wird pro aufruf +1 gerechnet + -> am Ende wird die Node Anzahl zurückgegeben + + + diff --git a/bintree.o b/bintree.o new file mode 100644 index 0000000000000000000000000000000000000000..d230b775e180a67c1d4fc1882e5a317578c3b81b GIT binary patch literal 5465 zcmbtYU2GKB6~1?7?(W#L_Kv;&4G;!muxat`VtxuHBn!67x&cZ67m^a0{TZ(}tan$t zvtX>yRyL&Fx{O-$IbH8)Wch5cdf9|ATZ6cVGErfiIBZY)5bK2rqycQ)wR>E_;S;*~>8RX!J za5`Zn>Uf_8W8~n~aI##kx9RnQjlY4sX|Ka5*aFN;j*)0ATwKn38hAeo3T^;0QBNo}=jqfU0J7H{F zVGdwY;fayhp0RlKPJHekv3PaA9L$`>Ol<;&W$p5ygIT7 zhDB0o{58t=RzsBW`4J;ty=D{M19354)p<5g;^(hcI)q9vM7h7AGb93Ie!mf)AL|;e z{@(S1mRm6lQLt{sc&|d$QDQYh!RRftapS!o3IH`?rCs~xNBY3g?xhc^Bai0JJ|dM) zPdSJf%jx$g(0C?-I6fa!_s#F`gR(pph$$Mc?(5<0`s1fdOAsLR&K~uCzfITwEB)s+ zI>w{N=WfJay6)*_>{{#j_&lHXZliCpM@vgfcC(q4fk>lH1zh|RSKT^zWUPj3sjYvT2f>R3uhS~u=Sd5x^ z^Dn~&fXfo|pTL7_1M`2v(*yW0>^}@V10;dH2gZz{fz8IIt>J-i)aakGDtU8Ps!%cq zKuDBQle_YTR3V=*`ZHveythLpF)Ub@(65su>Pt-~O2l8z&Y0sCk)PU#d#Te{TLfCBO5@dT2Z^_?K8q)C;70Q`roMCv3j zB?X0Ms4!Jbl*})ttRrWNCQ*FBED+^9yqd9&Spd|15&4@S2OIKOahIZA14&e@H1a5j zFK13zMA2H&r20zP%p`~bF6u=77HIuPN~Xz!P@1?xzX@8Fwaik&DwKGPL<>CxWrGYM z@Fd63U$IamQbzzy9WZtj0Z}c~cKfm68*AEPr94TbR!)vPYRY@3C6zN1c16-kU&65x zb;_Jd70(bh(2B%!Xh0x(fSnL$#Bf5a>k_b#S#^t-@z+a1+ilX#u7_gw4Aw z_)HoKOAES^a%U+C9zDc)T}rk*Tq)+Vsf1;c;AA7$8Z0$cBpVuV>Piba?J2wV%XZH4 z=4n3l+U$@|fPpeH8UlU~(X?kY8MYTWNVGL7Diua#b#M*csqN54LlW#rY|G;sUlVFH zLD>%9DgKT+1x(N|eYV?S^mdPip6;gLx*+U$ou%Zjjxa4p?^p838H`Fi&4^GFCZLT%2c(&R=vprAF(H4 zkENFH80+@E$U0H@D{HGT&0QhECMqvUQhO=PYZtrNB8xpUW}z3TrsUI`6R1n=ClTRz=wgP6)I1 z3hR1@b-uz>i|H@0wWnFT8et(3QSda=uCVT?h)@l)V1>25!}J+OD=(wd&Qq*mmUYg- z``jHy-<@Xa9i~GgPceNKrYwZ?Bi4)AEL#VeG|T7`3 z=i$UjmyeGQj2|o&UN%!!8P3ye{&;p^yl5-XI9y2L5tW1^4K|x_iVO`#xTgsB6mdO8 z9`_Wf^Mpp*6O@MvGo{27?p%?nY(8^(+ZH#U-o9;o+m?P%^>fqafk-x=%2nVfs>M)4 zWjyP`lLWsAQY8zJW1A#ps|3zLRkqT(Y!blUp`k&e&#t0aC}*ep%jRT%$vhR^XzZzE zbC!`jW9-l7_a5y>FN-OuI>>aj7K3dtYT4Hmy3D;3D2K*b*}*uk$&Gr;DEsHNM!KiAl#Ag(kAoo zPGQCCkU%(y!iry_LbuXIhHJ%|gcTzf2s>Pq#X4Yf27L_Pt2i2VQJl-LN0DQIR&eQG zcFQSw528nZlst6NpzP?r?xMF{GyshgC45j0|1@aCX%QuBK^76 + +static int compare(const void *a, const void *b) +{ + return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b); +} + +void setUp(void) { } +void tearDown(void) { } + +void test_addToTree_single_element(void) +{ + TreeNode *root = NULL; + int value = 10; + int dup = -1; + + root = addToTree(root, &value, sizeof(int), compare, &dup); + + TEST_ASSERT_NOT_NULL(root); + TEST_ASSERT_EQUAL_INT(10, *(int*)root->data); + TEST_ASSERT_EQUAL_INT(0, dup); // neuer Eintrag + + clearTree(root); +} + +void test_addToTree_multiple_elements_and_size(void) +{ + TreeNode *root = NULL; + int values[] = {5, 3, 7, 1, 4}; + int dup = -1; + + for (int i = 0; i < 5; i++) + root = addToTree(root, &values[i], sizeof(int), compare, &dup); + + TEST_ASSERT_EQUAL_UINT(5, treeSize(root)); + + clearTree(root); +} + +void test_addToTree_duplicate_detection(void) +{ + TreeNode *root = NULL; + int val = 42; + int dup; + + root = addToTree(root, &val, sizeof(int), compare, &dup); + TEST_ASSERT_EQUAL(0, dup); + + addToTree(root, &val, sizeof(int), compare, &dup); + TEST_ASSERT_EQUAL(1, dup); + + clearTree(root); +} + +void test_treeSize_empty_tree_detection(void) +{ + TEST_ASSERT_EQUAL_UINT(0, treeSize(NULL)); +} + +void test_nextTreeData_returns_inorder(void) +{ + TreeNode *root = NULL; + int values[] = {5, 3, 7, 2, 4, 6, 8}; + + // Einfügen + for (int i = 0; i < 7; i++) + root = addToTree(root, &values[i], sizeof(int), compare, NULL); + + /* Erwartete Reihenfolge (inorder): 2,3,4,5,6,7,8 */ + int expected[] = {2,3,4,5,6,7,8}; + + int idx = 0; + void *p = nextTreeData(root); // Iterator starten + + while (p != NULL) + { + TEST_ASSERT_EQUAL_INT(expected[idx], *(int*)p); + idx++; + p = nextTreeData(NULL); // Fortsetzen mit NULL + } + + TEST_ASSERT_EQUAL(7, idx); //alle Einträge geprüft + + clearTree(root); +} + +void test_treeSize_returns_correct_size() +{ + TreeNode *root = NULL; + int values[] = {8, 3, 10, 1, 6, 14}; + + // ersten Baum aufbauen + for (int i = 0; i < 6; i++) + root = addToTree(root, &values[i], sizeof(int), compare, NULL); + + TEST_ASSERT_EQUAL_UINT(6, treeSize(root)); + + // Baum löschen + clearTree(root); + root = NULL; + + TEST_ASSERT_EQUAL_UINT(0, treeSize(root)); +} + +int main(void) +{ + UNITY_BEGIN(); + + RUN_TEST(test_addToTree_single_element); + RUN_TEST(test_addToTree_multiple_elements_and_size); + RUN_TEST(test_addToTree_duplicate_detection); + RUN_TEST(test_treeSize_empty_tree_detection); + RUN_TEST(test_nextTreeData_returns_inorder); + RUN_TEST(test_treeSize_returns_correct_size); + + return UNITY_END(); +} diff --git a/doble.exe b/doble.exe new file mode 100644 index 0000000000000000000000000000000000000000..0443f08f7b68f30f8fc91fd0355ac200614472be GIT binary patch literal 81083 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 I*5@n#1AyS~vj6}9 literal 0 HcmV?d00001 diff --git a/doble_initial.exe b/doble_initial.exe new file mode 100644 index 0000000000000000000000000000000000000000..116bd19e0db147ce046c38f69f16c13a4d17e23e GIT binary patch literal 66659 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 z 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 literal 0 HcmV?d00001 diff --git a/highscore.c b/highscore.c new file mode 100644 index 0000000..fe8a458 --- /dev/null +++ b/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/highscore.h b/highscore.h new file mode 100644 index 0000000..7774ae7 --- /dev/null +++ b/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/highscore.o b/highscore.o new file mode 100644 index 0000000000000000000000000000000000000000..297fcd76f72c1eb2cf63738d85aa4b6813c19f42 GIT binary patch literal 8751 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 OUNBnQm)ukP|GxnfV<5Hw literal 0 HcmV?d00001 diff --git a/macos-arm64/libdoble_complete.a b/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/main.c b/main.c new file mode 100644 index 0000000..34163d0 --- /dev/null +++ b/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/main.o b/main.o new file mode 100644 index 0000000000000000000000000000000000000000..18a1854ff67f74b39f2c8cb278bb118b73b18476 GIT binary patch literal 5953 zcmbtYeQX>@6`$R`x!d#k<7~&DrOmpr6Q|U7j^ntgleA9kYtGOVQ^&MvU0v6Adw1L1 z?Ok{GY&XKB$ZgT-6v-AyfT$oKq)LcN@DHN2K-)w~iVC$5f=EQ72+|rAqzdt2)TrUT zncelB9f>~}X=mR2-f!NUuYI$#sTUdvrUzRH8Df%;L~L!*W-`y76bYGt=ete3eg_l^ znR+skQf;-0cPnv>OuZhNv#eX`sXOiSXsv4OD$F9IwoT+({=|h9OnnyVE0Kpv`8mzBMv2mQAVp>@HKUCx zeU@^#m{Xt8OvO<1+I@8-t7o!SvS4af#CD?CBf6%{>sn4z9#gY9%}}gD4vUO-M$X%r0wa;2}NOqC4eYvvi~lpXOR$b*`mf`RCkjVwb?W^LDc zM0psidPZ4LHB&=|vHw%a)2XX}?qp+-GSbE0LQi^WaprM-@28aPGTQF^y zyK0(`GNq5Rxg4mW)cq7439<(=_mb>O6-skCjYvLUI#*D^W!T4DI(TD3FU*zFM5aA; zcf+gOl$gq?NiAE*!P*eID}*4#K)LyW$p>SEM!P5gfn-io&A7Msh}aRb)OoE6*`WhZ zz>N4(km0x%s`O%G2>O$%Lga6FE&OU~Q$xfM{T^7j=&FT3K~2B`6MsgtCrZVfo>XlZ zWL+bo>qul7ZPuNk&Q?qND{_0jrYIei@i1DHe>3dyINaZu9g_sl$R&wjkhes8^&z2I zXn~N~&@A-Ht)Uemv?}c8bSA{t`SQ$W8t?Kw_sEc?YH6 zV|E?0zriCwj1F?|Q0u0_*J#~54Gz+7IZ7MlQ}B%_`b33xVeu&KK1u8IR57BrlZqjZjgiq1n^Hey$C@VC0iUz=BmNwfoh&s82w#YrS?Po93 zj#p{>@&avKph}e9fyzJA-a}aW)3nw96&n2A`?T#8ZRM)lj?lKNG$ik$UC)8bx5VBy z8kFZ>J@qPWd5qRCK+nVg%mD_yNRo_?&dxxXux8M--Hnoze?X9v>ecRr(#H z#e$_T4p>@tz|`gk?^ceLbofe}dqz2-8^<3Rz-r1;oH6fpzGZMzY$p6_zX?eo!lF_i zkk8{5gVf6lFL%S?(Z=u#;&_8!oW2C?O`fZF!==YN&3W#XYwPL6ct;yMm!*luXN6e3 zUy)uAE*!no5`edwr%ynE*E1jM6n4xStJ=hn@7KMUeI~?FvYDG3l$G_9c)$$*`Y;gkiu( zu7iXZA|Lt432@Y8< zUGSv$J*g48%C#|1TJR*i>|!57UY`ZFKD-CG-dw_&;1b^2xrB!>m+tqZ%|1_h*fdDI z2gp|739+1G*n(qmkT?d1tb-LjERxnCobdGVO+qqmgmN&qz_yqKupkOt<~a=7NsCb8 zE47`2^FdhX!14+_+c~I#{ZjQG3*ATp9ya**YBN>;!vZC6Hg&F4{r?IU?be*Ce^)pP zNl>;~s{U_{vZGU(`h21=ZlH0cgot!YSl${^Ojq4 VF|N5zZ@G4FxtDLb#&5mo{}(laBS!!L literal 0 HcmV?d00001 diff --git a/makefile b/makefile new file mode 100644 index 0000000..6fd6185 --- /dev/null +++ b/makefile @@ -0,0 +1,64 @@ +CC = gcc +CFLAGS = -g -Wall + +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) $(CFLAGS) $(LDFLAGS) $^ -o doble + +$(program_obj_files): %.o: %.c + $(CC) -c $(CFLAGS) $^ -o $@ + +# -------------------------- +# Unit Tests +# -------------------------- +unity_src = $(unityfolder)/unity.c + +unitTests: numbersTest stackTest bintreeTest + ./runNumbersTest + ./runStackTest + ./runBintreeTest + +numbersTest: numbers.o bintree.o stack.o numbersTest.c $(unity_src) stack.o + $(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runNumbersTest + +stackTest: stack.o stackTest.c $(unity_src) + $(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runStackTest + +bintreeTest: bintree.o bintreeTest.c $(unity_src) stack.o + $(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runBintreeTest +%.o: %.c + $(CC) -c $(CFLAGS) $< -o $@ + +# -------------------------- +# Clean +# -------------------------- +clean: +ifeq ($(OS),Windows_NT) + del /f *.o doble doble_initial runNumbersTest runStackTest runBintreeTest +else + rm -f *.o doble doble_initial runNumbersTest runStackTest runBintreeTest +endif \ No newline at end of file diff --git a/makefile_linux.variables b/makefile_linux.variables new file mode 100644 index 0000000..6268874 --- /dev/null +++ b/makefile_linux.variables @@ -0,0 +1,2 @@ +LDFLAGS = -lGL -lX11 -lm +BINARIES = ./linux \ No newline at end of file diff --git a/makefile_mac.variables b/makefile_mac.variables new file mode 100644 index 0000000..1c2b240 --- /dev/null +++ b/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/makefile_windows.variables b/makefile_windows.variables new file mode 100644 index 0000000..68f36d4 --- /dev/null +++ b/makefile_windows.variables @@ -0,0 +1,2 @@ +LDFLAGS = -lopengl32 -lgdi32 -lwinmm +BINARIES = ./windows \ No newline at end of file diff --git a/number.md b/number.md new file mode 100644 index 0000000..305e726 --- /dev/null +++ b/number.md @@ -0,0 +1,30 @@ +*createNumbers: -> numbers array gets filled with random entry with only one dublicate + +-> check if len is greater than 2 +-> create new array numbers, use malloc and check if correct +-> set seed for rand() +-> create new TreeNode root +-> add new value to tree using addToTree and rand() +-> addToTree sets isDup to 1, if value already exists +-> if value does not already exist -> add to numbers[] +-> stops at numbers[len -2] +static dublicateRandomEntry: +-> numbers[len-1] is filled with random already existing number +-> numbers[len -1] gets switched with other random entry -> dublicate is placed randwom in entry; without the switch, dublicate would always be at the end + + +getDublicate: + +-> numbers (Zeiger != NULL) und len (min. 2) check +-> define new array numbersCopy +-> copy numbers to numbersCopy + -> simple loop to copy each element from numbers to numbersCopy +-> sort numbersCopy with qsort +-> compare each element of numbersCopy with next element (if numbersCopy[i] == numbersCopy[i+1] -> dublicate was found, because same values are right next to each other) +-> return found dublicate + +compare: + +-> gibt 1 aus, wenn a größer ist +-> gibt -1 aus, wenn b größer ist +-> gibt 0 aus wenn a==b diff --git a/numbers.c b/numbers.c new file mode 100644 index 0000000..8f6bda6 --- /dev/null +++ b/numbers.c @@ -0,0 +1,105 @@ +#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. */ + +static void dublicateRandomEntry (unsigned int *numbers, unsigned int len) +{ + if (numbers && len > 2) + { + unsigned int dubIndx = rand() % (len - 1); + unsigned int copyIndx; + + copyIndx = rand() % len; + + numbers[len - 1] = numbers[dubIndx]; + + //switching last entry with random other entry + unsigned int temp; + temp = numbers[copyIndx]; + numbers[copyIndx] = numbers[len - 1]; + numbers[len - 1] = temp; + } +} + +static int compare(const void *a, const void *b) +{ + return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b); +} + +// 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) +{ + if (len < 2) + return NULL; + + unsigned int *numbers = malloc(sizeof(unsigned int) * len); + + if (!numbers) + return NULL; + + srand(time(NULL)); + + TreeNode *root = NULL; + + unsigned int i = 0; + while (i < len - 1) + { + unsigned int val = (rand() % (2 * len)) + 1; + int isDup = 0; + + root = addToTree(root, &val, sizeof(unsigned int), compare, &isDup); + + if (!isDup) + { + numbers[i++] = val; + } + } + + // Duplicate one random entry + dublicateRandomEntry(numbers, len); + + clearTree(root); //Notwendigkeit muss noch restlichem Code entnommen werden + return numbers; +} + +// 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) +{ + if (!numbers || len < 2) + return 0; + + unsigned int *numbersCopy = malloc(sizeof(unsigned int) * len); + if (!numbersCopy) + return 0; + + for (unsigned int i = 0; i < len; i++) + { + numbersCopy[i] = numbers[i]; + } + + qsort(numbersCopy, len, sizeof(unsigned int), compare); + + unsigned int duplicate = 0; + for (unsigned int i = 0; i < len - 1; i++) + { + if (numbersCopy[i] == numbersCopy[i+1]) + { + duplicate = numbersCopy[i]; + break; + } + } + + free(numbersCopy); + return duplicate; +} diff --git a/numbers.h b/numbers.h new file mode 100644 index 0000000..2315581 --- /dev/null +++ b/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/numbers.o b/numbers.o new file mode 100644 index 0000000000000000000000000000000000000000..5f6471d1031e60edb45bab4c8aaedd3d3c5954cb GIT binary patch literal 5848 zcmcgwYiv}<6`t96 z-rZ}g{_IG1=A1L%dCZx)GjnhJr5Z-%)jGyHCFN$pyfL4bw5rB5#_o497WXUOgC@Yn zo({$%`A8XVJ#vVREeE5y+#%nMxGzjxm4(~&kOQZKd)(^~DSQ399l|@{o>~vL+d1Gd;GXa~RAFyysC&Q}-$g)v z2HXVJ02PX3hz%VW4;McUFWl-07f1cY@#gTt^M2-gVHv#(&o{e#FTDyIVTBi$!%Nj=;`bKoivGpW zZ72BJA}fYgOB!no0lkh5%X~Tb+T!?X(SJ6)aHZ$Tx8(paxG;?lK`r`GH!re*%f6p1 z`(D2$Wx6T5wQ3HB)op))*qv|M(9)(ZpB-Bl*IWF*_MUdN#9IVOkQ6yq*0xU{T)w)VB~?MG&;wkhknlt%T7?C|?U#hMs);EDF~(p+Dx5AZzP-e6ClYc^j<8~b9JtkDZ5l8w#mOJ`!4bR^I<%{FO=8es&be9I%dR&nu)*i0nL zL@s&Sn94KPmQLEwU3z6Ilb#O9s*uhlr_)9}kW2%hi&BpixGHlqnQT7bgt>+6bSpH` zVrnX%oHhFU$j!4`mf%K^fY_HCu98=GrNcGvKb=G=F zK4JmXNTjh4+1^3M^jtQQj~p%7F3d)aY;HI+cZxk$|CGc`XmQ){lXVI?)08!h?;~?4gTQJ@_IQ&5 zq*&EoOhi-xsP`$e7rAl&3t~5cH^j0AfDC&4ugS4BS0rMjNks&NMSmDk$2CNQw(#bcQC%xox~&z@r3tL}ub zVcFy7<#c#=s8p)~dJn0%^s08#9o-11U?!p?>G(XWGeb{lF-(;d)tjOjEpN=uu~w6n z%TTb9dPLdIJf4R=8a6Ynk7@c~8{gv@@Ql>EkV&_XdD?V>iAL)4s4fgrtc6zANQtHp zyDRSGQ zUhg@}J?D6Zw)wuz1ot;#Ic$|9@gi8b^=;&2i(L7)B0aVBT+=-s6+21mOuuq4R#f#) z;Yhs-wxL{{*2%Ey*l2f%0Z&QX7-VwH9t_zOGuEU=Oun0uVy~4(%5X~%(J4VG1E*yM zTFbkv)L=lJc+^`Y4rOQTeg(W8>$qiNFPFD<(uxwn3~J@CniITTw^U zgxK;6u~82Q{~596rf3a{re5I%-*H^DpAr6>q8-eAL9wx$AgwnAf8wO5c~i6`L{ma+ zJ0o@`#Et~8rhQ(~-6!;)3;(p(bU_U46`KwV{Vm}y2+su}2=rs&J0a>`5T1hA)FZVf zM2D%}PAv>l^O}lvuc+B4{3k?>tE)j&?-h+lM8j(oNP~8ALU146TW&TDYMZ2<2c)nL)0Xjk&% z(c~SP?zx)e6-Aj4bCP| zx8m`zw-CLO{RtF#^sp9;L&^5o)Vxjo2$aHIwPlqUrqcMDO+`T|+_!951?2 zY*{do#4e!97k3%fO6hGh#j+uLR5<)uM(m+<8+%+0Z!sHKP^oEU%g@E=|DDAG3RlbsMCNDPJ@~XL-kDtI%rvI_wbT zEbp5vtt?G_;yMA~J~AbgU5($lr=JA3Oeu|6Q^~Yp(YbuqB1t?Y`7C|Iwx2$I+UiQ++%(v_9}CWpBFER=|0}N2 J7jEf8_`k}}?j8UD literal 0 HcmV?d00001 diff --git a/numbersTest.c b/numbersTest.c new file mode 100644 index 0000000..feb7527 --- /dev/null +++ b/numbersTest.c @@ -0,0 +1,93 @@ +#include +#include "numbers.h" +#include "unity.h" +#include "unity_internals.h" + +void test_createNumbers_no_null(void) +{ + unsigned int *arr = createNumbers(10); + TEST_ASSERT_NOT_NULL(arr); + free(arr); +} + +void test_createNumbers_has_exactly_one_duplicate(void) +{ + unsigned int len = 100; + unsigned int *arr = createNumbers(len); + TEST_ASSERT_NOT_NULL(arr); + + unsigned int dup = getDuplicate(arr, len); + TEST_ASSERT_NOT_EQUAL(0, dup); + + int count = 0; + for (unsigned int i = 0; i < len; i++) + { + if (arr[i] == dup) + count++; + } + + TEST_ASSERT_EQUAL(2, count); + + free(arr); +} + +void test_createNumbers_has_correct_value_range(void) +{ + unsigned int len = 10; + unsigned int *arr = createNumbers(len); + TEST_ASSERT_NOT_NULL(arr); + + // Check all numbers are within valid range (1 to 2*len) + for (unsigned int i = 0; i < len; i++) + { + TEST_ASSERT_TRUE(arr[i] >= 1); + TEST_ASSERT_TRUE(arr[i] <= 2 * len); + } + + free(arr); +} + +void test_getDuplicate_returns_correct_value(void) +{ + unsigned int arr[6] = {4, 1, 7, 7, 3, 2}; + unsigned int d = getDuplicate(arr, 6); + TEST_ASSERT_EQUAL_UINT(7, d); +} + +void test_complete_function_of_numbers(void) +{ + unsigned int len = 50; + unsigned int *arr = createNumbers(len); + TEST_ASSERT_NOT_NULL(arr); + + unsigned int d1 = getDuplicate(arr, len); + TEST_ASSERT_NOT_EQUAL(0, d1); + + int count = 0; + + for (unsigned int i = 0; i < len; i++) + { + if (arr[i] == d1) + count++; + } + + TEST_ASSERT_EQUAL(2, count); + + free(arr); +} + +void setUp(void) { } +void tearDown(void) { } + +int main(void) +{ + UNITY_BEGIN(); + + RUN_TEST(test_createNumbers_no_null); + RUN_TEST(test_createNumbers_has_exactly_one_duplicate); + RUN_TEST(test_createNumbers_has_correct_value_range); + RUN_TEST(test_getDuplicate_returns_correct_value); + RUN_TEST(test_complete_function_of_numbers); + + return UNITY_END(); +} \ No newline at end of file diff --git a/runBintreeTest.exe b/runBintreeTest.exe new file mode 100644 index 0000000000000000000000000000000000000000..02da1dedcbc7013dd2f31c04342a2fb757c54555 GIT binary patch literal 105098 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

F+19?lE*Go9i?XSS^kUNA$9VdkOh@K z3m)6urH(|DE}o5A@hs4MeFr6!aTC9gcN;a#lhBF~8%=`N+%~`he**Cz34Q#cSUluDZ0mY&( zVh+VkO4bvKg9qdFT+D03CG8CVl{|w`IEv~Fzo^H#jNXf=uFx4!C4k$()PcTCGs84@ zTP-yRtfgg}gK1Sf8}w*1QbcF?Phb~3BvUw-PNXPD(SN`x?J}6W6fm6&C-B_1UdktasmkPY#+);zczqJ$10AQ8yck`-*E z!iLVQD=$H0WPK`cP~EL@{q~76QSX~bjU)pXwwI5-&>IbyT73_UpbEbJ6(^JyGtS+n z)>dLfq!E|&H)ozE5_Fj-^dG5E5e5QK!+#tH?ahLf97l*%DzO?ZS-m?Kgk{Gef0#IL zJb{*Rz1OnsJr*EZE76XVv`>ImdRgfZ`%+0UF+%~%biEg_kauly4Zyh#EQV)$jlA+* zU6|+*H|K##^vjinaYjs{RzN0Aj&IzeR*?}R9YvCEzz=fnAK(h=hbH0WNYaZcAn93B z(xix_edW>PK|hUFm}v4$ODWSiGSks?;%=O22wHS%<(15XO;pNA$}mf2cn}%%L1duu zP6*#mO3aeNM>R>01-ZIh?~z~Ya)sl0a7+aKW*$3E6G9BgJx|i2oH)IOYQjB2D$?9E zq&g2Qq+eZg#30;*UO{~@qAjuk7>Trjo4(}QGT6YR^{B^E5Kt*^pBrTZHN4P>4Ooaa zOVU0D+W#&aK*uuFgeo6iW{cRsSD5h{YSk`!l?>o%9N|0XlfKmUa#0UIS{k;{K(-)JQ85pFhlGV0!xfV#AH1m2_k5tHYhTh5Jj7Pi)>Aw@6NLENQA zlt4U|2qh3Gl#oGHASH0Du7p&o4OhZxL_kX51iBI!5pX4ZkrPqE2Y`hVdH~5xQA)^w z2}W1SFDiVF%Z^#1?K(GV9bHS_o~R{F;d<<}iSZEXwsTv`ZUnYn?f5-#Hh#jjR3_a1 z_8sFWn7lm+64;^n5)#o%X?g{-NK#(Gg@nu|q+YqHgyfYwosiQ-3nx)3Z(%baVy!pr zdPS2VoQ(`LD56a}!(NCL-Q-b~abT~7hEq;k58A$&2Vm1Id_TB|qV593D{fOd&|;X4 z*|BE$^c23_6a*_+4=Tg9jyf=#c&!8n_m`K8fgCcCH;Y!V$P3?(TCl!kF~jQSivgwE zt#okHqUr(-RsrxINZ5RoYd}v5cDkQ@@da_YF@OE?9e3vkW_QrYXGW(x_&$$NeeHT#-Q+-PR zookR*dRQbux<7pY&MiGQ@I_Bc*f9nstxGZ&lJwECwxwf{kZm$jnzs$I9lsc=cv>Fp zN8OuAOl?t^3ylo8r=mI0uG3{Cg>R@GfS1C$Aq%C97ft+of=3)69~gcNu>0kW1GG?S z*>-&L_Qzw&T=$u6w9EdP%}zg~T_>w-A9vW!b)DQaS+sE@7!dX(ev&?i)!8oTj1bOo zoxJ)?o&^velYa&hvQPilgM+<4wD2*x%2wAAUX4u?2v5UsNYWG$%~k`=-!P^v#X}!4 zC#aTWGl;AhWcoU;A627;bB7FR>P%9ql_Vgfw_Sg?OesbR$@^a41Q6s?HPmdLwp!Gq zWn=${kQ$F9s>f%xnYisqlR3%SPGYwCIg$50$~(f4_dVoQkcjfq4u57_o&R1)J&30< z8YA1eotvNIcpzQK4*m9~p(}*cI|bPhl!u(e;oMH!^|UgfLVgG=QTOnIh3?yU+FB{J zi-cYo%|yL|ldRSmZaydk?;)NS3nb6q)8dkXe`Z_j>Itb<11FLia`7eyl1tqeAQo|) z#c0=?5<9B{CW^{ZE%FCs;u;}g-waH=g5BsOO1DCEK<86N_3-6XIidYGNrNG^4M~}< zfooroJXTW?P?n6Y>iEnytAm#32RlEQtaQITz;}d>xAZ8msA*E&uH&EC)LdW=05F%`NQ?9V1-nSwFJJZ#F?Fh^W zzdRar9qStzQa{8HPMcP)VkU{QR$ zW#cjMJ;t`r3FU*X(_Pac=)w+E7tIQYE#t{Y3$j(;NFw&N_Y2bmVTj%~lKZ>E3(BM!_#;o)nSpt2joP+Qo2 zm+kRfl|~5k>Pkw-j@FKDQkkvwDG(pm$haaK|diWef4K?fk zjtUvBX2?IB;`{lUVh^NLw%^g0GE^<@T`X(y4vkjp^hpyRLA4!0a$>*u0$Z}@ll)gA z3*0W&s-5BYFvAw9Wjs}V^?Kp+nsxFeKnyWDyF=>zL`!>XV6=;-VQuPW%w#F*)U$ts zGGnuc)L&3m?m|QAtpwA8JE-0Wu+Ih7Hwb(Hi}mEo2o9;|Q2^Fwh?1$ ze?ydrULvADml@9ldDQ8oZ<{bVrK(tnJKaCTK$xR~QSY44^G z%|4m03aDX(%*9q9O1McN}UDJ4~y!9in>PN`X0$(?LzF(w=df`X?!j zkAx9>hT*4y+K*9?^_`DQDJ+ty8w)#R`kl;_Zpd__o=I%dM6GsEqG<7mbn4a?)CC&_ zm@%sX0sF}!t^)idl@2L^T5$)S33fxY6!&~cE~i*qk$|~tXZQjk(J?%Lqv*Y#QZ>XQ z1B&OM%Yx@oiQXa5dSgu^w5)X(aq3dvx=uVFMXvV&8YJnsoh13EYFGCnn^v(s0_GLF zE1KO^oE=K%&E(&#$x(~h6bhdpMSkHE+Uif|bg0m~RD(7(USfZ)W4XyZ%j+i^_)Fr` zrH(?WT$^p`Y0(1o-}c?=)4elNpBDto>vI^eK|S|zcBj^75B9tu@rq*6LMQv9>eD0Y zvq)m!(y_cg2MzT(Th!+Ql&X+*w5iLZ1#k>eAF;lHtD#;@8~So{1%~xibEI0I3z%2y z6TpUQJ%6jTKhc{;qx-sY zlh~$Cxmf7w&mWVXGJxfp=p)5Y(Zqxt-~>tcQ=%gT6-V~q4vDxL2<#nO z1C%&bCi?W^;F&wa*P=KSO^*=5KPSPu)Mt0-ivJ@(gNh!!MKh$Bl^Xf@Qx)Hg+*<#* zR=`~GTcWvM%(-gz6c|SFnJ#fDMHl!7j@nrjvNsumX~CTRkk?>PlIMG}J*8 zx|y`urQQi9vYYOW=C_se)7sV6T4lo1QZhAq+9X{!o|4K3VUu8dwC{5^sK7QW!Zt6O z?G!2IfYsKz7u^aAeXH$;-v~(YCn9e0=k-1ydK_&K(&m(#9(AINMWQ_+7c{jFea7zI z=?f1M{Z3yGg-{(;srO!u#}nZ3`v?y`8p{KjIS+*3fts+s%eeyZyhsW_kB)+_9-ys+ zzJSn3x=X`LIKnw;Kc?o`O1%JX6U4ekRJv?F&IKB>pn`UaxBMh?^{14=M&o`;3` zQK|^mT%A2;==><{k?`FYETB*#?e84rtVP&^IB)lEF@uTY&p127>3zHloP#Hf{Imd^ z#RFstZR#2is*LC;qTpVPKmVA1jAQd8w*LbS+e5_hgq2PwlV*@zYSA^i8Lb9rFw1#2 z3$x5p0`atxQlKv$q>yX%kHe;ZThSm+JJ7kAzhQFHr_j({q%S7YX$4DrD)}k+DRaOI z_&$h&tuwL5aRIsxPx=UtBt+6Vw3fx5LyGOrj+TC`cV*mx_}uQ+4*v)~aq2z5)hie> zFog0aXx#e24RJ~NeNfUe+ChtBlEkpZlPuTQ_N0jgF&jJQy6l@cnzn|L=y|r>_kk9$ zM}+;HATK5`TZ_-oD&eP%7TVCjHaV{a#Euv9J$>pHapYNCP2|aG?v{%o6fFdYf`-Dt zL{GPAy5R~FPrgG%yD$QR*{HW}g(1jU-uDH}olFR@p*1VNCt4HFsmaM?kU3O{slg}o zfDq9`VQwAV4$q*8XO}t;Or(=p9L;YW=NEFl$5k;0OI+T5wpQxFTJi=YqapMHKgDDU zw%aTVEH)JQFv-%Tc5cxNd>){o0zVE>1-MccyBxOG@1q=eHF&gqjNyEFkP`7~%h8We z@>H;_i?G}r&9aEIlm_;mXl+t%lFg&H_ItfJyiHSxeju#4)iFS7yEi>DbC1Z}Lz!Q> zNY6~&n%d27$WOaqt6a#qy@RXnCCrMc2i*-b1sQLc=V@}#rZPMlrG}aLK6!yOqZhch zms6~C3koYJsEiQfJg2}ZAb*a;e(-mW4NI(ru+rbmrxxi_S8UeRUINgd_E|USUO>gO zg?c?vU~yXGb+7HeWpoonHK>XOyxhY5hYf} zk#S?)DdPsr<0rf%R|mj{1$Y?XF9p~Q@TUSi3bTh6XWfPh< zttD)tL)14sg~YxLbaJknx2I{-0Wku@%O1g|{HEwZl%{S2y>}p|mhVA5-)QNW?L+11 z^Jy8LLk2kC+v#v4aqGKC!>rL*`A^f5?&ieU?xEfzPs;H5<3Qgy%=pA3nKpHOF4>T) zqaChg0CU8!trcS>`F006^N)l-+LJ9Tt>C}V^!$hTuK_MW3b)8x^e!S0$PgPF4V<4 z=I@1Xn=LCoxrbNQPE%ggccD;Ap;M?$0oJgjCoMr~OC2zph!cVp?|`$YQM%L| zNFZIK2cSW3)3ImvUACrFQ3viA6#;X-eN!LB?$zsv9oJT-E2ZfS4xNKGG%D=?^7Ng~ zm39u)YDC=&6f|}x1+f}yqghp(`gNAj$%k)gwYHPSUZz^Nsgor3B^}G{=P`jDA+f*I zv0P)f8#H!;O6gKZLjtL>2>=Zm`)uc_8Y|M4&e1d7kSi;8>HKsZuNl`PofbeXxgLK5 z*igvLyb$;m!>qQA9BZ3;hF1T-A}VJ)E+O<9Fp)z0qWN9G`Eix=NoJe*+a{Usz&1(y z1)zd1)Ck*A(QMyuCSC9abL*d&wsam18IYzeoy&VkD6R_}#PH7~DI%+8T0}b{QCi1R z6?)IaucQ<{Od}LAo$d<|$MDuy(;|x=r939$eGosK_Y=(a1l$l`$vbRXOsBiY$a^y7 z5Q}ZjH)h>U^Ozj(tF4{|GF`VdL5&n|ciLFBbWK zN)*UTbwU0^Z*c7U5__|b?IG+>2rGNrYa~aP`q347Z~GFUq4#!UgNeF@Ti;>8G@mva z97F6d{0{4+Q+61P{zR@XT2Ka*%00&p0dvoBO?26%ylnAct&%^4@n0?{s(pBpjMX=u zP%7QF$7#8bHD(G9-J|j6RNFMGYsE&_EN8TYdMxL@vBUQ=?L^CFl$bP4my-nQ<(4f|>*J_?O zGFik}DxMD+Ch@C9sa#WKQUZEDba6DhnVg-_RIL!-_uVzsU#)5CBK@eTqv=AUhDkwB z#A@t6`p$^b7-{_h$&1V&q~3!VDeYp--fp8wkvQa!B)d}_^uL+ZCDrO8wRWj%Bp=k( z2hgCp3$O(iJI_Y1iB_GgygZAe&-~=WeMrWHWL&W)HwY<7u>*h&g}r>WFn{B|Z?_nL z*JdIYx>NdV5#ev7*-V%EBQPP;1HXOI{C0AFRCPGH6kF?UARB()cRKU}?a>a2C&IEU zn&liRVus?ka>iH_(5$v?+_Mk?J`BDb$JpSSF*vkr%TVY|5hI%VkU;mNIs2KP`dXNs z(%0yuvfkI|wUbC+`+1dSK}#cjP0$N0FuezeFd@I zT8=3pHr|y@6QIuBi-gjD`=8_z2T1>mj*|Z2>xm)adkiz60ptaHo5sFPO#x_V-%qgH z1owt>H{eFoiR(IPr-bj4Mz%?!%!_vaP!?utD4&$e^__+zH<11zAD5n+)lUS>J==YN z4aHt9ip9a3$WGr@Oyp3*cv-{O|4h{qDwr#(;RX|FRu@O}n<@E8Gv!0f48iY-g+gON z1Hbc#i?DqdprP6= zoGpALERoNoz-Is^g`l4sldZK!m@Kcs1~JI}W`U?d*PqA`(v(e8pr#vT;;)d%$Hrs& z?)zDsigr%nI0weB?ax~T#Z%`A#&w_&k}%B3o^+B3Fr;myu{QNSN#zz)B&d<< z5`$iYByg9yw?fzJLjVm5xDLBc&?`UGOh>vfUi1C=Fx0o}V_06xwk#IVx-nMy$2j^J zp`Qgh+A!hsg4!|AmH{hfB?HzS%duAX$G6})PjVlB-{wYj8d?DrnS`J(lbWt7sMv>__wH?Q92sVg;Aac z`gXZt9Z6M)OPBf&FXI=$M5NFK(7KL81ga6x6afb#*-l2l0}=3X32Ftys)ZI4#-W5Z zbOb^f# zrttUM$@8mTN^PTe+UQlaA(B^(TP`ZISO@jHTt zTY43D+r)$J8Q9$P9~_|X9t@6kxAa-vnV$td$E)4j2g!o*Cf?d!^FjW8`rMAF4??iq zwk##sxuRvsL40zdBhcUXlW2TMy%ef|*l~EfJQojs)n$lNC+jT-^Y*zN(Qk~moG|+n zae6gg%HR9Q2pofse1k%(k2-$=R{a?!e_R*;v`NbelYeZ>3B|um$cxgNQ3%vC=|~0z z3l36{`I-N1E{8j0CS{t)(;wpX{ZMAq-jnCGo*i9!)hY6FdA8VQ_@`yrW?Vb1DAzV4 zciOs^%sAT(FQWJm6rB7NSxJTEI!vtwdm?h}or~nqRn|{)ZFZ;QQ=5Hj3VyD#i?`sW zj%Ey)(Ye#o^Maq`1&@Ae8-49GTGasXPji582Ka^_v7ztT(op`~4qF#VaE5a*CIbCA3X?jNs+eaPs2y&!EpY zta1ncz(x1qn+fYYcpbNzUL;3y?zFUUsU4MVOMVggsqcM0it6s4mL@8@kg&nO0F#GL zHrxed_{T_UuWA>c87XpCEV%x1*wGg##CG#(upgNJ7Nof59)aV-BP#ig5>JSEG7mN4 zEvh1GsMwmPbR%lJ?k2Q_v!xTSm3E{#Gd~F&bq8M$??vOn2;9LgTkGG+Rzm7@utb-5 z+}-)E*{y(Ti=zt|$n#htTJw^TPX56YyhRS*r+&GHsPVEqUOrAq8BBg@BWGx9-G&_a zU_@?P(aDx~zV=(&iaJ`}`F&tai~4(Hp_f~W@Wm1O-U228&iz>+7w_7K@Dg*bEw{rR zDxH?$Hcz@8HQ>m%Y z@3?SDKL9>-30{}ZO-TtCfC_mwAPwpcUx;YCp>si=GVKE|Lh){Ti#IE@Kn1g1U*I*U zHlG!eYoAKF{7{$r_sc|o4!@iLu6McHEX}x|g;~Ov_4J1)jHG$#^h4D0p-C@LFyomn z^)Y0li%cgSBiSQ}dxF?2I*K=U;VB?3is=HGw5o^mf~> zmjR;(<80>Ai^1CYJ5+wqllgArwY^1TrY$FM%;q(4X*prH?YaikPTLbM=G@uSfx@eH zb!?4uCt)5j=$X;&Q4YJv99#o|6!%j4+L`V9mlOY`tQp$<-o=1DZQBMs!QOD?H}nP| z5+L*mN;rco8iJtgrmJ&9Io90J*w955Cq4m@r<`ax;m8k-@U+d!w6(sDOt$N(gSDK< zvh8{w!sUfrOb8$a<3c3BIBmf7j(qV~r(a4yBCK;D2p zGO;ZN1~(@#FooBCHd>a);d3!Pi=zgK-{8Tf86zMAyF3OP?3v z{xUQc-xk^R5lTfP1iKQivD$Vu07)YCUdpMOfn-k9MAiYiO>!TgL~0Xv!r^EYPxNH= z+rIw|(C!1k@8Cq4hix~1fFw=L-+WD#wNQ#s^RHn|y|)?4!(%tCz*ftI&qKR)NhfoO~GfC;xPe8m-fsAwT~F0=}06e^fdx%{HTSS~>=c z+-X^2FJ{%Ds&;oUDGzyj{cvZ*l3vw!xI?2u_}IuFf}K0DIWp+j`BhHNatF?afalUX z@b$FK%a?`_Y${hVPFzTD)?Eo_zK-e=Gp@~jMSMNy82MKIU8f76Su*5Z3IQSYgG+ea z?}7`4BXnHm9_)#X?@LvbV{82hO5QwwDf(A);1A*e8Ic}p|03IhUcUiS_Jz5>>)<@# zN?VZy;-X`8_+MN)2|-{tq#@f0uhpg5gD6SU+6WdLIoREIZ=`%p{#ja%U0ERHD*;il zu|V`*fiy8s06jFx!Y9f3(XwtP=RS_O6JoHt7oH^2|2PvQrs-UH_NS4(mokZxxX=$# z8ucAR>9->-d>Cr!eINFO_S3(_^$6@;k&h|%$yLY|eU+50ap30M! z9XcsuZoz?)#jmCL`4;M74&virZ42fgQ!s-{Nv;4h zSi{LO1i??-!AYNTC^SD55R@_>i!w? z-@yBLN34{p=l^SXBAU7H)rftD)K@qvP!&=S1A@r~o36rXYt%a`y#voYu2k?D;x9akNO$~AlCO<|w(vd?t zreOlPewjWKdF+_a$+#-w?d@;88$JKW`eJ7$K7(d+S6qzGpuM~^lRksyw`%iw!f#DU zG}&(JKvEX`j}v5_xwa>qak$4-(Fop_tEBknIq@|qOw@v&HqYTS%|GOZvM@v+^aMK_ zt!6hS{?9ii(xlLnc{uPc79;Yzc9>_s6mEwvLZ7y7#{19eXK9!&&==bL<1o4gF-xHZ zg7)gpd4;Rr(m2>A7D)3`W zZ?eX@XS|%(mdjFHh{Taf{O38bONIUBTcC~Zw1_V{>vU)q!`JEj3Bkj%{#CMg+Y|0Mk=V+O48~7yA3=VIOzoNn1|H?$&hw+&wQA?p zBz`{{G8+w@6#Xn0E9aHUYG-NX|{vzvahaVH9BmSq|w2Va);z42{j3zYnNYbC0 zN#(zy%kL(8k!F?P4t5K_A*{-6%f&88_o0Y>p#QJV`k&E1RPK(0{?QIaREZ;bZKd`U z|7*@RC-iS=hW-ym=|3Cx2>o|J|Jl%gXX8kB%fYm~%$K=6hO(!9+1(kQtl7UOG^qyi zVA%tOE+&h}ugF=FuN>7ZVw8u}uYa>qvx{D5sF|ieFom}uVo{tX-z!4CBd)gW!9vJa z&{i5P-wMcgI6ru}F(DTMdNMn(xZ(o75_ktE&7dQEye-YMmCmmU7oAHt+z$CLE&2Y=GeuQ0Pj!~$PzLBqE1#53aN9s9}u zK1uI~+g#n0tY7;H4SolA;u+WAju~9{I<{S|N3me}0|q`%uq%8GlnOOq-AW5se916) zEk0tnjpjP|3LOxe0t_wcdbA>%e@9FlAJdL1zyDX!@hE2hj{LW4 zz~S1`;H&WaDjfy&b+Ze~JRW9D^3Qf%6)3MYq?Hzzxg3|2H#wF$JtZzy7udMo*Vt6* zYx2*jV15MNibh|#-&Y_I-nx2kU7)sB6MP7Y>hdP9Z%cWFzjmv)zRu^Z3^df%RDcEL z8HT>1zOfNvdpDKW27KPe^12P2TGDUu`ExZU-bSB4&{)^xjmjeV)^BX6_4$3?sz6hd~~QBp{Jt*@ym3R&Oi@R8;TuQLN6>FLAzQFw=|*0<4D=XWqi_Ex`7&*RAV zZLDwH>d3EY+F0(dsKypY)a6)78f-%A`yH3m_^atN{k~d%xkFMpR@Vm{&ZaA2Ao)H= zX}u!{IxBDVQ3eoinB};nx~8I<*S)B|rp`|_F%%NfPXl3nPyts6*CEPqI4k^AO%1yl zmc?--5b$|*RW)@r{;g6RR^Z!E?yuS8bLfbI@&X`p(Tt57YwD!gXynKb6RD|mEUT?A z_d7}(%WM2Pj({>^?kK6QZ=|NFbd&@d8UQh;@3-4YhahDi2Gn)92O) zz|2tuo2_Yrokenp@)w>rdwq?6sKNyvwJWcwb(HwaE3O=hDkA0Vp)cm39@+%!SO!Lc zMzpxdpY5o~u^@tpFh7Y7GRaleWC819p}U%;IYy=9W@)vH~3~Z!8^mynZvQNrjdI1#Q`7O z5M_q!RcM3hm5%lBR80=_%W|CyXNn&^Ur}SdAH1}jo8hAz75FD2j`S_lw-B9H_l724 zpt2q+!vBGQi$EvCKO*thSJc-!(1yI%O|P6Ir2h7N)D@d*uJ%Dhot~sc@~MSDdepr> z;HTE-Ml#FcFK@&UME+rV!z{_83t!g?Cb>y}?Ko1&Hc|Lt6X z9x}r*cfp)_bJ8`P5@JQO(xnLFokQ+hdltM(771x37En+mcS+eQ#kEH#_j@4 z;hHSQ9so??%})GVDZmuI`rjXv}{xe_-?_a@K4`2!x=QDN;Foloe z9so??OSsvOMM#SYD_{yoVUjxzFoj!iI{;HSz6g2%%tOE#fM+563GOVw6mGs4_5ipU z;gh&a0e2vrSB!c9&O+$LT@830!V28AfZ-R|F5C@(+Yy>epew+3gky0x1I8G_Qc7Vn z1S8yzdk^4dgzuEWP5}2Kylyq@1aLdTKjMA?a5us?asL@G#wPZ|%U~yf_ad~fK^kBR zcjE2`+>S8ya@Yyrbc9pZLO%~ceuM?M?SP9AuEm`KcpbtD+z!AE2>0Ng26!*Re%xt* zDctUb&Hy(fWb4q608_XKcNX9*gpc9Q1>Aw~3*2s^DaR8=+#bO6J?NF|Q9j_k2>*_| z6mUO6wSuu#fb9r#aIXPegzz@p)kKeQA8tQj>`}4b;@$!n`%~;w+}8r8fAr?X-3l1~ zpM8$|HcJ2h(50X*iamkZ?;n|-xNby4LXov2uG`XM>Srv$qA*J~+8y;Kx<8L)?0wv1 zHx$O=k0UL9oWN7ac@uxSt!C9)Y%we78;ZrG62#MPk!gf){0{IuNt0-qo@kECHl<5G z8t>uC(efGb1m9vP)5yb^uECnzT1ffl8S)$9VnezSHqsbjBh7b#e`VlrC&Wr@`m7WWRUn(`3cdI`r{So|&KbkjPeK}jCrN;ccClRdU0 zzFX}v_oE+Bx%bPmR1;I@De20HI5uKlT)Mi>(qJw!btuGVp5$YcL!;MZ*FvrT@;_!>6ij6m%d!Y=l(0stm1#YdFG&7<{U6Xke@CQ{)-KF_4`Q6{jHKO# zH2WcprG~U_q&bk*Y)CtfG&j=P4QUe(BOlWC8qz#St47*kL)t#1wIeMHWouUt(yY&5 z4q-^M9>H7-X*U|u(ven#w7U#xYml}MX+vGjGW{+YJ}Scw8NMmQ<1!rctl%<1hG{Z9 zUxr#4D`Mi8%J>yB^vm$t7`p3Y;(KD^kIMLA8TQEVgBZHwGH!ZKNMx7c1R0(u!)zI@ zkYTM1ua)7AGQ2~E`(@Z6!^1Mv>ivq0zbC`vGBm*+=$a@)5o7Eu8JGVtN=s(v$I#`< zxJQPiG5CMCqfp)d?d_PR;Bgb4-Q-~B9lPeWC34@mKylI2qS#~>G%fe}J>^Y)7j5J- zcBeTHPjIjUkNw(M;?K<;ah`8Ip$ zpI)=m8LG$sNAUz!)#&pvb_S!Z{rU>}=f`+Fi6>nf{MC3+SV=qBwLVHE7J()_*%G_? z*oQ${j<*TVZ0RY3SJVM|n1*ybUu&$XYeF(|U9qvjhyC#-mfHHd4T!J{EgO9sD;l=a z|H|f)da+B5vg0DLO^lreNqk%AA=&AgOn6%4tt*GRH&YJKOa`XW@5Q4wB1FkNT)-fJ z))ZO>sSSF7gteT|NO?np*T1#F$1+3?dT_@wBe2)URtU-(@$k-z2ae?%=>cD)zL&7_ z^>|LlRxu%M6{9CFcv8*Vp`7Hasb9|@>@t(6VMYB$-Vn?z;#DGML9EGNSyPWD070F1 zQ&j`h=&xeGW(@&6GA(ap`&g5|v6eo9@(4k770~Ae%uCNh7M{l@v8$R$mdOnJ|CLxT zvnBy_z)HTueUYoUz~z}gZ%(CnPCgEK${T8CZ)}>qxu$M5>N4A)$Jw=WXV0CTE{W4X zYrJFfRr|^tqB1NwmAA0AC@PGpr_zxPMp0FQ#(2k+4J~ehjYMT(Taf2pxnp?C#~{(X zzX#s2cT7Is(8gSQk%#V6=wJdHjD!q(DW}qr1w>ID290*d@C^8CYVmk6iX2@3ef?Vl z{|{=Q0ehTO{N8nY8}>HuZQl#H8U3Gv2lhU&?}0}j*#AKHgFO%SKgjmk_c`{Z@5|a( zv~S(MhJDTZ+V}0<_vpTkeck(d_Vw>$57{4bJe2-W)$^!|C7tR(XoC^C;xUvlvc)_Pn7B5d806qS3EgFX)FMXA{B3#5#5Qp}GFw zo7#z%RIxitH5j?Ppv;joZ@zqx?3lgLAE@&!#lbn>JVeSHE2@{);Xp-QxnuSQHp#qv zyl9jW$UBtXn3Om^ds68zh1btaQ)e}S)MSmPIVq0J;3t6j>V`UBB~GY-z^X+DeCQE!&SxLQ=s95zxE~?3DspMz1 zKySghpK|24^C`4LrdxiEe50%;lPV{ zQ9$|4NoGp0@+HNy%3lC0oQG9RN|!72&mnk{g1IRZKO`O-Q&HPNeiajX>0dGjkE|xx~yW=DbzP8X_a*vT@V`O#OU}Hc|cy66qCP zg?^ZYqRDazWO+^*O=90eXtEMEp3k8zl?vD32;-SfmOqLLz%yjt*QZhWxRgDsVUTbg zc++wYfu`Loj%Mxo%Xnk&wwmSP&YXIzgNnzlCLe-*zqm~P~tO=FlM6r)caLQY>X7W)?9(6 z;z?s=QnlId!}4o_jFK6aKvr^M^uofw;>4C9-%0R^9n5;D>e7kDODAUj-{-_)UDUte zoy^pj3EVN*O^KP1KaTqqQ&Iv&SX`ZN3tZYL`(nhbEXiuN0f^@ZOL;DnO{BzlG)tVV z288B1{EVV9t^=UxKg@gs;l?X@EOG4DNK7!NKPoK8OlE6ssBd7V@goT}o*W1P%<8Aq z)8nb)vm&Vtfu?F^8pDa*TC&2mGnzX@QIKh3T)Bp2R=IVe&KpC7t%M*zXn?z`G28*i zJ*(L7(y(l-bZ&8QZbbeo!f@&let6vy42!I86pcMHfxSwCjo>ce|k+FON!8{{ras;(K={T20nx$MXIBvtUhxP0~ z*0V1?Q)X9rvliP#bd@R^Z>5Z{OB^9(!0`rtsTBd7&c~?i8Y{9?!_P;C6UCND$y#UI z0MY1D_6VtMlV!0MZn?I(WM!t^7?>e8SDEbs>hz}Fc8m047BSAR8+Qi4C@BT3_8dipFI&S~tq{!=lxDje6w~_*Bt^dN@$b|eOaL3Mh z3&Bs3Zbcb(GNi;#hLj;ELyDLTA>dOdnvN(jQynFCmZRvi97UVuDABVV-G$g`a5eLm zNJ`)Xt(m)!QTDTdu(A%^9!d zvXie+ri`RG4v+B++8D3wnMpm3ikWhT%n) znbYlBmBF0Dp-^DX>PXDeircD|?VpnNB~y1g#{__HC#E z%|cV0g6_`I660*b!yrF@C$9{yUc6+-Ob?jiE+onw#EAcJmK>r1{nXrfk<9m+;;yC4 zw^L^R6O(yl)Y@yrC^G3EQ4an?F&6&{6{5R*`l63=5BRaMy!Q0c5i<>#l3yi+&Yq2o zUK+*QJ_nv|MR29xarE8}Q;NAm!LeKJu^$71E@e-WA8XiLy!^t7a6XqK;VStBBp!s7 zHLyaQ;*G&1;LQ`fs`za$0A}JGFwga>&hH%+gCVUb7mp#)OuH-1creD6j3t>(yRnj- z%Py3tQY>BY$_&d+AS*EKt{pK|N}=sFVFj0an&5*mL`Y;*^)Rn4&cm5yF4tAMTub91 z7fEv77y_}xGgq<&Qjl7fOoikFF`gWrDvOHJJ)W$^ydo*zs+@vT(!8{%_0s-8rI8k< z$r7r0+0&&K){QtQvoy*qsOSt?(ORvdr3ps>H=<<7cj}4PJMvEF0~ZGlNvDSl@)LO#K%|>Mzh= zEik9poy?8kH&Tw&W*VtS4m(nhj2)>*4mnbf6eG2n>=Up)e;gSzQcv@ixJp;#7kTl@ zo3nK8ybNYHHKfucZ#upH#!OeGQ3L}dnO7pZeF6arn-H6?Q6)by!Mh^6bTz&Y5;%j1 zQQWCR`2;+&_O1_9u_I&4Ky%g<{Mf5B);3gL+o&6<%@fQG#4LKUFuD@uL2Jet!N}M- zhxtCrXq+b`Mdk?^?8lP`Z+-?phIEWT4@|lZ+zn|Md44j9`WjB-=?IMP8SFnM-4d08 z+z(EoZ8n)3M992v5;cW+j!93CnyEx+F^q|silK0tsUV|yVW;<|(I9qWLlWoNW~YTI}Se7r4Z-zsm z!0h30C@*(798GVA#EI$6kf_M?M%qX8^psC;=;@A`nwYnCuTl+PB$>G`E^~UkrG+@H zDw= zi}Okf3%sSQUorm`QkqG=83t?jmKHnnN|~6An?F-VU5_D5^5osYn^)o`=6JLDR0Jhz zwTq%Ia4qLKv|2`x5~0;Hf2;YR&O9~~Y z34!D*@@%R|P3NiNMfoPIWjJYuu>hLi`YPFUfyy$XM7BzHmcY5saniY^Wptp4nP-`j zXmx2XVm3ZcX6dHMcFb<9G;9?@L9>`S7lFW*_!|qaWF_XYgwd0V%A1;4X-p!YaF@j- z3Q^d~m}H!!9T4;Qf2r()o0E
|BwQ^Odw}dGb<@63Fa)hW6SH7o**X) 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 literal 0 HcmV?d00001 diff --git a/stack.c b/stack.c new file mode 100644 index 0000000..2bc5825 --- /dev/null +++ b/stack.c @@ -0,0 +1,61 @@ +#include +#include "stack.h" + +//DONE: 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) +{ + // ,-→ Wenn keine Daten angegeben wird die Liste unverändert zurückgegeben + if (data != NULL) + { + StackNode *newNode; + newNode = (StackNode *)malloc(sizeof(StackNode)); + newNode->data = data; + + // ,-→ bedeutet Liste war leer - das neue Element hat keinen Nachfolger (next = NULL) + if (stack == NULL) { + newNode->next = NULL; + } else { + newNode->next = stack; + } + stack = newNode; + } + + return stack; +} + +// 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) +{ + if(stack != NULL) + { + StackNode *nextNode = stack->next; + free(stack); + stack = nextNode; + } + return stack; +} + +// Returns the data of the top element. +void *top(StackNode *stack) +{ + if (stack != NULL) { + return stack->data; + } else { + return NULL; + } +} + +// Clears stack and releases all memory. +void clearStack(StackNode *stack) +{ + while (stack != NULL) { + stack = pop(stack); + } +} diff --git a/stack.h b/stack.h new file mode 100644 index 0000000..641b400 --- /dev/null +++ b/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 + +//DONE: passenden Datentyp als struct anlegen +typedef struct Node +{ + void *data; + struct Node* 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/stack.o b/stack.o new file mode 100644 index 0000000000000000000000000000000000000000..7a4f93ff1e21a8d2ca32114bb78d1546071a28de GIT binary patch literal 3927 zcmcgv-D@0G6hC)o@9w0tn{1MrCbl(`kbY@*H{GUb8g08Kso7Loq7syn8uw$8-F7n@ z_M?fRf)FiD+lNGa5G*u*fS_+yBKT2lL3|QK@kOKvO8cNtq);%PbMMUTPSU)3;NE*a ze&?L~J$Evff!+`iYa<5|RAvv3Up7aE8j z=yd^4GJpr%rNVfKJ4l(TMA9)oKqt-}5zULh^&AqiUEM&&L|m_hLssGr9kwB&^u@)O~k!W2XN8qAGyRKJ}{P8{5`R7zdNyb zDwJ3pYfUV?)e7Z-&q8Sb0}CV;PdrRqrGm!A5ZXgfsTZ0%agq35z_Me2QC0AZCqmdF z_?zytw_GX6y{rr4)wpT}N5`*ZGD@`3nffLi>!c&x<1`*{V(ZlXdom}6y0W&mCc=o$ z{<*Y-9nsI;T0&x~!qu0(3d4zW@m>!ntN!LZWsB3++2U-CdPc}Y_f>a{rQ49rHiU!mU2_3kV>0U?hT>cWGih_f54BOVl!ZkqbgZWL75 zqIw^pQhTMGOrIA{o(6?9fyts_fbuO1y@Wt6T!Yiee7=wdfLB_s>bI8!NQfoUSDg>#~_>ms6Ncf3i= zCe!v&pFPW}Z=2;YP|Ywa=if;HtP3>ln5N)<@^Db<`#adP+7WG}*@L@Q34)^bcX*_x z53dAo185!UNHfka2Wos8Yh+D$i}`y5mb^Q*N_Vx9?NXbyC8jMipVGd)osc2yRb4Yv zR88yGC@{k)TQDp}*IFos&{FI`gdJ}a3VuY})An2&L4$7PNV8PeJ8BHMr;RejTQ3Ta z2DfRXSsLesG4yz&^laSB2+)L+<#d(i3ie|W3*tJP0JW#nS_sj6h&4xSAGVCKNA*E! zaOnUGGVPuO@|UrAkZeq=$^-A9>Ks=W_!AW#dXKX+F|Muh#wc(4o3mMuiup@)@Icg& zGz|8SkClvKX*^}%Ju*I2m^JZuXG-HEv5C=Q;hd2!m+-dAnd7-~fk7=fg$>||{XGEuS=G1I&kJHZe^-lEmgi#e1rh~C)&P?Yk zc-Pn?aJO01XY#pJBn!iXgZ=tmE5b~nl$#5ejBL1QT5BSv;T2iDg**LX*NjzU4y5t!Q`aG}SMsyWt+wDul z#?48X6K}(z`7(G7>nE{jFpu*r zb<4<6Mh!l3bax!xZ;tMvqx0b*lD>x>?j&+DO4iZQtBl5{Ipbx}iL&e;y_qG~?QrzE zlDd9}JMM5J$jQ8vi6UvBJ31P#)K$lucXTrj?tMr1fuoB|=J41_`gaXrN*-uD%2g5{ z7fWQA*Msv>C0cI)`l=C;-$o402LOF4iB_;|#L!AgqQ28E+=!9(+J6n|io)pb#L2Ir z+W!o)D6T$BVC_GKvKgl4|AI!UFxq==s{Oa%Xi^xhYrqXcY1Y!vY$%NWEa-2-O$(Mt z?|p^QU&Thkw}&8_F`3Ifb~3I|g@jLZ#N5D|BD(1#OQfBpFu6u<1i+`3f}Z&bySv^j zdata); + while (stack->next != NULL) + { + printf(" %d", *(int*)stack->next->data); + stack = stack->next; + } + putchar('\n'); + } + else + { + printf("Der Stack ist leer\n"); + } +} +*/ + +// Setup-Funktionen von Unity, die zumindest als Platzhalter definiert sein müssen +void setUp(void) {}; +void tearDown(void) {}; + +void test_createNodeAbortsOnZeroData(void) +{ + void *data = NULL; + StackNode *stack = NULL; + stack = push(stack, data); + TEST_ASSERT_EQUAL_PTR(stack, NULL); + + clearStack(stack); +} + +void test_createdNodeIsFirstInList(void) +{ + int data = 42; + StackNode *stack = NULL; + stack = push(stack, &data); + TEST_ASSERT_NOT_NULL(stack); + TEST_ASSERT_EQUAL_PTR(&data, stack->data); + TEST_ASSERT_NULL(stack->next); + + clearStack(stack); +} + +void test_createNodeCorrectOrder(void) +{ + int data[3] = {0, 1, 2}; + StackNode *stack = NULL; + stack = push(stack, &data[2]); + stack = push(stack, &data[1]); + stack = push(stack, &data[0]); + + TEST_ASSERT_NOT_NULL(stack); + TEST_ASSERT_EQUAL_PTR(&data[0], stack->data); + TEST_ASSERT_EQUAL_PTR(&data[1], stack->next->data); + TEST_ASSERT_EQUAL_PTR(&data[2], stack->next->next->data); + TEST_ASSERT_NULL(stack->next->next->next); + + clearStack(stack); +} + +void test_removeNodeAbortsOnZero(void) +{ + StackNode *stack = NULL; + TEST_ASSERT_NULL(pop(stack)); + + clearStack(stack); +} + +void test_removeOnlyNodeEmptysList(void) +{ + int data = 42; + StackNode *stack = NULL; + stack = pop(push(stack, &data)); + + TEST_ASSERT_NULL(stack); + + clearStack(stack); +} + +void test_removeNodeRemovesFirst(void) +{ + int data[2] = {0, 1}; + StackNode *stack = NULL; + stack = push(stack, &data[1]); + stack = push(stack, &data[0]); + stack = pop(stack); + + TEST_ASSERT_NOT_NULL(stack); + TEST_ASSERT_EQUAL_PTR(&data[1], stack->data); + TEST_ASSERT_NULL(stack->next); + + clearStack(stack); +} + +void test_outputTopFailsOnZero(void) +{ + StackNode *stack = NULL; + + TEST_ASSERT_NULL(top(stack)); + + clearStack(stack); +} + +void test_outputTopCorrect(void) +{ + int data[2] = {0, 1}; + StackNode *stack = NULL; + stack = push(stack, &data[1]); + stack = push(stack, &data[0]); + + TEST_ASSERT_NOT_NULL(stack); + TEST_ASSERT_EQUAL_PTR(top(stack), stack->data); + + clearStack(stack); +} + + +/* Speicher freigabe lässt sich nicht mit Unity testen, am besten Programm mit valgrind ausführen +void test_clearStackFreesMemory(void) +{ + int data[2] = {22, 17}; + StackNode *lowNode = (StackNode *)malloc(sizeof(StackNode)); + lowNode->next = NULL; + lowNode->data = &data[0]; + StackNode *highNode = (StackNode *)malloc(sizeof(StackNode)); + highNode->next = lowNode; + highNode->data = &data[1]; + StackNode *stack = highNode; + + clearStack(stack); + + TEST_ASSERT_NULL(lowNode); + TEST_ASSERT_NULL(highNode); + TEST_ASSERT_NULL(stack); +} +*/ + +void test_push_should_add_new_node_at_top(void) +{ + StackNode *stack = NULL; + + int value = 42; + stack = push(stack, &value); + + TEST_ASSERT_NOT_NULL(stack); + TEST_ASSERT_EQUAL_PTR(&value, stack->data); + TEST_ASSERT_NULL(stack->next); + + clearStack(stack); +} + +void test_push_multiple_should_chain_nodes_correctly(void) +{ + int a = 1, b = 2; + + StackNode *first = push(NULL, &a); + + StackNode *second = push(first, &b); + + TEST_ASSERT_EQUAL_PTR(&b, second->data); + TEST_ASSERT_EQUAL_PTR(first, second->next); + TEST_ASSERT_EQUAL_PTR(&a, first->data); + + clearStack(second); +} + +void test_top_should_return_null_on_empty_stack(void) +{ + StackNode *stack = NULL; + TEST_ASSERT_NULL(top(stack)); +} + +void test_top_should_return_data_of_existing_node(void) +{ + StackNode node; + int x = 99; + + node.data = &x; + node.next = NULL; + + TEST_ASSERT_EQUAL_PTR(&x, top(&node)); +} + +void test_pop_should_return_null_when_stack_empty(void) +{ + StackNode *stack = NULL; + TEST_ASSERT_NULL(pop(stack)); +} + +void test_pop_should_remove_single_element(void) +{ + StackNode *stack = malloc(sizeof(StackNode)); + int x = 7; + + stack->data = &x; + stack->next = NULL; + + StackNode *result = pop(stack); + + TEST_ASSERT_NULL(result); // Kein Element mehr übrig +} + +void test_pop_should_remove_top_node_only(void) +{ + // Manuell verkettete Liste aufbauen + StackNode *n1 = malloc(sizeof(StackNode)); + StackNode *n2 = malloc(sizeof(StackNode)); + int a = 1, b = 2; + + n1->data = &a; + n1->next = NULL; + + n2->data = &b; + n2->next = n1; + + StackNode *result = pop(n2); + + TEST_ASSERT_EQUAL_PTR(n1, result); + + clearStack(result); +} + +int main() +{ + UNITY_BEGIN(); + + printf("\n============================\n Stack tests\n============================\n"); + printf("-> Create Nodes (push)\n"); + RUN_TEST(test_createNodeAbortsOnZeroData); + RUN_TEST(test_createdNodeIsFirstInList); + RUN_TEST(test_createNodeCorrectOrder); + + printf("\n-> Remove Nodes (pop)\n"); + RUN_TEST(test_removeNodeAbortsOnZero); + RUN_TEST(test_removeOnlyNodeEmptysList); + RUN_TEST(test_removeNodeRemovesFirst); + + printf("\n-> Output Top (top)\n"); + RUN_TEST(test_outputTopFailsOnZero); + RUN_TEST(test_outputTopCorrect); + + RUN_TEST(test_push_should_add_new_node_at_top); + RUN_TEST(test_push_multiple_should_chain_nodes_correctly); + RUN_TEST(test_top_should_return_null_on_empty_stack); + RUN_TEST(test_top_should_return_data_of_existing_node); + RUN_TEST(test_pop_should_return_null_when_stack_empty); + RUN_TEST(test_pop_should_remove_single_element); + RUN_TEST(test_pop_should_remove_top_node_only); + + return UNITY_END(); +} \ No newline at end of file diff --git a/test_stack.c b/test_stack.c new file mode 100644 index 0000000..60fabd8 --- /dev/null +++ b/test_stack.c @@ -0,0 +1,80 @@ +#include +#include +#include +#include "stack.h" + +void inspectStack(StackNode *stack) +{ + if (stack != NULL) + { + printf("Der Stack enthält die folgenden Elemente: %d", *(int*)stack->value); + while (stack->next != NULL) + { + printf(" %d", *(int*)stack->next->value); + stack = stack->next; + } + putchar('\n'); + } + else + { + printf("Der Stack ist leer\n"); + } +} + +int main() +{ + StackNode *stack; + stack = NULL; // initialisierung mit NULL -> leere Liste + + printf("...ein Element wird eingefügt...\n"); + int toBeRemoved = 42; + stack = push(stack, &toBeRemoved); + + inspectStack(stack); + + printf("...das Element wird wieder entfernt...\n"); + stack = pop(stack); + + inspectStack(stack); + + printf("...pop auf leeren Stack...\n"); + stack = pop(stack); + + inspectStack(stack); + putchar('\n'); + + int data[5] = {1, 2, 3, 4, 5}; + + // alle 5 werte der reihe nach auf den Satck legen - 1 unten ... 5 oben + for (int i = 0; i < 5; i++) + { + stack = push(stack, &data[i]); + } + + + //alle Elemente mit Test-Funktion ausgeben + inspectStack(stack); + + // Elemente stück für Stück ausgeben und entfernen + printf("1. Element war: %d\n", *(int*)top(stack)); + stack = pop(stack); + printf("2. Element war: %d\n", *(int*)top(stack)); + stack = pop(stack); + printf("3. Element war: %d\n", *(int*)top(stack)); + stack = pop(stack); + printf("4. Element war: %d\n", *(int*)top(stack)); + stack = pop(stack); + printf("5. Element war: %d\n", *(int*)top(stack)); +} + +/* +int main() +{ + UNITY_BEGIN(); + + printf("============================\n Stack tests\n============================\n"); + RUN_TEST(test_createNodeFailsOnZeroData); + + return UNITY_END(); +} +*/ diff --git a/timer.c b/timer.c new file mode 100644 index 0000000..fd8f6c1 --- /dev/null +++ b/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/timer.h b/timer.h new file mode 100644 index 0000000..180f8ac --- /dev/null +++ b/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/timer.o b/timer.o new file mode 100644 index 0000000000000000000000000000000000000000..965df2b352a4f9ef0dbf3a10c1045960be97c804 GIT binary patch literal 3086 zcmbtWU1%It6ux(6C%bhw-Hl0WW0g#QY^`)>x0^J!(b~0}l2lQGZLmVxxIdHK)y+)U znYC*b4F-!v#8&#C&RP3dXkh(?>y3&__X3P=XId#rU0jXC^ZZ#Rm`Ed%tte zckcgR?c7F2vYcRSyFf8!xMtTCSZ0eT#udg|ajApKbT;*@Q7gM;X}WD*WK+vV#c{%f zOjz;oBJsM>3b(*_9qopt$nr&FVLk7A@UD3M>p_6vwWB<0_m6e;O%-z^;T9Nsl`|Go z8M_%8Z;@q=$P#UduO3*K-(VkB)qV{DQp4nkcJypjDv_p?g?s4pyncOW|8DG)xQ#zKO1E9MSH``3VF8!+iMDgcEgBK>3uIs0+d7ixR%%y)@UP(W&{H9<)`x4q0E9sd}SJIhYid{*c z2JSn0Q&L`EekJv}_V?=QDmj1Y1x=%-1qI5{n`k9}>Kad|TA~nBIR+x|Qxa3u-IPJ7 zTtrGC2`Ro^l;HPIUc!27h$LN|cyd}V6^8YF`;CH;*R%6($1)F9?Y3EfQf^lphb+5l zTV*|4XZNZTo3T+KB3K~Vjt3d%J=I3JjoRZa+p6m#>sU^+ZkaW`X}R!dYaU@x;!eYE zyLyxs(}Xi7*%HU26h)JPE=)0$}(W*0mIImhh^EnjIY zC*pG=J{QF2ZjH}{;>o!dk7nxa^87d+i`;zEs-GDh3Ciw)(b>_FEKFJ98ZP9TR<+fs znam$SxHKAUqEs5w@Au*sY^T}HI%Xr=Hebl^)sJ+VEmyC+s6WxPCZ5icT61)7SbMxP zO%uN+1Aw?;RypHcJrz&9PwNKRDT^TYH|(PuGv}02Z_o5+AcuIq-#;QgPbqsuoHx+7 zA;nl4c~YPqfo)%4I||e%ye9(N=>W9?F94$_N=1!6qAt;0s*0OVdNYBS1}nY9+k}+F z4bIqBfyM(g2}H4+okWh41m2$_C);*Rk@U6#Ll)d5qVTjE4E(V@=Rh6arzTQ$3^bh;c z>C|VN)|~C*a;1V>C(znut8U^Al*CrkGJWj0Z6A_(R_J0CcAhBxV!{x7((xv>BM literal 0 HcmV?d00001 diff --git a/unity/LICENSE.txt b/unity/LICENSE.txt new file mode 100644 index 0000000..3e3aad5 --- /dev/null +++ b/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/unity/unity.c b/unity/unity.c new file mode 100644 index 0000000..3ea455d --- /dev/null +++ b/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/unity/unity.h b/unity/unity.h new file mode 100644 index 0000000..7c749c2 --- /dev/null +++ b/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/unity/unity_internals.h b/unity/unity_internals.h new file mode 100644 index 0000000..a66859a --- /dev/null +++ b/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/windows/libdoble_complete.a b/windows/libdoble_complete.a new file mode 100644 index 0000000000000000000000000000000000000000..728bb8f4ab6565bf5927777ae6397da54dbb2417 GIT binary patch literal 14140 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