From 1763ac1f6dfdbdeef945f5c5b72b33a57c82c6ed Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 2 Dec 2025 19:19:02 +0100 Subject: [PATCH 01/47] made doble_initial --- doble_initial.exe | Bin 0 -> 67469 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 doble_initial.exe diff --git a/doble_initial.exe b/doble_initial.exe new file mode 100644 index 0000000000000000000000000000000000000000..7d7ae6053f6261413c84c09af11327493c50e396 GIT binary patch literal 67469 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 UY1%=fSYjF5<+@jdGd-C9U!Bc6R{#J2 literal 0 HcmV?d00001 From cc927ad72337dfee53fa93dc27b7e4e4efbacc20 Mon Sep 17 00:00:00 2001 From: Jens Burger Date: Fri, 5 Dec 2025 12:19:11 +0100 Subject: [PATCH 02/47] =?UTF-8?q?Stack=20Funktionen=20hinzugef=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- highscores.txt | 1 + stack.c | 40 ++++++++++++++++++++++++++++++++++++++++ stack.h | 5 +++++ 3 files changed, 46 insertions(+) diff --git a/highscores.txt b/highscores.txt index 4edd5a7..2326b02 100644 --- a/highscores.txt +++ b/highscores.txt @@ -1 +1,2 @@ +player_name;9943 player1;3999 diff --git a/stack.c b/stack.c index e3a90d4..dd516f9 100644 --- a/stack.c +++ b/stack.c @@ -10,24 +10,64 @@ // Pushes data as pointer onto the stack. StackNode *push(StackNode *stack, void *data) { + StackNode *newNode = malloc(sizeof(StackNode)); + if(*newNode == NULL) + { + //printf("Fehler Bei Speicherallozierung!"); + return NULL; + } + newNode->data = data; + newNode->next = stack; + + return newNode; } // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be // freed by caller.) StackNode *pop(StackNode *stack) { + if(stack == NULL) + { + //printf("Fehlerhafte Adresse uebergeben"); + return NULL; + } + StackNode *next = stack->next; + + free(stack); + + return next; } // Returns the data of the top element. void *top(StackNode *stack) { + if(stack == NULL) + { + //printf("Fehlerhafte Adresse uebergeben"); + return NULL; + } + return stack->data; } // Clears stack and releases all memory. void clearStack(StackNode *stack) { + if(stack == NULL) + { + //printf("Fehlerhafte Adresse uebergeben"); + return NULL; + } + StackNode *currentNode = stack; + StackNode *nextNode; + + while(currentNode != NULL) + { + nextNode = currentNode->next; + free(currentNode); + currentNode = nextNode; + } } \ No newline at end of file diff --git a/stack.h b/stack.h index f7d542d..f438504 100644 --- a/stack.h +++ b/stack.h @@ -8,6 +8,11 @@ The latest element is taken from the stack. */ #include //TODO: passenden Datentyp als struct anlegen +typedef struct StackNode +{ + void *data; + struct SatckNode *next; +} StackNode; // Pushes data as pointer onto the stack. StackNode *push(StackNode *stack, void *data); From 00fafec3dc18a54bef8abee5e481802e5f9f3238 Mon Sep 17 00:00:00 2001 From: Jens Burger Date: Fri, 5 Dec 2025 14:33:22 +0100 Subject: [PATCH 03/47] test_stack.c erstellt --- stack.c | 4 +- stack.h | 2 +- test_stack.c | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 124 insertions(+), 3 deletions(-) create mode 100644 test_stack.c diff --git a/stack.c b/stack.c index dd516f9..6ce7eff 100644 --- a/stack.c +++ b/stack.c @@ -11,7 +11,7 @@ StackNode *push(StackNode *stack, void *data) { StackNode *newNode = malloc(sizeof(StackNode)); - if(*newNode == NULL) + if(newNode == NULL) { //printf("Fehler Bei Speicherallozierung!"); return NULL; @@ -58,7 +58,7 @@ void clearStack(StackNode *stack) if(stack == NULL) { //printf("Fehlerhafte Adresse uebergeben"); - return NULL; + return; } StackNode *currentNode = stack; diff --git a/stack.h b/stack.h index f438504..d80bda0 100644 --- a/stack.h +++ b/stack.h @@ -11,7 +11,7 @@ The latest element is taken from the stack. */ typedef struct StackNode { void *data; - struct SatckNode *next; + struct StackNode *next; } StackNode; // Pushes data as pointer onto the stack. diff --git a/test_stack.c b/test_stack.c new file mode 100644 index 0000000..26a219f --- /dev/null +++ b/test_stack.c @@ -0,0 +1,121 @@ +#include +#include +#include "stack.h" + +void testeStackBeschreiben() +{ + printf("=== Test: push() ===\n"); + + StackNode *stack = NULL; + int wert1 = 42; + stack = push(stack, &wert1); + + int *topValue = (int *)(stack->data); + if(topValue != NULL && *topValue == 42) + { + printf("Test 1: Erstes Element erfolgreich gepusht!\n"); + } + else + { + printf("Test 1: FEHLGESCHLAGEN!\n"); + } + + + int wert2 = 12; + stack = push(stack, &wert2); + + topValue = (int *)(stack->data); + int *secondValue = (int *)((stack->next)->data); + + if(topValue != NULL && *topValue == 12.25 && secondValue != NULL && *secondValue == 42) + { + printf("Test 2: Zweites Element erfolgreich gepusht!\n"); + } + else + { + printf("Test 2: FEHLGESCHLAGEN!\n"); + } + + + printf("=== Ende Test: push() ===\n\n"); + return; +} + +void testepop() +{ + printf("=== Test: pop() ===\n"); + + StackNode *stack = NULL; + int wert1 = 20; + int wert2 = 74; + + stack = push(stack, &wert1); + stack = push(stack, &wert2); + + stack = pop(stack); + + int *topValue = (int *)(stack->data); + + if(topValue != NULL && *topValue == 20) + { + printf("Test: Erstes Element erfolgreich gelöscht!\n"); + } + else + { + printf("Test 1: FEHLGESCHLAGEN!\n"); + } + + printf("=== Ende Test: pop() ===\n\n"); +} + +void testetop() +{ + printf("=== Test: top() ===\n"); + + StackNode *stack = NULL; + int wert1 = 20; + int wert2 = 74; + + stack = push(stack, &wert1); + stack = push(stack, &wert2); + + int *topValue = top(stack); + + if(topValue != NULL && *topValue == 74) + { + printf("Test: top() gibt korrektes Element zurück!\n"); + } + else + { + printf("Test: FEHLGESCHLAGEN!\n"); + } + + printf("=== Ende Test: top() ===\n\n"); +} + +void testeclearStack() +{ + printf("=== Test: clearStack() ===\n"); + + StackNode *stack = NULL; + int wert1 = 20; + int wert2 = 74; + + stack = push(stack, &wert1); + stack = push(stack, &wert2); + + clearStack(stack); + + printf("Test: clearStack() aufgerufen. Speicher freigegeben.\n"); + printf("=== Ende Test: clearStack() ===\n\n"); +} + +int main() +{ + testeStackBeschreiben(); + testepop(); + testetop(); + testeclearStack(); + + return 0; +} \ No newline at end of file From 03495bddf0857c29360828f4ca6950fb508299de Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Fri, 5 Dec 2025 23:50:23 +0100 Subject: [PATCH 04/47] einlesen und grobe logik in kommentaren etablieren --- bintree.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/bintree.c b/bintree.c index 5cf82a9..7af7804 100644 --- a/bintree.c +++ b/bintree.c @@ -2,18 +2,41 @@ #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 TreeNode *root = NULL; + + + TreeNode *addToTree (TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate); + void *nextTreeData (TreeNode *root); + void clearTree (TreeNode *root); + unsigned int treeSize (const TreeNode *root); + + // 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) +{ + //root setzen } +else +{ + //vergleichen und dann je links und rechts weiter + // mit neuer rekursiver funktion? + // in dieser jeweils nachschauen ob duplikat +} + +} + // 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, @@ -23,14 +46,17 @@ void *nextTreeData(TreeNode *root) } + // Releases all memory resources (including data copies). void clearTree(TreeNode *root) { } + // Returns the number of entries in the tree given by root. unsigned int treeSize(const TreeNode *root) { -} \ No newline at end of file +} + From 7dca38c37f9956a00aa20c238234744dcb6580c4 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Sat, 6 Dec 2025 16:40:57 +0100 Subject: [PATCH 05/47] wrote first version of addToTree() and wrote new recursive function addToTreeRec() --- bintree.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 47 insertions(+), 9 deletions(-) diff --git a/bintree.c b/bintree.c index 7af7804..850bae1 100644 --- a/bintree.c +++ b/bintree.c @@ -18,23 +18,61 @@ void clearTree (TreeNode *root); unsigned int treeSize (const TreeNode *root); + // selfdeclaredfunctions + TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate); + // 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). + +// returned Value is new root? TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate) { + // create a node + TreeNode *newNode; -if (root == NULL) -{ - //root setzen -} -else -{ - //vergleichen und dann je links und rechts weiter - // mit neuer rekursiver funktion? - // in dieser jeweils nachschauen ob duplikat + + newNode = calloc(1, sizeof(TreeNode)); + newNode->data = calloc(1, dataSize); + newNode->left = NULL; + newNode->right = NULL; + memcpy(newNode->data, data, dataSize); + + + return addToTreeRec(root, newNode, compareFct, isDuplicate); } + +TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) +{ + if (currentNode == NULL) + { + isDuplicate = 0; + return newNode; + } + else if (compareFct(newNode->data, currentNode->data) < 0) + { + currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); + } + else if (compareFct(newNode->data, currentNode->data) > 0) + { + currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); + } + else + { + //duplicate + if (isDuplicate == NULL) + { + return newNode; + } + else + { + isDuplicate = 1; + } + } + + + return currentNode; } From 494fa2237c9d62b12e9271f96bad7117f0538df0 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Sat, 6 Dec 2025 22:27:57 +0100 Subject: [PATCH 06/47] fixed logic problem in addToTreeRec() --- bintree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bintree.c b/bintree.c index 850bae1..1943006 100644 --- a/bintree.c +++ b/bintree.c @@ -63,7 +63,7 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType //duplicate if (isDuplicate == NULL) { - return newNode; + currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } else { From e52da066fa2239621706d1766235cf8b60f88599 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Sat, 6 Dec 2025 23:18:07 +0100 Subject: [PATCH 07/47] wrote clearTree(), created clearTreeRec() and clearNode() --- bintree.c | 32 ++++++++++++++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/bintree.c b/bintree.c index 1943006..60daca8 100644 --- a/bintree.c +++ b/bintree.c @@ -18,14 +18,16 @@ void clearTree (TreeNode *root); unsigned int treeSize (const TreeNode *root); - // selfdeclaredfunctions + // self declared functions TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate); + TreeNode *clearTreeRec (TreeNode *currentNode); + void clearNode (TreeNode *node); // 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). -// returned Value is new root? +// returned Value is new root TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate) { // create a node @@ -79,6 +81,8 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType // 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. + +// Needs stack!! void *nextTreeData(TreeNode *root) { @@ -88,7 +92,31 @@ void *nextTreeData(TreeNode *root) // Releases all memory resources (including data copies). void clearTree(TreeNode *root) { + clearTreeRec(root); +} + +TreeNode *clearTreeRec(TreeNode *currentNode) +{ + if (currentNode != NULL) + { + clearTree(currentNode->left); + clearNode(currentNode); + clearTree(currentNode->right); + } +} + + +void clearNode(TreeNode *node) +{ + free(node->data); + node->data = NULL; + + node->left = NULL; + node->right = NULL; + + free(node); + node = NULL; } From 2176383f1e6b9c77bf017c7d30436ebe3e15ce61 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Sat, 6 Dec 2025 23:44:40 +0100 Subject: [PATCH 08/47] wrote treeSize(), created treeSizeRec() --- bintree.c | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/bintree.c b/bintree.c index 60daca8..9aa8baa 100644 --- a/bintree.c +++ b/bintree.c @@ -4,8 +4,8 @@ //TODO: binären Suchbaum implementieren -/* * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv), - * `clearTree`: gibt den gesamten Baum frei (rekursiv), +/* * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv), Done + * `clearTree`: gibt den gesamten Baum frei (rekursiv), Done * `treeSize`: zählt die Knoten im Baum (rekursiv), * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */ @@ -20,8 +20,9 @@ // self declared functions TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate); - TreeNode *clearTreeRec (TreeNode *currentNode); + void clearTreeRec (TreeNode *currentNode); void clearNode (TreeNode *node); + void treeSizeRec (const TreeNode *currentNode, unsigned int *nodeCount); // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates @@ -69,7 +70,7 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType } else { - isDuplicate = 1; + *isDuplicate = 1; } } @@ -96,7 +97,7 @@ void clearTree(TreeNode *root) } -TreeNode *clearTreeRec(TreeNode *currentNode) +void clearTreeRec(TreeNode *currentNode) { if (currentNode != NULL) { @@ -122,7 +123,23 @@ void clearNode(TreeNode *node) // Returns the number of entries in the tree given by root. unsigned int treeSize(const TreeNode *root) -{ +{ + unsigned int amountOfNodes = 0; + + treeSizeRec(root, &amountOfNodes); + + + return amountOfNodes; +} + +void treeSizeRec(const TreeNode *currentNode, unsigned int *nodeCount) +{ + if (currentNode != NULL) + { + treeSizeRec(currentNode->left, nodeCount); + *nodeCount++; + treeSizeRec(currentNode->right, nodeCount); + } } From b50bd58dac62935befc71d592c13a74a5a8b694e Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Sun, 7 Dec 2025 14:34:37 +0100 Subject: [PATCH 09/47] created bintreeTests.c --- bintreeTests.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 bintreeTests.c diff --git a/bintreeTests.c b/bintreeTests.c new file mode 100644 index 0000000..46ced2d --- /dev/null +++ b/bintreeTests.c @@ -0,0 +1,30 @@ +#include +#include "unity.h" +#include "bintree.h" + + +// test if addToTree expands tree correctly +// by going down the path where the given pice of data is expected +// and checking if the pice of data is found there + + +// test if nextTreeData returns the next pice of data correctly +// needs Stack!!! + + +// test if clear Tree frees all node.name and node memory AND sets them to zero +// aditionally tests if the memoryspaces have been cleared + + +// tests if treeSize returns correct amount of nodes in Tree +// by using addNode a given number of times and testing to see if +// the treeSize matches the number of nodes added + + +// main, strings together all tests +int main() +{ + printf("\n============================\nBinary Tree tests\n============================\n"); + +} + From e523b5462ddc5a67ea330fbfe7617e9c2e5d0a0f Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Sun, 7 Dec 2025 23:23:32 +0100 Subject: [PATCH 10/47] started writing tests but ran into problems --- LICENSE.txt | 21 + bintreeTests.c | 13 + bintreeTests.exe | Bin 0 -> 55961 bytes unity.c | 2622 +++++++++++++++++++++++++++++++++++++++++++++ unity.h | 698 ++++++++++++ unity_internals.h | 1271 ++++++++++++++++++++++ 6 files changed, 4625 insertions(+) create mode 100644 LICENSE.txt create mode 100644 bintreeTests.exe create mode 100644 unity.c create mode 100644 unity.h create mode 100644 unity_internals.h diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..3e3aad5 --- /dev/null +++ b/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/bintreeTests.c b/bintreeTests.c index 46ced2d..380f633 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -2,10 +2,23 @@ #include "unity.h" #include "bintree.h" +#define MAX_TEST_NAME_LEN 10 + + +typedef struct +{ + char name[MAX_TEST_NAME_LEN]; + int score; +} HighscoreEntry; + // test if addToTree expands tree correctly // by going down the path where the given pice of data is expected // and checking if the pice of data is found there +void test_addToTreeExpandsTreeCorrectlyNoDoubles(void) +{ + +} // test if nextTreeData returns the next pice of data correctly diff --git a/bintreeTests.exe b/bintreeTests.exe new file mode 100644 index 0000000000000000000000000000000000000000..921fb7cc794aa14f1c885af43edeba8b57a882d6 GIT binary patch literal 55961 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 literal 0 HcmV?d00001 diff --git a/unity.c b/unity.c new file mode 100644 index 0000000..3ea455d --- /dev/null +++ b/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.h b/unity.h new file mode 100644 index 0000000..7c749c2 --- /dev/null +++ b/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_internals.h b/unity_internals.h new file mode 100644 index 0000000..a66859a --- /dev/null +++ b/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 From 1ead9595ceac451f05ba934b5171764bf4a73357 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 08:03:16 +0100 Subject: [PATCH 11/47] wrote test_addToTreeExpandsTreeCorrectly() --- bintreeTests.c | 69 ++++++++++++++++++++++++++++++++++++++++++----- bintreeTests.exe | Bin 55961 -> 0 bytes 2 files changed, 63 insertions(+), 6 deletions(-) delete mode 100644 bintreeTests.exe diff --git a/bintreeTests.c b/bintreeTests.c index 380f633..2c2ba87 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -5,19 +5,72 @@ #define MAX_TEST_NAME_LEN 10 -typedef struct +static int compareIntEntries(const void *arg1, const void *arg2) { - char name[MAX_TEST_NAME_LEN]; - int score; -} HighscoreEntry; + const int *entry1 = (const int *)arg1; + const int *entry2 = (const int *)arg2; + + int result = *entry2 - *entry1; + + + return result; +} // test if addToTree expands tree correctly // by going down the path where the given pice of data is expected // and checking if the pice of data is found there -void test_addToTreeExpandsTreeCorrectlyNoDoubles(void) +void test_addToTreeExpandsTreeCorrectly(void) { - + TreeNode *testRoot = NULL; + int *testIsDouble = 0; + int score1 = 12; + int score2 = 6; + int score3 = 18; + int score4 = 3; + int score5 = 9; + int score6 = 15; + int score7 = 21; + + + testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); + + // Checking the Tree without Doubles + TEST_ASSERT_NOT_NULL(testRoot); + TEST_ASSERT_EQUAL_UINT16(score1, testRoot); + TEST_ASSERT_NOT_NULL(testRoot->left); + TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left); + TEST_ASSERT_NOT_NULL(testRoot->right); + TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right); + TEST_ASSERT_NOT_NULL(testRoot->left->left); + TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left); + TEST_ASSERT_NOT_NULL(testRoot->left->right); + TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right); + TEST_ASSERT_NOT_NULL(testRoot->right->left); + TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left); + TEST_ASSERT_NOT_NULL(testRoot->right->right); + TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right); + + // Adding Double + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + + TEST_ASSERT_NOT_NULL(testRoot->left->left->left); + TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left); + + // Trying to add Double while Doubles not Permitted + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, testIsDouble); + + TEST_ASSERT_NULL(testRoot->right->right->left); + TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); + + + clearTree(testRoot); } @@ -27,6 +80,10 @@ void test_addToTreeExpandsTreeCorrectlyNoDoubles(void) // test if clear Tree frees all node.name and node memory AND sets them to zero // aditionally tests if the memoryspaces have been cleared +void test_clearTreeworksLikeExpected(void) +{ + +} // tests if treeSize returns correct amount of nodes in Tree diff --git a/bintreeTests.exe b/bintreeTests.exe deleted file mode 100644 index 921fb7cc794aa14f1c885af43edeba8b57a882d6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 55961 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 From 4042a7d97900797dac32d19f552e77f8d75e83bc Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 08:19:12 +0100 Subject: [PATCH 12/47] wrote test_clearTreeworksLikeExpected() --- bintreeTests.c | 57 ++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 48 insertions(+), 9 deletions(-) diff --git a/bintreeTests.c b/bintreeTests.c index 2c2ba87..68dc28a 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -43,31 +43,31 @@ void test_addToTreeExpandsTreeCorrectly(void) // Checking the Tree without Doubles TEST_ASSERT_NOT_NULL(testRoot); - TEST_ASSERT_EQUAL_UINT16(score1, testRoot); + TEST_ASSERT_EQUAL(score1, testRoot); TEST_ASSERT_NOT_NULL(testRoot->left); - TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left); + TEST_ASSERT_EQUAL(score2, testRoot->left); TEST_ASSERT_NOT_NULL(testRoot->right); - TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right); + TEST_ASSERT_EQUAL(score3, testRoot->right); TEST_ASSERT_NOT_NULL(testRoot->left->left); - TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left); + TEST_ASSERT_EQUAL(score4, testRoot->left->left); TEST_ASSERT_NOT_NULL(testRoot->left->right); - TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right); + TEST_ASSERT_EQUAL(score5, testRoot->left->right); TEST_ASSERT_NOT_NULL(testRoot->right->left); - TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left); + TEST_ASSERT_EQUAL(score6, testRoot->right->left); TEST_ASSERT_NOT_NULL(testRoot->right->right); - TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right); + TEST_ASSERT_EQUAL(score7, testRoot->right->right); // Adding Double testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); TEST_ASSERT_NOT_NULL(testRoot->left->left->left); - TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left); + TEST_ASSERT_EQUAL(score4, testRoot->left->left->left); // Trying to add Double while Doubles not Permitted testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, testIsDouble); TEST_ASSERT_NULL(testRoot->right->right->left); - TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); + TEST_ASSERT_EQUAL(1, testIsDouble); clearTree(testRoot); @@ -82,7 +82,46 @@ void test_addToTreeExpandsTreeCorrectly(void) // aditionally tests if the memoryspaces have been cleared void test_clearTreeworksLikeExpected(void) { + TreeNode *testRoot = NULL; + int score1 = 12; + int score2 = 6; + int score3 = 18; + int score4 = 3; + int score5 = 9; + int score6 = 15; + int score7 = 21; + + // Fill Tree + testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + + // Save all Adresses + TreeNode *node1 = testRoot->left; + TreeNode *node2 = testRoot->left->left; + TreeNode *node3 = testRoot->left->right; + TreeNode *node4 = testRoot->right; + TreeNode *node5 = testRoot->right->left; + TreeNode *node6 = testRoot->right->right; + TreeNode *node7 = testRoot->left->left->left; + + clearTree(testRoot); + + // Check if everything has been set to NULL + TEST_ASSERT_NULL(testRoot); + TEST_ASSERT_NULL(node1); + TEST_ASSERT_NULL(node2); + TEST_ASSERT_NULL(node3); + TEST_ASSERT_NULL(node4); + TEST_ASSERT_NULL(node5); + TEST_ASSERT_NULL(node6); + TEST_ASSERT_NULL(node7); } From 409afc165bd581c9b7264295ae25b293a4677b90 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 08:24:30 +0100 Subject: [PATCH 13/47] wrote test_treeSizeWorkingLikeExpected(void) --- bintreeTests.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/bintreeTests.c b/bintreeTests.c index 68dc28a..ef35bef 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -126,8 +126,38 @@ void test_clearTreeworksLikeExpected(void) // tests if treeSize returns correct amount of nodes in Tree -// by using addNode a given number of times and testing to see if +// by using addToTree a given number of times and testing to see if // the treeSize matches the number of nodes added +void test_treeSizeWorkingLikeExpected(void) +{ + TreeNode *testRoot = NULL; + int nodeCount = 7; + unsigned int testTreeSize = 0; + int score1 = 12; + int score2 = 6; + int score3 = 18; + int score4 = 3; + int score5 = 9; + int score6 = 15; + int score7 = 21; + + + // Fill Tree + testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + + testTreeSize = treeSize(testRoot); + + TEST_ASSERT_EQUAL(nodeCount, testTreeSize); + + clearTree(testRoot); +} // main, strings together all tests From ffde7270db9903645d27c5dd7cae29b74483e9cf Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 08:30:10 +0100 Subject: [PATCH 14/47] wrote main() in bintreeTests.c --- bintreeTests.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/bintreeTests.c b/bintreeTests.c index ef35bef..0ab00e7 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -76,6 +76,10 @@ void test_addToTreeExpandsTreeCorrectly(void) // test if nextTreeData returns the next pice of data correctly // needs Stack!!! +void test_nextTreeDataReturnsNextDataCorrectly(void) +{ + +} // test if clear Tree frees all node.name and node memory AND sets them to zero @@ -163,7 +167,14 @@ void test_treeSizeWorkingLikeExpected(void) // main, strings together all tests int main() { - printf("\n============================\nBinary Tree tests\n============================\n"); + UNITY_BEGIN(); + printf("\n============================\nBinary Tree tests\n============================\n"); + RUN_TEST(test_addToTreeExpandsTreeCorrectly); + // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); + RUN_TEST(test_clearTreeworksLikeExpected); + RUN_TEST(test_treeSizeWorkingLikeExpected); + + return UNITY_END(); } From b138a8f251becad079fab5f5f624c1a340e59647 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 08:36:00 +0100 Subject: [PATCH 15/47] added bintreeTests to makefile as Target --- makefile | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/makefile b/makefile index 1f15f75..686e04a 100644 --- a/makefile +++ b/makefile @@ -35,8 +35,11 @@ $(program_obj_filesobj_files): %.o: %.c # -------------------------- # Unit Tests # -------------------------- -unitTests: - echo "needs to be implemented" +# unitTests: +# echo "needs to be implemented" + +bintreeTests: bintree.o bintreeTests.c $(unityfolder)/unity.c + $(CC) $(FLAGS) -o runbintreeTests bintreeTests.c bintree.o $(unityfolder)/unity.c # -------------------------- # Clean From c49a8d687c57ef376eb0df191904b3ea69b963d0 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 13:01:23 +0100 Subject: [PATCH 16/47] reset highscore.txt --- highscores.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/highscores.txt b/highscores.txt index 2326b02..4edd5a7 100644 --- a/highscores.txt +++ b/highscores.txt @@ -1,2 +1 @@ -player_name;9943 player1;3999 From 574ed71bae16703fb7b732bd8ef68837d0e48c6f Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 20:48:02 +0100 Subject: [PATCH 17/47] added bintree.o to makefile --- makefile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/makefile b/makefile index 686e04a..f827225 100644 --- a/makefile +++ b/makefile @@ -38,6 +38,9 @@ $(program_obj_filesobj_files): %.o: %.c # unitTests: # echo "needs to be implemented" +bintree: bintree.c + $(CC) $(FLAGS) -c bintree bintree.c + bintreeTests: bintree.o bintreeTests.c $(unityfolder)/unity.c $(CC) $(FLAGS) -o runbintreeTests bintreeTests.c bintree.o $(unityfolder)/unity.c From f91ab68a72fba81de27e3c132c71ca55ba57c100 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 20:49:01 +0100 Subject: [PATCH 18/47] added bintree.o to git --- bintree.o | Bin 0 -> 2163 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 bintree.o diff --git a/bintree.o b/bintree.o new file mode 100644 index 0000000000000000000000000000000000000000..e8fcbd71dca67cd0a6bd0ac632196b14cdff8de3 GIT binary patch literal 2163 zcmaJ@&udgy6uvKSVyC6xSb|Qii$|3*h0JprgNP`+8i!mZBf%!rMM^W7dFtqx2{RK( z0+zyH;qefLZgtf~*LC4S7m}pHbm^k~6AFq7UAS-|oqpfF@28Bt@a{e5JLjHr?m6eZ z`|3aK5geam`Akt6VRzk)uA=qy&zKMy1N6A&xmaR;*{)Z+RSms&cEtR)z0&C<6>>=? zpns&^M%v&KWUtM%vLi~4y_VKnhRS?Kh^ZjHJb3CIolfta2m2fJk^}KMi_-gB_Fk5x zSIJ3lF+b;(tvRn!ctk@FdGKf4BE9k(>6b0(?IyupU~i7w~|cJ6{i<-rn9ks%1_VD17R0VxK<`heJey44lb6zx}_aewYkQlEMQcp&vlGkDP^?y_Y&? z%u_dVPR+;4mELtAbm2S7$}fp06y4}NAH>J%_xncH z9M4|Nm{?5+KoU{rXCysxAe7d;S>NGZr9rtRn?cOX+T4&Z9&91ew zX;m7lv)>lU);rc(yLHX2b-%Q}I%ZGVB^XJJ!=M>cMtRi~zkQ!7tO&0M6}1#mVAY9C z>LWO&1);ze6Fe7%Pp{ZrgS3ng%hqTP-F{4SuloM|*F8 z7^w6Z>O5*N&+HSWqZGct%&v)%V?fw5F>)FRJ10iY17ZJYgyDVD*mBuLu@2A4UeZYN zmSb?H!5#~)5bzwy8xBI~C^$7GZ#Q*zgWZrG$(xN`V;anFdL(Z(MqwJunAtJuu^h0x zBTQo^Ed*DqHk++l2qW|2hI^y7wwXjOBR?T81a+>1wcET`k8EviiE6#R&|08YL|t@i hVii9IM9=c#uQlCjTj@j;brf@L1)>St{{iJXrOp5V literal 0 HcmV?d00001 From 517d363f3e889f0144a22c0f60bbcb9ced494a10 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Mon, 8 Dec 2025 22:41:49 +0100 Subject: [PATCH 19/47] debugging --- bintree.c | 25 ++++++++++++----- bintree.o | Bin 2163 -> 2629 bytes bintreeTests.c | 71 ++++++++++++++++++++++++++++++++++--------------- 3 files changed, 69 insertions(+), 27 deletions(-) diff --git a/bintree.c b/bintree.c index 9aa8baa..3c34c42 100644 --- a/bintree.c +++ b/bintree.c @@ -1,3 +1,4 @@ +#include #include #include "stack.h" #include "bintree.h" @@ -39,7 +40,8 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc newNode->data = calloc(1, dataSize); newNode->left = NULL; newNode->right = NULL; - memcpy(newNode->data, data, dataSize); + memcpy(&newNode->data, data, dataSize); + // printf("node created\n"); return addToTreeRec(root, newNode, compareFct, isDuplicate); @@ -48,22 +50,33 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) { + // printf("entered addRec\n"); + //printf("curdat = %d\n", currentNode->data); + //printf("newdat = %d\n", newNode->data); if (currentNode == NULL) { - isDuplicate = 0; + printf("currentNode == NULL\n"); + if (isDuplicate != NULL) + { + *isDuplicate = 0; + } + return newNode; } - else if (compareFct(newNode->data, currentNode->data) < 0) + else if (compareFct(currentNode->data, newNode->data) < 0) { + printf("compareFct(currentNode->data, newNode->data) < 0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } - else if (compareFct(newNode->data, currentNode->data) > 0) + else if (compareFct(currentNode->data, newNode->data) > 0) { + printf("compareFct(currentNode->data, newNode->data) > 0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); } - else + else if (compareFct(currentNode->data, newNode->data) == 0) { //duplicate + printf("duplicate\n"); if (isDuplicate == NULL) { currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); @@ -73,7 +86,7 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType *isDuplicate = 1; } } - + printf("passed everything\n"); return currentNode; } diff --git a/bintree.o b/bintree.o index e8fcbd71dca67cd0a6bd0ac632196b14cdff8de3..f472e9eb2c68e7dd89c2c522cba49d3946327894 100644 GIT binary patch delta 1011 zcmaizTWb?h5XWb8X`VrM%6moHc^19R1*kO8|BN8QBvn9Vk^AGXzd?8j|I_?Qk0Lpf~GWy>ym;j&jQ`{lAA zzL^vIv=8!xo%$22=16csvgaa^Odwc8FrJP_PJ{4lJdyd4;Ua&_qw!&?`jN HcBu9T@KMXR delta 546 zcmX>q@>zg4rHzdN1eAc3^h929!4FIf3@nU55mvA`1M5W7Y^E>F6Bnsz1+XwM7(s<4 zfU*t@1`hfr5M?kj0La+DGFghTjFDk-A7iMVpvQ4n4Unuyx2wdi0;N_ccL z_;kA}cyu0g{C}bKK&AfV4@`2Vlm7qz@6jD9;L+*C@v;@KjyfHnF+ign1SUH$iSfB3 zbPBw-o&1tXl}Y6PWC3RJ&1THOjFT_0NK9VB;t@FqMjW zm=yzJZ9d5s&R7p}1S8NYpa>AC0Wru)2oYnT2*^PQ5nG@L$XN&xFQ5p>aS)M`qSVyj z%&Jt76A@}cfNDSvg^1{tq*j0&#xQw42PZ4Y@vM{Aa?G8a$H~LUHo2P9dh!X*S^%$I BXK4Tc diff --git a/bintreeTests.c b/bintreeTests.c index 0ab00e7..6aa1c01 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -5,14 +5,24 @@ #define MAX_TEST_NAME_LEN 10 +void setUp(void) { + // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden +} + +void tearDown(void) { + // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden +} + + static int compareIntEntries(const void *arg1, const void *arg2) { + // printf("in comp\n"); const int *entry1 = (const int *)arg1; const int *entry2 = (const int *)arg2; + // printf("const set\n"); + int result = entry2 - entry1; - int result = *entry2 - *entry1; - - + // printf("exit comp\n"); return result; } @@ -34,43 +44,62 @@ void test_addToTreeExpandsTreeCorrectly(void) testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); + printf("add1passed\n"); testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); + printf("add2passed\n"); testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); + printf("add3passed\n"); testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + printf("add4passed\n"); testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); + printf("add5passed\n"); testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); + printf("add6passed\n"); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); + printf("add7passed\n"); // Checking the Tree without Doubles TEST_ASSERT_NOT_NULL(testRoot); - TEST_ASSERT_EQUAL(score1, testRoot); + TEST_ASSERT_EQUAL_UINT16(score1, testRoot->data); + printf("node1passed\n"); + TEST_ASSERT_NOT_NULL(testRoot->left); - TEST_ASSERT_EQUAL(score2, testRoot->left); + TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left->data); + printf("node2passed\n"); + TEST_ASSERT_NOT_NULL(testRoot->right); - TEST_ASSERT_EQUAL(score3, testRoot->right); - TEST_ASSERT_NOT_NULL(testRoot->left->left); - TEST_ASSERT_EQUAL(score4, testRoot->left->left); - TEST_ASSERT_NOT_NULL(testRoot->left->right); - TEST_ASSERT_EQUAL(score5, testRoot->left->right); - TEST_ASSERT_NOT_NULL(testRoot->right->left); - TEST_ASSERT_EQUAL(score6, testRoot->right->left); - TEST_ASSERT_NOT_NULL(testRoot->right->right); - TEST_ASSERT_EQUAL(score7, testRoot->right->right); + TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right->data); + printf("node3passed\n"); + TEST_ASSERT_NOT_NULL(testRoot->left->left); + TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->data); + printf("node4passed\n"); + + TEST_ASSERT_NOT_NULL(testRoot->left->right); + TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right->data); + printf("node5passed\n"); + /* + TEST_ASSERT_NOT_NULL(testRoot->right->left); + TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data); + printf("node6passed\n"); + /* + TEST_ASSERT_NOT_NULL(testRoot->right->right); + TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right->data); + printf("node7passed\n"); + /* // Adding Double testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); - TEST_ASSERT_NOT_NULL(testRoot->left->left->left); - TEST_ASSERT_EQUAL(score4, testRoot->left->left->left); + TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left); // Trying to add Double while Doubles not Permitted testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, testIsDouble); - TEST_ASSERT_NULL(testRoot->right->right->left); - TEST_ASSERT_EQUAL(1, testIsDouble); - + TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); + clearTree(testRoot); + // */ } @@ -172,8 +201,8 @@ int main() printf("\n============================\nBinary Tree tests\n============================\n"); RUN_TEST(test_addToTreeExpandsTreeCorrectly); // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); - RUN_TEST(test_clearTreeworksLikeExpected); - RUN_TEST(test_treeSizeWorkingLikeExpected); + // RUN_TEST(test_clearTreeworksLikeExpected); + // RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); } From 36ac0d6d9d3c4b2e9a9dc0db4d4a67cbcdfaa540 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 00:36:27 +0100 Subject: [PATCH 20/47] normal Nodes working in addToTree() --- bintree.c | 10 ++++------ bintree.o | Bin 2629 -> 2665 bytes bintreeTests.c | 21 ++++++++++++++++----- 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/bintree.c b/bintree.c index 3c34c42..6cf26f9 100644 --- a/bintree.c +++ b/bintree.c @@ -50,9 +50,7 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) { - // printf("entered addRec\n"); - //printf("curdat = %d\n", currentNode->data); - //printf("newdat = %d\n", newNode->data); + printf("entered addRec\n"); if (currentNode == NULL) { printf("currentNode == NULL\n"); @@ -63,17 +61,17 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType return newNode; } - else if (compareFct(currentNode->data, newNode->data) < 0) + else if (compareFct(¤tNode->data, &newNode->data) < 0) { printf("compareFct(currentNode->data, newNode->data) < 0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } - else if (compareFct(currentNode->data, newNode->data) > 0) + else if (compareFct(¤tNode->data, &newNode->data) > 0) { printf("compareFct(currentNode->data, newNode->data) > 0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); } - else if (compareFct(currentNode->data, newNode->data) == 0) + else if (compareFct(¤tNode->data, &newNode->data) == 0) { //duplicate printf("duplicate\n"); diff --git a/bintree.o b/bintree.o index f472e9eb2c68e7dd89c2c522cba49d3946327894..e53f36e3003b527a372829f3c3d34987b1c1f7ad 100644 GIT binary patch delta 617 zcmX>q@=}B|rH!2d1RhP~ROa+x1G5Cwx|KluftqMQ^XP_8>v!lT<&z^B_)0jSRL|Ap2Am3BZS8k2RI zG_{ld|NjqEBH+>K#PM=7$Sf@C>#Tw56DGGaX=?Bx)C;^$!lt;?2dH@BDOw3y=+>!+|&e$WF~GNi9lEQAkWl2}(_7NG>fZ0t)%%r=%*_+A8>k z`uG490YP$pZb4#E>g06R_w`$Vd@&$qVb}vCWx%XcaIs5pF-~A0LevQYSrB!xaIsXl z*gCk_Hn`X?xEK@Ad+)ZomjR8Z(3)Pw-luuksfkY)vilHlaE9P1g^PIMHVT*P@902CU4 A%>V!Z delta 580 zcmaDUa#VyfrH!2d1olnjROYl`1G5?UCz?)YJU8*IJmZ3iZ?zd;O#CQ3S%+~GS97fZ zL#d`mFDt|3?~IBnI*beq9^I}I9^C>!3Wynex?L4KIuAPjztDQ1(hjIlVzL>NreXH~ z|NlL@Lj^oKoj6|Z2ik#KSDiIbSHR>hCQUs-gf4;C8Mw8S`T(^wPQJ}#z_@ub53>|w z_hxnGB*w`XSR^JdVF^hVW@2FA0a^;8<$zcM$Oh52K&${{gXm@;)&a6X^c^6!0J1?e z2QveM3y=+>qkuR7$WAUTDoV{O@ykz1Rj{>H@C)_vnVik~yM8xNP7H`y7!CtT88C|h z7(@^;4j>C676lhef{Sg0i|vGq{e_FM0$l>pI}6B?1)F>l&H{2l{@eVMEtWAF +#include #include "unity.h" #include "bintree.h" @@ -17,10 +18,13 @@ void tearDown(void) { static int compareIntEntries(const void *arg1, const void *arg2) { // printf("in comp\n"); - const int *entry1 = (const int *)arg1; - const int *entry2 = (const int *)arg2; + const int *entry1 = (const void *)arg1; + const int *entry2 = (const void *)arg2; + // printf("const set\n"); - int result = entry2 - entry1; + int result = *entry2 - *entry1; + + // int result = entry2 - entry1; // printf("exit comp\n"); return result; @@ -45,18 +49,25 @@ void test_addToTreeExpandsTreeCorrectly(void) testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); printf("add1passed\n"); + testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); printf("add2passed\n"); + testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); printf("add3passed\n"); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); printf("add4passed\n"); + testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); printf("add5passed\n"); + testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); printf("add6passed\n"); + /* testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); printf("add7passed\n"); + */ // Checking the Tree without Doubles TEST_ASSERT_NOT_NULL(testRoot); @@ -70,7 +81,7 @@ void test_addToTreeExpandsTreeCorrectly(void) TEST_ASSERT_NOT_NULL(testRoot->right); TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right->data); printf("node3passed\n"); - + TEST_ASSERT_NOT_NULL(testRoot->left->left); TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->data); printf("node4passed\n"); @@ -78,7 +89,7 @@ void test_addToTreeExpandsTreeCorrectly(void) TEST_ASSERT_NOT_NULL(testRoot->left->right); TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right->data); printf("node5passed\n"); - /* + TEST_ASSERT_NOT_NULL(testRoot->right->left); TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data); printf("node6passed\n"); From d56a2f7a032c9433bbc11188b847ee1704d8b526 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 00:44:04 +0100 Subject: [PATCH 21/47] adding double working, double not Permitted not working --- bintreeTests.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/bintreeTests.c b/bintreeTests.c index 24f2c1e..f8b61ba 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -64,10 +64,10 @@ void test_addToTreeExpandsTreeCorrectly(void) testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); printf("add6passed\n"); - /* + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); printf("add7passed\n"); - */ + // Checking the Tree without Doubles TEST_ASSERT_NOT_NULL(testRoot); @@ -93,24 +93,24 @@ void test_addToTreeExpandsTreeCorrectly(void) TEST_ASSERT_NOT_NULL(testRoot->right->left); TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data); printf("node6passed\n"); - /* + TEST_ASSERT_NOT_NULL(testRoot->right->right); TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right->data); printf("node7passed\n"); - /* + // Adding Double testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); TEST_ASSERT_NOT_NULL(testRoot->left->left->left); - TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left); - + TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left->data); + // Trying to add Double while Doubles not Permitted testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, testIsDouble); TEST_ASSERT_NULL(testRoot->right->right->left); TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); - clearTree(testRoot); - // */ + //clearTree(testRoot); + } From 6b30677698e482175887ca866cd856f0c847cd0c Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 01:00:42 +0100 Subject: [PATCH 22/47] addToTreeExpandsTreeCorrectly --- bintree.c | 25 +++++++++++++++++-------- bintree.o | Bin 2665 -> 2717 bytes bintreeTests.c | 5 +++-- 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/bintree.c b/bintree.c index 6cf26f9..a7846be 100644 --- a/bintree.c +++ b/bintree.c @@ -51,27 +51,35 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) { printf("entered addRec\n"); - if (currentNode == NULL) + if ((currentNode == NULL)) { printf("currentNode == NULL\n"); - if (isDuplicate != NULL) + if (isDuplicate == NULL) { - *isDuplicate = 0; + + return newNode; + } + //else if (isDuplicate != 1) + //{ + // *isDuplicate = 0; + // return newNode; + //} + else + { + return currentNode; } - - return newNode; } - else if (compareFct(¤tNode->data, &newNode->data) < 0) + else if ((compareFct(¤tNode->data, &newNode->data) < 0)) { printf("compareFct(currentNode->data, newNode->data) < 0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } - else if (compareFct(¤tNode->data, &newNode->data) > 0) + else if ((compareFct(¤tNode->data, &newNode->data) > 0)) { printf("compareFct(currentNode->data, newNode->data) > 0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); } - else if (compareFct(¤tNode->data, &newNode->data) == 0) + else if ((compareFct(¤tNode->data, &newNode->data) == 0)) { //duplicate printf("duplicate\n"); @@ -81,6 +89,7 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType } else { + printf("setDuplicate\n"); *isDuplicate = 1; } } diff --git a/bintree.o b/bintree.o index e53f36e3003b527a372829f3c3d34987b1c1f7ad..d193ca1c6e01704e3fd298d97f3a725791bdbe2c 100644 GIT binary patch delta 567 zcmaDUGFOx{`geRJ2GtQZ~P@U}u3j>21`^0l{ ztOtNn5feYEGfA*bmSVi2so~Mf$`2It=sfrWq|2kZR)e9G)1%u};-wMLEFeSRr6!Ou z`5=?XWCJFB!Q}t{|9fmruo)DoA;w^-#Se`TFn&jGYl z3@FXQAOK{^fLSqcu@t!2TDaI&xY&ER*mt-X2hd8Wc|aD#yrn>vEZF2La2AjY^3vv? zY_W{dAb&A3C@=siATS1Ekna#8wm=b(9}yy6KoO8nAtEJ3sj0!4RjDBVBGiNc)d)}C X$RW*|3iP}11i delta 539 zcmbO$`ci}|rH!2d1Rk+Z2u?K3X6%``P@U}s3j@O^wu$HD zST_KrJSKirXZ$hoqwr)M#$#HV9=)vmAkof)FF^V{nrk%}O1M0_T{Vt__zXan#7ill zxswktiA>gK(icqn|Np;7cc_3zrxVA^%|In!nPw(^K0btu!0RNSuqdO?left->left->left); TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left->data); + printf("double passed\n"); // Trying to add Double while Doubles not Permitted - testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, testIsDouble); + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, &testIsDouble); TEST_ASSERT_NULL(testRoot->right->right->left); TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); From 5dc45f859088c8ca2931680dcb311d8382325ce8 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 01:03:58 +0100 Subject: [PATCH 23/47] uncommented not needed code from test_addToTreeExpandsTreeCorrectly and addToTree --- bintree.c | 14 +++++++------- bintree.o | Bin 2717 -> 2179 bytes bintreeTests.c | 30 +++++++++++++++--------------- 3 files changed, 22 insertions(+), 22 deletions(-) diff --git a/bintree.c b/bintree.c index a7846be..a0b9a0d 100644 --- a/bintree.c +++ b/bintree.c @@ -50,10 +50,10 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) { - printf("entered addRec\n"); + // printf("entered addRec\n"); if ((currentNode == NULL)) { - printf("currentNode == NULL\n"); + // printf("currentNode == NULL\n"); if (isDuplicate == NULL) { @@ -71,29 +71,29 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType } else if ((compareFct(¤tNode->data, &newNode->data) < 0)) { - printf("compareFct(currentNode->data, newNode->data) < 0\n"); + // printf("compareFct(currentNode->data, newNode->data) < 0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } else if ((compareFct(¤tNode->data, &newNode->data) > 0)) { - printf("compareFct(currentNode->data, newNode->data) > 0\n"); + // printf("compareFct(currentNode->data, newNode->data) > 0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); } else if ((compareFct(¤tNode->data, &newNode->data) == 0)) { //duplicate - printf("duplicate\n"); + // printf("duplicate\n"); if (isDuplicate == NULL) { currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } else { - printf("setDuplicate\n"); + // printf("setDuplicate\n"); *isDuplicate = 1; } } - printf("passed everything\n"); + // printf("passed everything\n"); return currentNode; } diff --git a/bintree.o b/bintree.o index d193ca1c6e01704e3fd298d97f3a725791bdbe2c..22e8a0e509a69ea28114f8f2d9f2d2a452055c3d 100644 GIT binary patch delta 541 zcmYLGO-lk%6n$?T&5?u=8X67C7LkQ$^Z`K$gCtBJf}l}L7r78ug+c||LI{T0B##y? zTC{Cz?G=LBx36|3{)NEKoiXOZedo-%=iPfBbFZ}{;gjnCqgVyZbi&gS=3`9ejH!M{ zXa3Gcjmw>f#pSZhSaz)HC>m_VNUyuD|FZznlSPcb%(a^;YedaPt0L8V%_ zW)ve4#**gX<{{P3SVmxMF=X*9ZXP%*+%fO%p8XzRY?rNO2`m;^wlJzGvM$?78aI&h zK|*d6*i2#XezztxgG_|Xudh$9S!${I@-y+$>XjHXQqo#5N|no|m@y!=iiz$%oDCq> zO0INAC@ab=uds@t zX`rT;6fWj+;&i!Gf(TJrI@qDL7PGd^G5((~51(SF z=c*N1=d8~4DW_27dYvm#kze52ioRH_ouM5%F9LIotpEY*mNr^Oz0KktV;r&2bBx<9 z^w!}%I9vp8ZtG$|w(gX}DGv9@;hs3$mvM*u=8zFQ_wNq^*&nMWHlu5tAFp2K)L&O~0vhVF&5Y{&k`9IfCuDwsx*w;q lvom}v?)`1)KlcmI%*o+_1ri{_op<4hkZS04=zoNpzW@k#+Cl&T diff --git a/bintreeTests.c b/bintreeTests.c index 9f5d834..b5f901b 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -48,61 +48,61 @@ void test_addToTreeExpandsTreeCorrectly(void) testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); - printf("add1passed\n"); + // printf("add1passed\n"); testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); - printf("add2passed\n"); + // printf("add2passed\n"); testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); - printf("add3passed\n"); + // printf("add3passed\n"); testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); - printf("add4passed\n"); + // printf("add4passed\n"); testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); - printf("add5passed\n"); + // printf("add5passed\n"); testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); - printf("add6passed\n"); + // printf("add6passed\n"); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); - printf("add7passed\n"); + // printf("add7passed\n"); // Checking the Tree without Doubles TEST_ASSERT_NOT_NULL(testRoot); TEST_ASSERT_EQUAL_UINT16(score1, testRoot->data); - printf("node1passed\n"); + // printf("node1passed\n"); TEST_ASSERT_NOT_NULL(testRoot->left); TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left->data); - printf("node2passed\n"); + // printf("node2passed\n"); TEST_ASSERT_NOT_NULL(testRoot->right); TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right->data); - printf("node3passed\n"); + // printf("node3passed\n"); TEST_ASSERT_NOT_NULL(testRoot->left->left); TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->data); - printf("node4passed\n"); + // printf("node4passed\n"); TEST_ASSERT_NOT_NULL(testRoot->left->right); TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right->data); - printf("node5passed\n"); + // printf("node5passed\n"); TEST_ASSERT_NOT_NULL(testRoot->right->left); TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data); - printf("node6passed\n"); + // printf("node6passed\n"); TEST_ASSERT_NOT_NULL(testRoot->right->right); TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right->data); - printf("node7passed\n"); + // printf("node7passed\n"); // Adding Double testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); TEST_ASSERT_NOT_NULL(testRoot->left->left->left); TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left->data); - printf("double passed\n"); + // printf("double passed\n"); // Trying to add Double while Doubles not Permitted testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, &testIsDouble); From 402604cb45e0236fd6fa711d7544699db44c46d4 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 01:07:39 +0100 Subject: [PATCH 24/47] removed no longer needed code --- bintree.c | 18 ++---------------- bintreeTests.c | 39 +++------------------------------------ 2 files changed, 5 insertions(+), 52 deletions(-) diff --git a/bintree.c b/bintree.c index a0b9a0d..dcb6695 100644 --- a/bintree.c +++ b/bintree.c @@ -7,7 +7,7 @@ //TODO: binären Suchbaum implementieren /* * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv), Done * `clearTree`: gibt den gesamten Baum frei (rekursiv), Done - * `treeSize`: zählt die Knoten im Baum (rekursiv), + * `treeSize`: zählt die Knoten im Baum (rekursiv), Done * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */ @@ -41,7 +41,6 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc newNode->left = NULL; newNode->right = NULL; memcpy(&newNode->data, data, dataSize); - // printf("node created\n"); return addToTreeRec(root, newNode, compareFct, isDuplicate); @@ -50,20 +49,12 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) { - // printf("entered addRec\n"); if ((currentNode == NULL)) { - // printf("currentNode == NULL\n"); if (isDuplicate == NULL) { - return newNode; } - //else if (isDuplicate != 1) - //{ - // *isDuplicate = 0; - // return newNode; - //} else { return currentNode; @@ -71,29 +62,24 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType } else if ((compareFct(¤tNode->data, &newNode->data) < 0)) { - // printf("compareFct(currentNode->data, newNode->data) < 0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } else if ((compareFct(¤tNode->data, &newNode->data) > 0)) { - // printf("compareFct(currentNode->data, newNode->data) > 0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); } else if ((compareFct(¤tNode->data, &newNode->data) == 0)) { - //duplicate - // printf("duplicate\n"); if (isDuplicate == NULL) { currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } else { - // printf("setDuplicate\n"); *isDuplicate = 1; } } - // printf("passed everything\n"); + return currentNode; } diff --git a/bintreeTests.c b/bintreeTests.c index b5f901b..da78f70 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -17,16 +17,12 @@ void tearDown(void) { static int compareIntEntries(const void *arg1, const void *arg2) { - // printf("in comp\n"); const int *entry1 = (const void *)arg1; const int *entry2 = (const void *)arg2; - // printf("const set\n"); int result = *entry2 - *entry1; - // int result = entry2 - entry1; - // printf("exit comp\n"); return result; } @@ -48,70 +44,41 @@ void test_addToTreeExpandsTreeCorrectly(void) testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); - // printf("add1passed\n"); - testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); - // printf("add2passed\n"); - testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); - // printf("add3passed\n"); - testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); - // printf("add4passed\n"); - testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); - // printf("add5passed\n"); - testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); - // printf("add6passed\n"); - testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); - // printf("add7passed\n"); - // Checking the Tree without Doubles TEST_ASSERT_NOT_NULL(testRoot); TEST_ASSERT_EQUAL_UINT16(score1, testRoot->data); - // printf("node1passed\n"); - TEST_ASSERT_NOT_NULL(testRoot->left); TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left->data); - // printf("node2passed\n"); - TEST_ASSERT_NOT_NULL(testRoot->right); TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right->data); - // printf("node3passed\n"); - TEST_ASSERT_NOT_NULL(testRoot->left->left); TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->data); - // printf("node4passed\n"); - TEST_ASSERT_NOT_NULL(testRoot->left->right); TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right->data); - // printf("node5passed\n"); - TEST_ASSERT_NOT_NULL(testRoot->right->left); TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data); - // printf("node6passed\n"); - TEST_ASSERT_NOT_NULL(testRoot->right->right); TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right->data); - // printf("node7passed\n"); - + // Adding Double testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); TEST_ASSERT_NOT_NULL(testRoot->left->left->left); TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left->data); - // printf("double passed\n"); - + // Trying to add Double while Doubles not Permitted testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, &testIsDouble); TEST_ASSERT_NULL(testRoot->right->right->left); TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); - - //clearTree(testRoot); + //clearTree(testRoot); } From 1c1099439636c8376fa8188e7dd1c48454c6f135 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 01:40:43 +0100 Subject: [PATCH 25/47] clear does not yet work, also TEST_ASSERT_EQUAL datatype is off --- bintreeTests.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bintreeTests.c b/bintreeTests.c index da78f70..6662482 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -77,8 +77,8 @@ void test_addToTreeExpandsTreeCorrectly(void) TEST_ASSERT_NULL(testRoot->right->right->left); TEST_ASSERT_EQUAL_UINT16(1, testIsDouble); - - //clearTree(testRoot); + + // clearTree(testRoot); } From 14fa122f20b2d34f7884e73f08c1053ea8f5cf8c Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 07:22:34 +0100 Subject: [PATCH 26/47] added runbintreeTests.exe to git --- runbintreeTests.exe | Bin 0 -> 102047 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 runbintreeTests.exe diff --git a/runbintreeTests.exe b/runbintreeTests.exe new file mode 100644 index 0000000000000000000000000000000000000000..40861af8ee5f2857e1911fc1d8664469beaa4eda GIT binary patch literal 102047 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⋙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 literal 0 HcmV?d00001 From f7549910eb83dc1637b0f560b309b8ff5d04973a Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 08:09:59 +0100 Subject: [PATCH 27/47] freeing node->data works, freeing node itself does not --- bintree.c | 21 ++++++++++++++++----- bintree.o | Bin 2179 -> 2473 bytes bintreeTests.c | 40 ++++++++++++++++++++++++++++++---------- runbintreeTests.exe | Bin 102047 -> 102878 bytes 4 files changed, 46 insertions(+), 15 deletions(-) diff --git a/bintree.c b/bintree.c index dcb6695..ac81d78 100644 --- a/bintree.c +++ b/bintree.c @@ -1,5 +1,6 @@ #include #include +#include #include "stack.h" #include "bintree.h" @@ -108,22 +109,32 @@ void clearTreeRec(TreeNode *currentNode) if (currentNode != NULL) { clearTree(currentNode->left); - clearNode(currentNode); + clearTree(currentNode->right); + + clearNode(currentNode); } } void clearNode(TreeNode *node) { - free(node->data); + // printf("in clearNode\n"); + printf("node-> data = %u\n", &node->data); + // printf("node-> data = %u\n", _ADDRESSOF(node->data)); + free(&node->data); node->data = NULL; - + printf("node-> data = %u\n", &node->data); + // printf("data freed \n"); node->left = NULL; node->right = NULL; - - free(node); + // printf("left & right = Null\n"); + printf("node = %u\n", &node); + // printf("node = %u\n", _ADDRESSOF(node)); + // free(node); + // printf("node = %d\n", node); node = NULL; + printf("freed node\n"); } diff --git a/bintree.o b/bintree.o index 22e8a0e509a69ea28114f8f2d9f2d2a452055c3d..d098a883d9cb0da14d92fed509e4fb569896df33 100644 GIT binary patch delta 550 zcmZn`Tq(?((#FmJ0s=rvej=~9paU}lgAOAD!wOcgI0Mf_(`?3^i3`<(POvaAD6m09 zC4iIzgMouyQA%P-B18;C8UV2dR3}W-fg!*_-vq{k&;dXyf_393Nha=Y2LX@HgD=+o z|NnpT1ttZ_ZdV}xkVh}r6p#!^hX+t}vJJBYFN(}$Z)RE5-cSLcVj++snBwEE0$@$O ztg=wy$>q$wlbKoO`tD_7V6XrRg6Nk(>;hziXltOiL5|AHPf69aQvmr&!B#=FlnX2Z zWu_ISrlu%>lmJx%!Q{Ox;q_8L1`F6s2&)jtmj;Vj1I-l!vz&n}88FKq$O1Wvg&_kj zTL71x3>TXX7h44v+XQ6Ef%O6j1|A@0W?DgoZ> BU6%j= delta 333 zcmZ1}+$_kO(#FOB0!BbedLpm5AOkZ40}CSqg8(a7oPl+sX*MIv#D(fw2`mf@PEb(^ zpriwXfrGvYL=}t-05T4+Y?fk_WOC>{_(B}W_2_mL@aT3B@Bs1`{r~@ef=BZah1kQP z9-U7;n%^jRbov6NK}r}vDnJH-xyKnM&taD32g$&MkGl#?zQ^1{~Y #include +#include #include "unity.h" #include "bintree.h" @@ -113,6 +114,7 @@ void test_clearTreeworksLikeExpected(void) testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + printf("Tree Filled\n"); // Save all Adresses TreeNode *node1 = testRoot->left; @@ -122,18 +124,36 @@ void test_clearTreeworksLikeExpected(void) TreeNode *node5 = testRoot->right->left; TreeNode *node6 = testRoot->right->right; TreeNode *node7 = testRoot->left->left->left; + printf("Adresses Saved\n"); clearTree(testRoot); + printf("Tree Cleared\n"); // Check if everything has been set to NULL - TEST_ASSERT_NULL(testRoot); - TEST_ASSERT_NULL(node1); - TEST_ASSERT_NULL(node2); - TEST_ASSERT_NULL(node3); - TEST_ASSERT_NULL(node4); - TEST_ASSERT_NULL(node5); - TEST_ASSERT_NULL(node6); - TEST_ASSERT_NULL(node7); + TEST_ASSERT_NULL(testRoot->data); + // TEST_ASSERT_NULL(testRoot); + + TEST_ASSERT_NULL(node1->data); + // TEST_ASSERT_NULL(node1); + + TEST_ASSERT_NULL(node2->data); + // TEST_ASSERT_NULL(node2); + + TEST_ASSERT_NULL(node3->data); + // TEST_ASSERT_NULL(node3); + + TEST_ASSERT_NULL(node4->data); + // TEST_ASSERT_NULL(node4); + + TEST_ASSERT_NULL(node5->data); + // TEST_ASSERT_NULL(node5); + + TEST_ASSERT_NULL(node6->data); + // TEST_ASSERT_NULL(node6); + + TEST_ASSERT_NULL(node7->data); + // TEST_ASSERT_NULL(node7); + } @@ -178,9 +198,9 @@ int main() UNITY_BEGIN(); printf("\n============================\nBinary Tree tests\n============================\n"); - RUN_TEST(test_addToTreeExpandsTreeCorrectly); + // RUN_TEST(test_addToTreeExpandsTreeCorrectly); // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); - // RUN_TEST(test_clearTreeworksLikeExpected); + RUN_TEST(test_clearTreeworksLikeExpected); // RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); diff --git a/runbintreeTests.exe b/runbintreeTests.exe index 40861af8ee5f2857e1911fc1d8664469beaa4eda..41bc99497d9208e6d1cdc62d980d78d0ca581679 100644 GIT binary patch delta 21404 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 RR=u=Vel|b(*`wrb@;^UcnYjP} delta 20921 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 Date: Tue, 9 Dec 2025 08:46:56 +0100 Subject: [PATCH 28/47] further debugging --- bintree.c | 14 ++++++++++++-- bintree.o | Bin 2473 -> 2525 bytes bintreeTests.c | 2 +- runbintreeTests.exe | Bin 102878 -> 102878 bytes 4 files changed, 13 insertions(+), 3 deletions(-) diff --git a/bintree.c b/bintree.c index ac81d78..5fe4a54 100644 --- a/bintree.c +++ b/bintree.c @@ -113,6 +113,15 @@ void clearTreeRec(TreeNode *currentNode) clearTree(currentNode->right); clearNode(currentNode); + /* + printf("1\n"); + free(¤tNode->data); + currentNode->data = NULL; + printf("2\n"); + // free(currentNode); + // currentNode = NULL; + printf("3\n"); + // */ } } @@ -120,11 +129,11 @@ void clearTreeRec(TreeNode *currentNode) void clearNode(TreeNode *node) { // printf("in clearNode\n"); - printf("node-> data = %u\n", &node->data); + // printf("node-> data = %u\n", node->data); // printf("node-> data = %u\n", _ADDRESSOF(node->data)); free(&node->data); node->data = NULL; - printf("node-> data = %u\n", &node->data); + // printf("node-> data = %u\n", &node->data); // printf("data freed \n"); node->left = NULL; node->right = NULL; @@ -134,6 +143,7 @@ void clearNode(TreeNode *node) // free(node); // printf("node = %d\n", node); node = NULL; + printf("node = %u\n", &node); printf("freed node\n"); } diff --git a/bintree.o b/bintree.o index d098a883d9cb0da14d92fed509e4fb569896df33..640ce651664092019f2479c3ee1d3108f6cd74ab 100644 GIT binary patch delta 283 zcmZ1}d{>w=rH!2d1Y9O^N(&}1Gcf2dGBBKA1&cB8O*GAB?3uVwo%IC^14GEfv&xJf z6F;gmR!saTyjh3QjESk6VR9mK32&%?M=z@oP?JaJ!55RyGtcFk00)ydut-d9VQG=P z%*4Q80aOE`{{yiLkPV^(Co8fpO|=8E#DF3!3~oS{444%JWXXbA*>Krnxa>5z*gUw{ wM!48cxYz->*on>JY+D(HK@MPKP+$O3KoA1N|0myPmu3wFdY^CefA&?30C0ykGynhq delta 261 zcmcaByi%AmrH!2d1Oz5>N((wLGcf2dGBB)Q1&cB8Of=1A%$c}Qo%I9@1B1fEv&xJb z6F;gmMoj!Dyjh3QjA`;DX0gfD%(0VSGf$sdata); - // TEST_ASSERT_NULL(testRoot); + TEST_ASSERT_NULL(testRoot); TEST_ASSERT_NULL(node1->data); // TEST_ASSERT_NULL(node1); diff --git a/runbintreeTests.exe b/runbintreeTests.exe index 41bc99497d9208e6d1cdc62d980d78d0ca581679..740be06f7a4c05c737e45a03725ad9668787f1e3 100644 GIT binary patch delta 13276 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 Date: Tue, 9 Dec 2025 09:59:22 +0100 Subject: [PATCH 29/47] debug --- bintree.c | 3 ++- bintree.o | Bin 2525 -> 2421 bytes runbintreeTests.exe | Bin 102878 -> 102878 bytes 3 files changed, 2 insertions(+), 1 deletion(-) diff --git a/bintree.c b/bintree.c index 5fe4a54..6c6c03d 100644 --- a/bintree.c +++ b/bintree.c @@ -56,6 +56,7 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType { return newNode; } + // dosn't consider is Duplicate != Null upon root Null else { return currentNode; @@ -140,7 +141,7 @@ void clearNode(TreeNode *node) // printf("left & right = Null\n"); printf("node = %u\n", &node); // printf("node = %u\n", _ADDRESSOF(node)); - // free(node); + free(node); // printf("node = %d\n", node); node = NULL; printf("node = %u\n", &node); diff --git a/bintree.o b/bintree.o index 640ce651664092019f2479c3ee1d3108f6cd74ab..a7303bbba52a42c24429418bb59cf4cf4c05787c 100644 GIT binary patch delta 331 zcmcaB{8fl6rH!2d1n#g+7U&6$|U;$JJqAvik3y=+>m4L1aU|^UW$tpj&jJ3el5-27E zlw)B?2eQP#tb8C#7R+jbi*>=pCc?#LZuVx|%4iI-f{{Ui0Z0Ks2oQrTf{5sqq*j!G r#X%wr49tum2XIX`=2*`tHqlXZ@(&IdwzQ(uRG^a#IOQfMaMl6|;{TIZvrDsr hoXsf2Bz4mbSKIg!9 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 delta 13428 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 A1poj5 From 8deeb6417ed9ac0014535e6d98ef386569f71bf1 Mon Sep 17 00:00:00 2001 From: Jens Burger Date: Tue, 9 Dec 2025 10:31:12 +0100 Subject: [PATCH 30/47] Testfunktion auf Unity umgebaut --- LICENSE.txt | 21 + test_stack.c | 57 +- unity.c | 2622 +++++++++++++++++++++++++++++++++++++++++++++ unity.h | 698 ++++++++++++ unity_internals.h | 1271 ++++++++++++++++++++++ 5 files changed, 4658 insertions(+), 11 deletions(-) create mode 100644 LICENSE.txt create mode 100644 unity.c create mode 100644 unity.h create mode 100644 unity_internals.h diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..3e3aad5 --- /dev/null +++ b/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/test_stack.c b/test_stack.c index 26a219f..34407f6 100644 --- a/test_stack.c +++ b/test_stack.c @@ -1,7 +1,18 @@ #include #include +#include "unity.h" #include "stack.h" +void setUp(void) { + // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden +} + +void tearDown(void) { + // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden +} + + + void testeStackBeschreiben() { printf("=== Test: push() ===\n"); @@ -11,14 +22,18 @@ void testeStackBeschreiben() stack = push(stack, &wert1); int *topValue = (int *)(stack->data); - if(topValue != NULL && *topValue == 42) + + TEST_ASSERT_NOT_NULL(topValue); + TEST_ASSERT_EQUAL_INT(42, topValue); + + /*if(topValue != NULL && *topValue == 42) { printf("Test 1: Erstes Element erfolgreich gepusht!\n"); } else { printf("Test 1: FEHLGESCHLAGEN!\n"); - } + }*/ int wert2 = 12; @@ -27,14 +42,19 @@ void testeStackBeschreiben() topValue = (int *)(stack->data); int *secondValue = (int *)((stack->next)->data); - if(topValue != NULL && *topValue == 12.25 && secondValue != NULL && *secondValue == 42) + TEST_ASSERT_NOT_NULL(topValue); + TEST_ASSERT_EQUAL_INT(12, topValue); + TEST_ASSERT_NOT_NULL(secondValue); + TEST_ASSERT_EQUAL_INT(42, secondValue); + + /*if(topValue != NULL && *topValue == 12 && secondValue != NULL && *secondValue == 42) { printf("Test 2: Zweites Element erfolgreich gepusht!\n"); } else { printf("Test 2: FEHLGESCHLAGEN!\n"); - } + }*/ printf("=== Ende Test: push() ===\n\n"); @@ -56,14 +76,17 @@ void testepop() int *topValue = (int *)(stack->data); - if(topValue != NULL && *topValue == 20) + TEST_ASSERT_NOT_NULL(topValue); + TEST_ASSERT_EQUAL_INT(20, topValue); + + /*if(topValue != NULL && *topValue == 20) { printf("Test: Erstes Element erfolgreich gelöscht!\n"); } else { printf("Test 1: FEHLGESCHLAGEN!\n"); - } + }*/ printf("=== Ende Test: pop() ===\n\n"); } @@ -81,14 +104,17 @@ void testetop() int *topValue = top(stack); - if(topValue != NULL && *topValue == 74) + TEST_ASSERT_NOT_NULL(topValue); + TEST_ASSERT_EQUAL_INT(74, topValue); + + /*if(topValue != NULL && *topValue == 74) { printf("Test: top() gibt korrektes Element zurück!\n"); } else { printf("Test: FEHLGESCHLAGEN!\n"); - } + }*/ printf("=== Ende Test: top() ===\n\n"); } @@ -112,10 +138,19 @@ void testeclearStack() int main() { - testeStackBeschreiben(); + UNITY_BEGIN(); + + //printf("..."); + + RUN_TEST(testeStackBeschreiben); + RUN_TEST(testepop); + RUN_TEST(testetop); + RUN_TEST(testeclearStack); + + /*testeStackBeschreiben(); testepop(); testetop(); - testeclearStack(); + testeclearStack();*/ - return 0; + return UNITY_END(); } \ No newline at end of file diff --git a/unity.c b/unity.c new file mode 100644 index 0000000..3ea455d --- /dev/null +++ b/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.h b/unity.h new file mode 100644 index 0000000..7c749c2 --- /dev/null +++ b/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_internals.h b/unity_internals.h new file mode 100644 index 0000000..a66859a --- /dev/null +++ b/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 From 53c12ce0edf7143897dbf06007bf1ecbe2801b7a Mon Sep 17 00:00:00 2001 From: Jens Burger Date: Tue, 9 Dec 2025 10:38:00 +0100 Subject: [PATCH 31/47] added makefile command --- makefile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/makefile b/makefile index 1f15f75..b7019df 100644 --- a/makefile +++ b/makefile @@ -38,6 +38,11 @@ $(program_obj_filesobj_files): %.o: %.c unitTests: echo "needs to be implemented" +stack: stack.c + $(CC) $(FLAGS) -c stack stack.c + +test_stack: stack.o test_stack.c $(unityfolder)/unity.c + $(CC) $(FLAGS) -o runstackTests test_stack.c stack.o $(unityfolder)/unity.c # -------------------------- # Clean # -------------------------- From 79a6eb72676cf96238820ed944e6169ad5812bb5 Mon Sep 17 00:00:00 2001 From: Jens Burger Date: Tue, 9 Dec 2025 10:41:53 +0100 Subject: [PATCH 32/47] Debugging Unity Aufruf --- test_stack.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/test_stack.c b/test_stack.c index 34407f6..9e1dbd1 100644 --- a/test_stack.c +++ b/test_stack.c @@ -15,7 +15,7 @@ void tearDown(void) { void testeStackBeschreiben() { - printf("=== Test: push() ===\n"); + //printf("=== Test: push() ===\n"); StackNode *stack = NULL; int wert1 = 42; @@ -24,7 +24,7 @@ void testeStackBeschreiben() int *topValue = (int *)(stack->data); TEST_ASSERT_NOT_NULL(topValue); - TEST_ASSERT_EQUAL_INT(42, topValue); + TEST_ASSERT_EQUAL_INT(42, *topValue); /*if(topValue != NULL && *topValue == 42) { @@ -43,9 +43,9 @@ void testeStackBeschreiben() int *secondValue = (int *)((stack->next)->data); TEST_ASSERT_NOT_NULL(topValue); - TEST_ASSERT_EQUAL_INT(12, topValue); + TEST_ASSERT_EQUAL_INT(12, *topValue); TEST_ASSERT_NOT_NULL(secondValue); - TEST_ASSERT_EQUAL_INT(42, secondValue); + TEST_ASSERT_EQUAL_INT(42, *secondValue); /*if(topValue != NULL && *topValue == 12 && secondValue != NULL && *secondValue == 42) { @@ -57,13 +57,13 @@ void testeStackBeschreiben() }*/ - printf("=== Ende Test: push() ===\n\n"); + //printf("=== Ende Test: push() ===\n\n"); return; } void testepop() { - printf("=== Test: pop() ===\n"); + //printf("=== Test: pop() ===\n"); StackNode *stack = NULL; int wert1 = 20; @@ -77,7 +77,7 @@ void testepop() int *topValue = (int *)(stack->data); TEST_ASSERT_NOT_NULL(topValue); - TEST_ASSERT_EQUAL_INT(20, topValue); + TEST_ASSERT_EQUAL_INT(20, *topValue); /*if(topValue != NULL && *topValue == 20) { @@ -88,12 +88,12 @@ void testepop() printf("Test 1: FEHLGESCHLAGEN!\n"); }*/ - printf("=== Ende Test: pop() ===\n\n"); + //printf("=== Ende Test: pop() ===\n\n"); } void testetop() { - printf("=== Test: top() ===\n"); + //printf("=== Test: top() ===\n"); StackNode *stack = NULL; int wert1 = 20; @@ -105,7 +105,7 @@ void testetop() int *topValue = top(stack); TEST_ASSERT_NOT_NULL(topValue); - TEST_ASSERT_EQUAL_INT(74, topValue); + TEST_ASSERT_EQUAL_INT(74, *topValue); /*if(topValue != NULL && *topValue == 74) { @@ -116,12 +116,12 @@ void testetop() printf("Test: FEHLGESCHLAGEN!\n"); }*/ - printf("=== Ende Test: top() ===\n\n"); + //printf("=== Ende Test: top() ===\n\n"); } void testeclearStack() { - printf("=== Test: clearStack() ===\n"); + //printf("=== Test: clearStack() ===\n"); StackNode *stack = NULL; int wert1 = 20; @@ -132,8 +132,8 @@ void testeclearStack() clearStack(stack); - printf("Test: clearStack() aufgerufen. Speicher freigegeben.\n"); - printf("=== Ende Test: clearStack() ===\n\n"); + //printf("Test: clearStack() aufgerufen. Speicher freigegeben.\n"); + //printf("=== Ende Test: clearStack() ===\n\n"); } int main() From 01bc6131899a5ea8cbf5097a4d75019fcc71b281 Mon Sep 17 00:00:00 2001 From: Jens Burger Date: Tue, 9 Dec 2025 10:45:10 +0100 Subject: [PATCH 33/47] =?UTF-8?q?Kommentare=20gel=C3=B6scht?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test_stack.c | 36 ------------------------------------ 1 file changed, 36 deletions(-) diff --git a/test_stack.c b/test_stack.c index 9e1dbd1..2576f65 100644 --- a/test_stack.c +++ b/test_stack.c @@ -26,15 +26,6 @@ void testeStackBeschreiben() TEST_ASSERT_NOT_NULL(topValue); TEST_ASSERT_EQUAL_INT(42, *topValue); - /*if(topValue != NULL && *topValue == 42) - { - printf("Test 1: Erstes Element erfolgreich gepusht!\n"); - } - else - { - printf("Test 1: FEHLGESCHLAGEN!\n"); - }*/ - int wert2 = 12; stack = push(stack, &wert2); @@ -47,15 +38,6 @@ void testeStackBeschreiben() TEST_ASSERT_NOT_NULL(secondValue); TEST_ASSERT_EQUAL_INT(42, *secondValue); - /*if(topValue != NULL && *topValue == 12 && secondValue != NULL && *secondValue == 42) - { - printf("Test 2: Zweites Element erfolgreich gepusht!\n"); - } - else - { - printf("Test 2: FEHLGESCHLAGEN!\n"); - }*/ - //printf("=== Ende Test: push() ===\n\n"); return; @@ -79,15 +61,6 @@ void testepop() TEST_ASSERT_NOT_NULL(topValue); TEST_ASSERT_EQUAL_INT(20, *topValue); - /*if(topValue != NULL && *topValue == 20) - { - printf("Test: Erstes Element erfolgreich gelöscht!\n"); - } - else - { - printf("Test 1: FEHLGESCHLAGEN!\n"); - }*/ - //printf("=== Ende Test: pop() ===\n\n"); } @@ -107,15 +80,6 @@ void testetop() TEST_ASSERT_NOT_NULL(topValue); TEST_ASSERT_EQUAL_INT(74, *topValue); - /*if(topValue != NULL && *topValue == 74) - { - printf("Test: top() gibt korrektes Element zurück!\n"); - } - else - { - printf("Test: FEHLGESCHLAGEN!\n"); - }*/ - //printf("=== Ende Test: top() ===\n\n"); } From 72f1d080a0e4c818fdaf191c59b050dcc1ce98ce Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 11:10:29 +0100 Subject: [PATCH 34/47] adToTree working again --- bintree.c | 19 +++++++++++-------- bintree.o | Bin 2421 -> 2535 bytes bintreeTests.c | 37 +++++++++++++++++++------------------ runbintreeTests.exe | Bin 102878 -> 102366 bytes 4 files changed, 30 insertions(+), 26 deletions(-) diff --git a/bintree.c b/bintree.c index 6c6c03d..c55d660 100644 --- a/bintree.c +++ b/bintree.c @@ -41,7 +41,7 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc newNode->data = calloc(1, dataSize); newNode->left = NULL; newNode->right = NULL; - memcpy(&newNode->data, data, dataSize); + memcpy(newNode->data, data, dataSize); return addToTreeRec(root, newNode, compareFct, isDuplicate); @@ -52,26 +52,29 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType { if ((currentNode == NULL)) { + // printf("Node == NULL\n"); if (isDuplicate == NULL) { return newNode; } - // dosn't consider is Duplicate != Null upon root Null else { return currentNode; } } - else if ((compareFct(¤tNode->data, &newNode->data) < 0)) + else if ((compareFct(currentNode->data, newNode->data) < 0)) { + // printf("<0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); } - else if ((compareFct(¤tNode->data, &newNode->data) > 0)) + else if ((compareFct(currentNode->data, newNode->data) > 0)) { + // printf(">0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); } - else if ((compareFct(¤tNode->data, &newNode->data) == 0)) + else if ((compareFct(currentNode->data, newNode->data) == 0)) { + // printf("==0\n"); if (isDuplicate == NULL) { currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); @@ -132,7 +135,7 @@ void clearNode(TreeNode *node) // printf("in clearNode\n"); // printf("node-> data = %u\n", node->data); // printf("node-> data = %u\n", _ADDRESSOF(node->data)); - free(&node->data); + free(node->data); node->data = NULL; // printf("node-> data = %u\n", &node->data); // printf("data freed \n"); @@ -144,8 +147,8 @@ void clearNode(TreeNode *node) free(node); // printf("node = %d\n", node); node = NULL; - printf("node = %u\n", &node); - printf("freed node\n"); + // printf("node = %u\n", &node); + // printf("freed node\n"); } diff --git a/bintree.o b/bintree.o index a7303bbba52a42c24429418bb59cf4cf4c05787c..707274c8e5ecaee5bdf934b681041b4a312b3296 100644 GIT binary patch delta 780 zcmew=^jw%LrH!2d1pL@1a!Cm$Ff%adFfuTlUw!u;pc%X%y-+hIFJzLl$@%~PzejhdfJdhj z$IJa7S)h^F4XCpQ8X$mdKm?PVr4YgZf!7(hb(i`8bqgcwp2eifwB_IAgG>vVx)~-X zG8@T=BT0jO0Q2o}SAoe#nL8&hV3C+y!s1as2dEGPKr|Z@0|O6~76h^-fNT(L0K^JF zHi#|*VjUnGL_Y#z3m_Xr^8us81;_@`py&wzviCvD80-ufY;6q~ z^1#9hs-;{E3_zWeby@T4OMuFyftZD1ACMFSvyK5t88C|p7#$EXE+7jc76TUp#w=89 zGhA#pT&x#pg)G>V-9Q$^l*2%l99Zl;M0WE_)=)-pSTHgufE)z`YCsGM5rl{_Py`en z2oYPL2q;t#B3?idP}o33N{UibgEOmAK_P@t69QBN3MYt&UP)>N$omYF_p)=cg2Ik} e@@e+H7{5XYz6 zRl%e4pyU4wtp_UgCtESeWls42|G!6fsDMYO6UWP`IMmkZfOLCwJAh2k@aXnc0BVu& z?L6q&c>-wO3vYxW0Eo^fV7eFR zkY2FI;ZnV<+)$O1nOQpdCZK@H7g!`FFJbYhp9#_q1R#1VF!Xq!^Z_7S0>}o@_kmae z$Oh4>Ou$eEvO)9`AhrOqLG%S6b^)?Mv=T5T0)Xti{FGD$TLslpE{3$C)YKFOkN{8| z2Hc&UCs(s3dKUr(q=A@)!4jxj2Fywavc$lwd>~5}%xZ#*b-~3Z!o_9+S#p~r*}@sY zo?-+#87Kk-YCsI~8bZVvC<5{rLc|s*0`eY0#0w|_@+3s01nBdata); + TEST_ASSERT_EQUAL(score1, *(int *)testRoot->data); + TEST_ASSERT_NOT_NULL(testRoot->left); - TEST_ASSERT_EQUAL_UINT16(score2, testRoot->left->data); + TEST_ASSERT_EQUAL(score2, *(int *)testRoot->left->data); TEST_ASSERT_NOT_NULL(testRoot->right); - TEST_ASSERT_EQUAL_UINT16(score3, testRoot->right->data); + TEST_ASSERT_EQUAL(score3, *(int *)testRoot->right->data); TEST_ASSERT_NOT_NULL(testRoot->left->left); - TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->data); + TEST_ASSERT_EQUAL(score4, *(int *)testRoot->left->left->data); TEST_ASSERT_NOT_NULL(testRoot->left->right); - TEST_ASSERT_EQUAL_UINT16(score5, testRoot->left->right->data); + TEST_ASSERT_EQUAL(score5, *(int *)testRoot->left->right->data); TEST_ASSERT_NOT_NULL(testRoot->right->left); - TEST_ASSERT_EQUAL_UINT16(score6, testRoot->right->left->data); + TEST_ASSERT_EQUAL(score6, *(int *)testRoot->right->left->data); TEST_ASSERT_NOT_NULL(testRoot->right->right); - TEST_ASSERT_EQUAL_UINT16(score7, testRoot->right->right->data); - + TEST_ASSERT_EQUAL(score7, *(int *)testRoot->right->right->data); + // Adding Double testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); TEST_ASSERT_NOT_NULL(testRoot->left->left->left); - TEST_ASSERT_EQUAL_UINT16(score4, testRoot->left->left->left->data); + TEST_ASSERT_EQUAL_UINT16(score4, *(int *)testRoot->left->left->left->data); // Trying to add Double while Doubles not Permitted testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, &testIsDouble); @@ -105,7 +106,6 @@ void test_clearTreeworksLikeExpected(void) int score7 = 21; - // Fill Tree testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); @@ -113,17 +113,18 @@ void test_clearTreeworksLikeExpected(void) testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); - testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); printf("Tree Filled\n"); // Save all Adresses - TreeNode *node1 = testRoot->left; + void *node1 = testRoot->left; + /* TreeNode *node2 = testRoot->left->left; TreeNode *node3 = testRoot->left->right; TreeNode *node4 = testRoot->right; TreeNode *node5 = testRoot->right->left; TreeNode *node6 = testRoot->right->right; TreeNode *node7 = testRoot->left->left->left; + */ printf("Adresses Saved\n"); clearTree(testRoot); @@ -131,11 +132,11 @@ void test_clearTreeworksLikeExpected(void) // Check if everything has been set to NULL TEST_ASSERT_NULL(testRoot->data); - TEST_ASSERT_NULL(testRoot); + //TEST_ASSERT_NULL(testRoot); - TEST_ASSERT_NULL(node1->data); + //TEST_ASSERT_NULL(node1->data); // TEST_ASSERT_NULL(node1); - + /* TEST_ASSERT_NULL(node2->data); // TEST_ASSERT_NULL(node2); @@ -153,7 +154,7 @@ void test_clearTreeworksLikeExpected(void) TEST_ASSERT_NULL(node7->data); // TEST_ASSERT_NULL(node7); - + // */ } @@ -198,9 +199,9 @@ int main() UNITY_BEGIN(); printf("\n============================\nBinary Tree tests\n============================\n"); - // RUN_TEST(test_addToTreeExpandsTreeCorrectly); + RUN_TEST(test_addToTreeExpandsTreeCorrectly); // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); - RUN_TEST(test_clearTreeworksLikeExpected); + // RUN_TEST(test_clearTreeworksLikeExpected); // RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); diff --git a/runbintreeTests.exe b/runbintreeTests.exe index c9a5f87eac2604a789d88717676ff6e255c2cb22..1e05d197464c837c505071d9e934f58cab853339 100644 GIT binary patch delta 18738 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 E08n3d_W%F@ delta 19476 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 Date: Tue, 9 Dec 2025 11:19:56 +0100 Subject: [PATCH 35/47] addToTree corrected --- bintree.c | 14 +++++++------- bintree.o | Bin 2535 -> 2389 bytes bintreeTests.c | 12 ++++++------ runbintreeTests.exe | Bin 102366 -> 102366 bytes 4 files changed, 13 insertions(+), 13 deletions(-) diff --git a/bintree.c b/bintree.c index c55d660..71ed18a 100644 --- a/bintree.c +++ b/bintree.c @@ -21,7 +21,7 @@ unsigned int treeSize (const TreeNode *root); // self declared functions - TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate); + TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root); void clearTreeRec (TreeNode *currentNode); void clearNode (TreeNode *node); void treeSizeRec (const TreeNode *currentNode, unsigned int *nodeCount); @@ -44,16 +44,16 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc memcpy(newNode->data, data, dataSize); - return addToTreeRec(root, newNode, compareFct, isDuplicate); + return addToTreeRec(root, newNode, compareFct, isDuplicate, 1); } -TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate) +TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root) { if ((currentNode == NULL)) { // printf("Node == NULL\n"); - if (isDuplicate == NULL) + if ((isDuplicate == NULL) || root) { return newNode; } @@ -65,19 +65,19 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType else if ((compareFct(currentNode->data, newNode->data) < 0)) { // printf("<0\n"); - currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); + currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0); } else if ((compareFct(currentNode->data, newNode->data) > 0)) { // printf(">0\n"); - currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate); + currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate, 0); } else if ((compareFct(currentNode->data, newNode->data) == 0)) { // printf("==0\n"); if (isDuplicate == NULL) { - currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate); + currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0); } else { diff --git a/bintree.o b/bintree.o index 707274c8e5ecaee5bdf934b681041b4a312b3296..c1bf070f65fb88afd4622174be48130879dd9f6a 100644 GIT binary patch delta 698 zcmaDZd{u}yrH!2d1kSNBFvv~h6&DO(W?;}^WMG)V3KnNzpJYV3M+|GzalL zx*a%tx?MFqx_uQqxF@S*q%nq77 zkHxQk3CQt40HQwty~+cne*@VPKsJb$Vq#!W0J1@J0ubu}*&zB15L*D*Ao>Roy8ziB z+6x$AKwB8{@>5b3Y!y^XxquuXaCdgLQqZWdFpD=c(Jja?&aBX#+|3%TTn^MD1C(cB zSPEo`fmv&TELkvXCrEa4BwIKm*s+X2rvOEOKn;jNPDY3r14Td%Mu^w~ML^C*hdDDyFy+{SY;*TOoPbz}{fFL$_>e)m3on74(tPf`Ao6k(X`*!B*@Q+fl^&n4t znn(x2;^@$&3{h1OZRR3QgW=Q_@i2Tksc&V8=JoJnIcK9J!|h426mFN)XJM+ESR7~s z8>fOz8EkCnsH<{zWXcWdmK!uG^8Q_e+7-DHnQ{x8gI1{BCp&esJAqe17~OH9E^1@W z?HM!|x#>?cin4Q};CAX2*=bm^GiRo6yxQyaKnxko7P@cMyjGq*4g=#~17mlC;ncwR zxuBkF`;WRXDE(~^UAM}&{QpH>s9#!HSZZJ9r5IITGSAeztf?MlRzFyFSh-gsJ<#Z-T|hwp~(OM diff --git a/bintreeTests.c b/bintreeTests.c index 8e33e98..40fdc05 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -116,15 +116,15 @@ void test_clearTreeworksLikeExpected(void) printf("Tree Filled\n"); // Save all Adresses - void *node1 = testRoot->left; - /* + TreeNode *node1 = testRoot->left; + TreeNode *node2 = testRoot->left->left; TreeNode *node3 = testRoot->left->right; TreeNode *node4 = testRoot->right; TreeNode *node5 = testRoot->right->left; TreeNode *node6 = testRoot->right->right; TreeNode *node7 = testRoot->left->left->left; - */ + printf("Adresses Saved\n"); clearTree(testRoot); @@ -132,7 +132,7 @@ void test_clearTreeworksLikeExpected(void) // Check if everything has been set to NULL TEST_ASSERT_NULL(testRoot->data); - //TEST_ASSERT_NULL(testRoot); + TEST_ASSERT_NULL(testRoot); //TEST_ASSERT_NULL(node1->data); // TEST_ASSERT_NULL(node1); @@ -199,9 +199,9 @@ int main() UNITY_BEGIN(); printf("\n============================\nBinary Tree tests\n============================\n"); - RUN_TEST(test_addToTreeExpandsTreeCorrectly); + // RUN_TEST(test_addToTreeExpandsTreeCorrectly); // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); - // RUN_TEST(test_clearTreeworksLikeExpected); + RUN_TEST(test_clearTreeworksLikeExpected); // RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); diff --git a/runbintreeTests.exe b/runbintreeTests.exe index 1e05d197464c837c505071d9e934f58cab853339..a66c8f71ea137301dd21344ce475b654de298c29 100644 GIT binary patch delta 17654 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 P{)tc5>uHP0p3wgT`3iW~ delta 17071 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 B;?n>C From 8754182f79bb7b6b2fa602b8eaa00351b03898e9 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 17:51:11 +0100 Subject: [PATCH 36/47] clear Tree and test now working corectly --- bintree.c | 5 ++++- bintree.o | Bin 2389 -> 2243 bytes bintreeTests.c | 35 +++++++++++++++++------------------ runbintreeTests.exe | Bin 102366 -> 102047 bytes 4 files changed, 21 insertions(+), 19 deletions(-) diff --git a/bintree.c b/bintree.c index 71ed18a..3ecf028 100644 --- a/bintree.c +++ b/bintree.c @@ -135,18 +135,21 @@ void clearNode(TreeNode *node) // printf("in clearNode\n"); // printf("node-> data = %u\n", node->data); // printf("node-> data = %u\n", _ADDRESSOF(node->data)); + // printf("data = %p\n", node->data); free(node->data); node->data = NULL; + // printf("data = %p\n", node->data); // printf("node-> data = %u\n", &node->data); // printf("data freed \n"); node->left = NULL; node->right = NULL; // printf("left & right = Null\n"); - printf("node = %u\n", &node); + // printf("node = %p\n", node); // printf("node = %u\n", _ADDRESSOF(node)); free(node); // printf("node = %d\n", node); node = NULL; + // printf("node = %p\n", node); // printf("node = %u\n", &node); // printf("freed node\n"); } diff --git a/bintree.o b/bintree.o index c1bf070f65fb88afd4622174be48130879dd9f6a..96c8f39a5e111e8ddb6c6941f742f92a26006228 100644 GIT binary patch delta 234 zcmcaAbXbr#rHzdN1d4!^^h929K?i0A1{OvJh5%NuI0NfM(`-hUi3`;=7qBoeG(klr zfRYXj1`hfr5LGZT0K}O1QFyZs<9w#c_n7BRu4I`nyOW85!2&1&qMrh>3y=+>&4G3W zOm<}r*94iz0#*ZIl>qsYV6k$bIw>$~8Hly{ChJBscvXlurH!2d1kSNBFvv~h6&DO(W?;}^WMG)V3KnNzpJ0=fsJIWIpYRl!z4wUi6Unf#X}+*S(6U;*oa zuu6b@X|Py1P@fE#wG_w_1GClwS+Zc(PLS;8TGow>!XV2S859_R6cB^}@sG)l?9!|t tOW7wUvd5b7?>HkCpwC9CIFcrz&@Fq!left; + // Save all Adresses + TreeNode *node2 = testRoot->left->left; + TreeNode *node3 = testRoot->left->right; + TreeNode *node4 = testRoot->right; + TreeNode *node5 = testRoot->right->left; + TreeNode *node6 = testRoot->right->right; + TreeNode *node7 = testRoot->left->left->left; - TreeNode *node2 = testRoot->left->left; - TreeNode *node3 = testRoot->left->right; - TreeNode *node4 = testRoot->right; - TreeNode *node5 = testRoot->right->left; - TreeNode *node6 = testRoot->right->right; - TreeNode *node7 = testRoot->left->left->left; - - printf("Adresses Saved\n"); - - clearTree(testRoot); - printf("Tree Cleared\n"); + // printf("Adresses Saved\n"); + clearTree(testRoot); + // printf("Tree Cleared\n"); + // Check if everything has been set to NULL TEST_ASSERT_NULL(testRoot->data); - TEST_ASSERT_NULL(testRoot); + //TEST_ASSERT_NULL(testRoot); //TEST_ASSERT_NULL(node1->data); // TEST_ASSERT_NULL(node1); - /* + TEST_ASSERT_NULL(node2->data); // TEST_ASSERT_NULL(node2); @@ -199,7 +198,7 @@ int main() UNITY_BEGIN(); printf("\n============================\nBinary Tree tests\n============================\n"); - // RUN_TEST(test_addToTreeExpandsTreeCorrectly); + RUN_TEST(test_addToTreeExpandsTreeCorrectly); // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); RUN_TEST(test_clearTreeworksLikeExpected); // RUN_TEST(test_treeSizeWorkingLikeExpected); diff --git a/runbintreeTests.exe b/runbintreeTests.exe index a66c8f71ea137301dd21344ce475b654de298c29..f671fdfa5778998b781f48531b1d936a3cda9c31 100644 GIT binary patch delta 17417 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∈&p8z6=#qa-SGVY_OcoZ<@ox?g7px+l zcE1aMP{#u&@n@g!9Z2M3^XVT4A_jU}S#$iPT&udTS_}7cnIk&=pcnr7bos$rS9Ok+ z=`XbR;2`o84LVe-{vz8-(LPeDcI&VphO8ng`(}GxCOvoPHP@?|R#uzoqpuA|r<{JR zR(*H4l_EP+sqR3h9(E=dXwBg&wU4#MtHTuwH8IjYXp=Im>YvMyw4082@^0z$xg$L( z4e3_uPppO9VOAQ^S~yADUmr-W)9%-okajw??Era?s@_N>KhcNYh#dH4s-+(Go)nA3 zFSZumOJTW)2Tb1gS@m8AO<5^V4k@M=7b6@jiL+JdYRqE%5SXo5J z(vjzdf3~Nj=_~#!ri& zOWzqwnrZtxBguYhcdD45A4bbg<)dStKNTl*dEoe>*PE@M<87>Qa(Vn5#q+`R z#LeKXHv)xnoV4w9&Ck)S(_Z>H3O)G2&(Y}3UO?zt|C>?h=j@x&=<|8_Zlx_ZquF4b zfP&JifOb;HThSQHgj>;UV5i)Q!YDrq0Ykq3Rur26^I?3H{s9crC9Ee3Tkz7JXlxto z`x1S&Cz{9X-2p{Ay$uXqV6c%AsZ!}ys;` z#)loCa;>;JoJ&B8VaF~vb|eZ_72z&CjAkP9hgy(MyaukSeh&A$0AWz}CX|d@B(vfJ5sIUtDNaFIXjM%~` zNV7H?4rDo=xh;++0Xa0x8d(m+Ww`jY6A9Dr$+Xt&hbAD)8aV-Em<@6c$VD5Z6Udru z>ssFc`Q8TU1+sCZwGHotH5Orp$`;S7Ta&kVwr7sX$g~f%i@Ti37g+CWT*v})OT6Yn z+K9jStSbp8J>omASnct-;vH9#Oj^YlwS*R_VG|}2H%RSbwg(9pb#6pQ28u0K&}9at ziJ|T!oNvz+;|7p0SkH4u-7GN(l}IP6yMW9Q56aR&0?NE z+H_bv;*V&T#Kr(b>k$tIkQC4OF%L%T5q}Lpe|#?P3q+i(F>;)qK(y%JBL4VB!dTC# zv!uFgpWBW-*@^9Q>Eihy?8$$MlYEH8csC+@JkL4-FZCO@F*bRqam41| zX@mFyaVxQ|HPi=Cs~Ix2y;f9*lQzD97c~i(@85R|U(_YS9)bIdH?@efMI0Oh zN18HeImssLV-R7d7&!=vELnjCwg{s5^guE}{3(X`ZySUYaE}-oiy2a1CXaJ7^S>8L4}Cd37DkOcI1)~DPlu{v2#lUiA|58- z3IqBNwE*Su05)3zp9A1~rD-(^J6vWW)+Q(FlS#h#aRL^Hi>OWkWY%Op1kL_LvQTtL zwYVLV1h*TlfDZwX05K#1Sq)9bXm(k-eu`AdUd^E7^@S98<#EP(VhLz{d#=WtVQK&1 z;$~OXRbe_Rlge!*s_I5roNr;k`&NK+4uITzi^UTU0;*he950T~#b9jKpf+y$gU0 z6SH;L2HS0h`i>5oahA+1YALsi1;}l`m8Zppu%E{4!^JCw=+v8IEzO)i8p_9IXQ#%I zSTrAAbYjjJjKmAYQa+fi3&gc zi#N!Cw86EP5#6?OOYIR8F%jY?|IN&On`zVjPCIN8v{`?rJ;t=UztavaM|XsZ`f_%K zvF(Y($>@n8N>5mHQh)cKf?Ha)xM~WHuj0wLjQNX|?%2MqJ!Ik?ywHFXp;#O=6G-EWE3%qx0&cR zSsYkN{)8A=1!q0tR1jV@S=?Gh%5fd;u0o{EqIxDsy_hr;OI0gA!lW$m#hIwlDSkGS zJVh>x)w9St-gmP2!z{$)M8DavsT7CLhRt4a`E0Td&UlAbICf-9`plcb!EZzoKV#NZ{=pkF65r9lfOirj2NR5r7 zrOXkkz?YKr79g`(2s82ykYYSjT0DOTq*l?(o_m1cKSQmJ{sPo#(+=k_TncTfMFJ@X z0y8Ci3Xr=t{ZRzuuuZKBAo1pA%)tvHsJX6k&fjX<)xfBS;Kxj<>YAgI7m>r7qdr^6 GdGfz}Tz&Nb delta 17727 zcmbVyd0bZ2_V?Kb4l)Q2vyAdEk1C^}G7s`F$)lj)fP#YafC{FTJ|^ZBAMt{_JXThe zR%%X#=8zetrm4TeuJ>l%2AUtQmYCkOw0OV!obycn-rhf6KA+86>$}!oYwfj%v(JH- zUauC$}0kRMdmajn>`Uf|3>eH^!~BiNs6Nj8~HJ4hsPrN>A) zsizKnB-uq1_;X|%{f#dt&(k8Cax$muS(|Ho`pb_@L1H2}{O>Z6@WA9CBX@h-mM8tUb zY-=Q%*4u_eXp36=idt<0H2TUwPSbiy({kG0@SpK?ue~psML)0)=ihOpKiO+ZIn8tk zrM{ykM_R)n`KI?%$Ba;8F&v$F%FS?U7lZiI-)Ah3pD_uOc)4s)?6vdn{z8KMz?aJ7xy5Q8(7q<$5_b zEmdM8kBw{!+Jv);YPnIR=QK}sH+ddk&!(zPcwEuPBtv8?6{^3r{zp-&FS%)*6%efH`Rs}!=Y~zHcgk!>sf8v1PU>c zMF}lt&Mq-$ZNf*A(fi<@deGm`)Vd^`aeG*wmNV*_(^Tgf=G}oVQbF_uYHYA$s1Ij& zf*$i6#jA_Ee)S|gU!bACc}Ik`jdz8w$XaH9$`F(fsxQFmIc2cXfInB@ibJB#$BPyW zT28wM4I>L^-yrY238Ojg*b?To6x@w6)=Bj?m+si?eQXMYQ<%X*#>Fy&I2jFMD2{K= z;5C{S`Mfb{b^(+NS#elzXJhZNfMxfE%z(L<3{39hnSta!f*C08{TM2_cP*e}e3y{z z^pvm9xE74+#xyKfS5tsSKyrYYOqt7+Cg&AQDLF4<%5XXN42DY1lk#b-pD*u|Pe=RZ zJAIO8#Lv@b{Bp>8`l;V@VoLf?mCFp1wRdoP0pf4KDE7 zFqsWN9^>a2Bhd?GlWA~JSw##qE1gwCgFa3U@+?*)7L zZ%Ai*Pxx$|ycJu1?e9M}l9?__rybtjI=%2JQ|Yl`v5uZXV%WGN*>whDzR5ZsZrA~X zqriB;!0TJAD?7-+Z)JQ-H?BZ}9_)<*U>jw9b0qFtQyH%pQW=43e>qad#Y$Pe_TT>g z8}2YDWCpUIbjF?&azNM**i3~z<_OthbWd=vT7?G7V5RSHZ4dSG zJ%V!HP{GGrirqnG*CrgNCqsRL*F%eQ#)rjS2Zh|T(b#8R1-%y<#g|pk;IKiuFu?lp zYS>G&G0kM}WVE+aV%W+tTom!Yccj#OxTbJ9z_k%ZPf}zrlc!TqNZFnkCy(klx+*hE z?ZaH@OR0|Za#%RoO7DdwlP76hcz*N~Pr~-8?&g6g;&Pd9@;Oe}oU{px7=SyjUdVWw zJ{ul}HGDFBFfQI-gvY4AUc+(B&S?BSWZAfja$J88C1HaQ(y4F*~;w(QpE!r{a;c9c7`!a8i zbBh5|oOh{D)FSdd-4GQ?zMu!Ae1?5DM$#F!-s1x3p$wS6-K zf1vlGqW#aWvQF(1WZD07bX4@v=oTg`_14L}Ihkc9bZb&d6R7}f<1n>ik>4G6q0TnB(omWAYlMUZQ z-yCw2d_`XzI+%3RcZWV3z4bBkFt^COd6=yXkcL^ck?Mx|rXFIKD2(s}gES;*wEpY} zI47jQ)^bQAOnnDzq#q9($>(XPQ@pSLnPt{?=ON26w$iNlwB*H)=$lRYyjE6f_MFFa z{kvse?BU6t>dv3gH{t`xKk51SAo2_~#24kB#>I@~IpjySR-$5YQ819!ZU()49qD3n z6bmOBOxIirIHiX}hw05KE(uAmhvS#aC$3m8K4cb7DB$P+}&;&qP%-_hoxq6>5 zK&syBbZBC7fFrJREQ5#Nv!r~ac)tIU;$c@OMg-)egJlUdCI{Ysquq(oQ8sc2={W3P zDup(O`;`GwxHHr(DLEiAUk>MM5pK9V_$O#xQba%U zZw}{avi^qNNt(syj;2$R3$Y+~CWj@R!9|e`b?di}?A42kVwF*0+^ZMpgX9SRbBnE0 zx(Hbw)3Y=^B`S0_E~lE-f^JOU0+~Gzwn=7tz%I(8e@ht>mB#uh^O7v{=FDSFPJiqA zJjH?Vk-7B8;bCcY*>chqUt><#El4`mcIL=v21Bt>H2VCr-E3@e3}_REXVbjY@PIXo ztTSH+S0G?#g)_~uWR*xD-rck2W$-FuG9}A4VE>g!4VdNwo zHp0(-2SfG3b~<*1KMsopBLc}cRFB^u)7>MY{k@^K4DDxfVxT{b$jEztzB%GanKwr~ z%m69R7CgDw`57gjpJ}YJe`kBLP3WZyM*0QR!PGKNgQ;thj_w#a%HQ!30~eFQ=Uu;z z+(qn4=HlkjK>N~t_#t!Ysq|=`pG$A12iSkdK1S*B>~_tlA@9+J8G-zqk+dyC4Pk#q zAlXYVWkmbmnQfiGJ;-wIXQ^vuW%LFnE2Uj0^X7p*ZZa-k$H2V`*c5IlQr^u0cvyia$1w0GH7LzBpWXMgAG55EDOQ#%aZ8sd^MkvL@(y6aa+EbAI{HAq#gzF{;$?q z$J-5A_V*Z_TF~4O&HT3sAs{zKpti0vTLmu}b75FG!!)e|k+I*={e~OET7{pPt2W_B z5cz$Ky$ZXs2QhxR2_MVq^B}Y?)MGRjTrD~%E9rTeHZ_9awwvA#Tg#9{yW}^gmka=@(&g9^uB}(uY zrkR7Ux+Vor#U~ArF)}Oy zOq0>(S;eMRwh;{FurVC}tiNAp`O3~FL|#$8=+Lgb$eU3c=H{HhfhgHHn^{LQJHX7^ znpt9I|Ew{3&`%U>Ba5?mn{N7e zaisfPM8(l+cUtOoPMActRnQt~ zirNCT!{`?!0eq4>eNYmtGYrE%n5V+*s-l|0vJ<*hQBQpvwZT@)9sqJ zzz>JwDA{Uu;)`xK)|=()&|hDQ4>YQvY-A8v1pW0HX4#F&719Tsz!{7$1mE7?PM6E`YiLwJUj4O{ll3ou$wXGX_IMY*;u?Ix0elZJ2DAaTVh$%*k}`ey&lX4 zrWgDqx6ZN9>#OWb_4z(NhD=zY&pol{w)`->vI+AhQm66~-fkGJF8@7rFuv42^@(cp zSQbN{@&GrM(zb?&3ICRs1`;CGv{@TUuF_|^ zY@%Z;JUt(Cg6T9=VP<>6C&wUghI+c9B06RyQ-nYv&8)16V3>;uvuD=sPV`bmaQIi1 z7((mU{a!=a9YY^@0J7$(e>V-+=!cX@P)0xlb*~($>cee8o^Q2Ym|RIGSE_Zpah763 zYFbY>C23k4?XeRw;h+@{_S^kldUn6i3j>+U*4vuaKwjeVFvT07y0N$AeE*Hz?a~^G z(hD~$*tEA^Y<5ZL#zu(3Mv%+emU0~`$z_`4()k#ZpZbvgUKt+f%yMAi*!9MuCqQ8_ zO&=fQI!1D=T6YrTJ}0DC&}HL;b%7Gt^o1cEb9v)mGl!~z)usLXfZS!H~Tdk{-jKiSn#ia&b-Z@z_z?PWISgu@{0=bX@`aQ$9hxXE0fk2x^t z@yX*T^_~zo;8|$wCw7pDDjVkE zOxo#oxzZX{RJbLz>pgu-T=p`C*Nvt)*ehHLXoyX@)b{`;1c;Bz#!ZdKFK( zgbxkp7}#<~!_Ft^rz>;vc)~k`&}XI$^Ej`@iNZ`z85T&JLzqB6ol+Yq1hZioR-+o2 zkJnKv1NJoIDdVx=8Ly*LYkYNQ;RCjrGB%6pV`RR9@py7F+br;Gc_>-1RQkiOO~Ik` zzo>Ca`@>&R^hR2&$d**c99RPXFL@=-JEs5trE8V`7E~uWv;eH+jZz2mh(5v5#}fD} z`ii7C+s{?(|B5C~!qtp9OjHcr70S~GQww~rKiDHZKIEx~o$?b;No^1vVY?0gWI<}n zgAdko+3YrF{ONf_R@1uLAYIQ)*~)d6Oluot+OFWeirlEstBtb$bA|RQlto(8$Z>ZS zxlf_m{7Oz+QOPwb{AaNyE~m4NKJ(b;}@1 zs=WCPbxRuRY4G&<^zd|l$AydP8`K%<@Mg!ZYtv`ikan80PTf^Ea|ZFP#?5jd+D=?} z;y}~UO3?zkzL+(GL^S@hzyHw|s9@Vb8UNr4ojIqNWYah2l#>lzWbQEH)-zcixUrn^ zT{-hAY;<#dF;|@&$LM0T?cf(6mJ!85uikmC-5XS5&f1bA*R^l0b7Guju#aaX`I z`T(sLJfnVU>^Ja?)}q}7&*&vI?qyCVG4~-1e3|1IEe_^5AMjex-_gRrGdePaqNwiwHXb*-2Gs)J2-=Hw20WwXx~V7^1TE-gv|gqF{bU-)-DEuI&uDkS z_ksS2_7FT*i}iqJyAz3mu0gX0&uCyBb`y9tXeXKvct$@(3jp5>S}`4Z@VZ(sThYRp z5oq)bQ~-QD=&xvT;Ir#FZarE&_;%1&(UQUAgyud%O9PM7ne%CYEqFEPIJ8pmIFGp* zXqDh`26NZYs=?!2=89)>RorX{I8?cXXv>)q=u>EGz_)|GkG2kc52%2zZJWU3u;)gj zJq=z9x*lyi`1m;-mx8u)Crz+@aZ6KN;u_qm35ObcaNLh*Y%&;iuqB*rE}|&})u@wR}9O?aEyKHhF7hnxg|2O*V5?+m*BKoK3Q3H~2=x1mQZhowc2f zoohNbbhdYH>+I~@)p@YwqHVb58W& zbhWMyj~6NFN+~AhXZuNn<8cadGu)NTB~`r}%h{%5uTILRK@oT9q=aTF;!d5E(JV#m z)JZALR>bW(DW^G#xJ{>%lA5c?PwS)_C2)_q$dPL$IgwkT$kmdZ#I00htt2ONk1Mi9 zl2f=R6ggXxhjXhW*{0*D93YijtpIq5dxH)obLlmj>C}UHVn1a2do=XvBl!Emzn_kF zXZKPzdkqVlmaItRyj`=X_cPnv@I;jA7LGN+ey()A_e{DgzhfNzv%O_Ll$k$U`wrl0SPOfn6Kv%u)%U>v`+g?w0akSJ-q1Rpy<=-f$ z{jX<{;WTSkIsZZ_ZQpff_=8dl2PI_|!t<8GFP6fcF?8eZVI-3t-@Q9(XR$?}yOu&> ziG^kz)$bWfZ0PYl3sogW7K+qj`t`m+bj%wr{AY!9>Kjv4!5RzoLk&}lBbE^ln|nel zz5m8L_g69 z$L~)zOZ=af!uS*^+4e)h{HKYu>(FXdM3RMVQ8LtibkgBKGLfzg?&LSG?{rb7B3lSj|||yA4(@4sZ$LZX3_u1 zF#6$<2vSJ5OAT$OhVREQ`d^%g2gHDD^-7 zH2<#%`sVS+h#if7Cz5|Bl8$>Pl8mD(-x1)%l{rs^G_C{wwq2470$Y2E7SK*?r;vqGl(a4GiKK<;dt8f zjBnS5_hz}i(qm70y2w>O;v(RWrrs+{a|QQ(f?Eq+eKjcGLvZ;~2s$CStQCS<@Vi9_ zddDO%D15EpQY_f6`{5ly_>tpniQREK`wWR`5{RA6Ap3Os>Sv?KkM!HmW)p2!>9xzQ zgrkFRd_%Ks{kPog3^txoIWDg2`8;Pkn~Sy|3>;w3g-M4H-W=$un~^b(9_l9Ra^A`s zk0|$_A_kitT#6H;Ij?2b^v@fEg=#!(wRFW#k*r>?{1k!WefU!(3V9n4s_OT11WKIq zb0o?=2fyQK$Ip>$9*#p1O1}maM;&fOVj2@}MY1`abSnZA{3Ha-_MTf2Z0_g6xRCw^ z3@at1FM_S7;=TwhyTyHxSenoFMY8q#93U;d4rm2+yB*16dyTvufo)iKI}$!y@jH{g z2?e(NH7J58`6UwnJRgnUt#s@!k?hb~`AY;&wwD2A(hmXQX#EAyaO!&}k{!CacOuxS zJonCEoZ78-f^dTGz7vVl{4#!f(%w}3{5Xxo zBW1A_QV8U%lhI~D-JFH2=zE-v$k3*Sw`JJ z9}%TbWr^Gc^1urD6Nn$4ROVhz0xn)Aq)EBHTrweSL|(ADZ$gZt;#{QgY*@uMxa3(6 zD@>eiM<#g;T~c4yREO&y8@^Nmr;cDR@dG;&MeL8T;W&*xmOI3J61>;kZpmMHcNpN4z@)82IPC4 z0?DpLKqrG_BN=%U$Y!-AatX-PU`yn`Kt2tzM1rv7v|*M=8jux{G9o8k45TwkXK6GO z&~m)8n`^fk2zzliBhLcK#4EcQIRfPBP)p=vAVIjBnr&_Xslpx1jMzKk#W{&9w16T2 zeTJ8Hvrz^Rn-P{s6_Cu4mdH{dFQkh{ok)moc$TGR4>WIBA;*DSutLrNnUZbUs|Scf zjwSL1kfm10Z6KbxmNq;NivxzCe!(QINL@k`lgE0J;M8SutMoRe>up{19+~rTaJ-SOC4Y)?U z?2mv~#is&b-&0~S+P(mc)*yNX$_mq(HYnZ;>FeB^VRSiKpO3?2aOi;zKni>wYlml_GkCNXoHl5~OCE`n= z$n>OmI+PTWv!YX&l=rYO@_^KcvEh)i#qw}W@ekrVj0B63xR;Q5;v(E-`0Pq~FG;H| zTg2V9i>wsqMMBjssX_wTCoOqY#?Uf?GY8M+QxT+2jE}-jSu3uHLM6w9W6@oR!bG%- z4$<&)&>{rWItn<WtiZjZ5QD+1#lJ@qf02z()J9{HC&a*Fek{0^ zF-Wphd>2WICx-y|Pc)|fZIQ&1LcVsqw63si7eFL;#KW=hRx5eKni{nYlhTN9dgl3l z4M?vEnYL(Q!}2*zoEG2o%r=KvFEJ^Oq=dIyDegegV?vr%vTcs9QDPfR7ig<2eFWk{ zbCnGn%?6F*h64E<)Qn^S>9s=2f!wu1rUB_QA;!6_6^9MMK-T)n>GyEU4Ny08(N;&Y>g+Q`GZyRl(>r1 zl1QQWRy-D6pm-~Ztud1-Xe3k{6UcngZYXglN`i5TL?f=V0QLajW0~I&(L0HR@!cj5 zaQ=6)SoUj1CBLha;g=s~_Nz{T-!&G%iwyWR!E6yQ96(c|8F-EX|4EjBmrHQq_@*M` z*(qj=t*Nm1!34|`>xY|_ThfrYPEP#KG^}$@9Gj0RQi`&91d3uSCgfqw?~lNf#H7Xm zy2NiRJlT&znA%jc>-7xyQU<;rg%e^*npwFv9m-Eent-htkhP;svbdT7A6Wno8Bm&T zwpf`7;DQBk|50FB7A!OwQkTnF$lwE+f3gB~TAGbIQ#uXZdu9i@}Nn#sH90PErk>LSPE%5X4g{-;QDO~;By8f=b9}h zjb^(9-}MQ0-T&G{SD_`vVsIfwxjYXOtIX(?Lg3TPd5GG4NhxKqSA#47I5JSkG6Z^6&SOs*rtwRbj54;7W1u{xWKm4wfJ?)2FUPPpmq;->%8|gpQe(VO zF;R<7AIlzJ)WTV>F?s1&7&;akBvcUla4r}X?~TRU-)P}u*EkHqzRc`2q5{B2W!8nn zvYRJ9ESIdX9K*!WN=(j@aprEFmFU)I0Sq1wU}1&XVmkwFS^$0%0L-m4TWn*1!2v;W|7Mj*11-$twPSwRmPaV!DdIO@~dk7&rqqN5zU6WEGrWo`LPq zXf>cazWBSH7+a5#9+e(+#v#P{aa^{zw4R(rj1di_F!icc$9;IC&bC4>0g1Olz5?PZ z9%(@E4PwenvdV*1oLvQ2!~gT(jk{VrI}@o^i`N;k7oBI}n%60wnuUxS6-(Lr4&KJ2 zM2FcZCMV9Ajl{Nz(Q`dC_AoS*5GBa(7aV zk>kCa-BaWM{{v)$$roVm8zAhjo$@VdY15MV4GZypVpXW$VAE&i$37T;9W?b~emsG6 z>hNX49Bc$2HAFK~0wl_6QPu&`SUFnF9H9$bDM>#Mq#lwPxd23q*ITpan?Tm!ug(^w z{{xT#-ONUgA-LvQjl&m6rxHl6P$Cd55SS_9bAep7s>dWC-B!Kk0CBD6;*>JZ#CI&{ pxo)eGHN&Wna2!4~!S(thk@Lwx^}uP<<}7GbZrw-zwTXO4{tw-T=nVh> From 2d6f8689f26055ca9ff53ddeaf036d5a9acab7f4 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 17:59:21 +0100 Subject: [PATCH 37/47] corrected mistake in test_clearTreeworksLikeExpected --- bintreeTests.c | 17 +++++++++-------- runbintreeTests.exe | Bin 102047 -> 102047 bytes 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/bintreeTests.c b/bintreeTests.c index db91d87..a451d99 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -117,12 +117,13 @@ void test_clearTreeworksLikeExpected(void) // printf("Tree Filled\n"); // Save all Adresses - TreeNode *node2 = testRoot->left->left; - TreeNode *node3 = testRoot->left->right; - TreeNode *node4 = testRoot->right; - TreeNode *node5 = testRoot->right->left; - TreeNode *node6 = testRoot->right->right; - TreeNode *node7 = testRoot->left->left->left; + TreeNode *node1 = testRoot; + TreeNode *node2 = testRoot->left; + TreeNode *node3 = testRoot->left->left; + TreeNode *node4 = testRoot->left->right; + TreeNode *node5 = testRoot->right; + TreeNode *node6 = testRoot->right->left; + TreeNode *node7 = testRoot->right->right; // printf("Adresses Saved\n"); @@ -130,10 +131,10 @@ void test_clearTreeworksLikeExpected(void) // printf("Tree Cleared\n"); // Check if everything has been set to NULL - TEST_ASSERT_NULL(testRoot->data); + TEST_ASSERT_NULL(node1->data); //TEST_ASSERT_NULL(testRoot); - //TEST_ASSERT_NULL(node1->data); + TEST_ASSERT_NULL(node1->data); // TEST_ASSERT_NULL(node1); TEST_ASSERT_NULL(node2->data); diff --git a/runbintreeTests.exe b/runbintreeTests.exe index f671fdfa5778998b781f48531b1d936a3cda9c31..800c7aca39394144e586b7e98a8f1c6b1ce05e85 100644 GIT binary patch delta 13966 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 delta 13894 zcmbVydt6o3_V1cY7H;IRK|p!G9~(gg0Ra^O0o@=dDk{G5fr(F2G%am=L`&MC;OMl{ zV}(6TJ?g=*FfGHZu%p*Q_Odz^_Bdf!LVC)|-1j@zTI`4S{_Y=le?D`K@A!@}=NNOY z`B-bgvrjue`?Pbz4l#FX<6{%W@PNk8US&I48d)o2k5OU2No-roo_?Q+F|1q=x@u+! zg3;{z^aepN53KX-nxpC~`}8Q<;~dP+P^)txOCZ*N6$_^7{wLT{iq=Iqr%gu_rBtFD z%(hUaEn0e70muS{PTU}BHx0VUQwe-6d%aR6TUHi44fa=b6{e>>N6tWpKXuwZw z14*uNY$6TAHHv1s#)-e{=%RN3J>%*jcIfDstAQP$Phj0d%q@fsrZBez@k@W2=oTuz zmr1MLhOx)#S+_9u0JXU#v60m47RAD8kbA1w=|{!xkz#uW-S3{l9-$ZAqu5INr+X^K zzyj<|Q68yImj??1Rk-?4wTFjzSE4N*@ytv|JTjRt{l_Dk-A``%1o7?&8mW(V{~Mf* z=7QT8g)TQ*p^usSwwoXb?FDVlig{#23O?U+}ikTyopko*xwk zT_~=1-~PMBl6%sLTkGEH+5=#$Lx}oE z3a;4c+}>eVx39hP3Wwn{NXSTuB^bB2)tG!vZRaCUFCARWQ$5?&o~k$?0mZ@Rlv%a! z(Cja%b|j?PcdGWKn*CALjwCgEqiQ#5_WM*jlIHe=8lO{7s163rVZ7>qUT6)-s$I93 z3I{&GKBKb(<5)9wF^MGr%m(0JTJaqwS`C2#TlsYQ<&VS>D(K@2Yjb<#lI~Ye=X#a1JGeM4P^! zt<-uCwa&wcxWmrsAK~N1U4Mj?hv-zQ7x2*TUntx>Ep!17eZa91>6GF!)7szzZ>ixs zd7JxHqf)=qtG1wrDRFP==M{9CrEl3Bp0PCD;SKeZnm#pBHSy~Myv*6YyceAtfoe0 zJVS@0Mh+;}$Wu2dJIbHFN*_R8(a~beRLY1>5xu6;%IG|U+h0&~d)qoUwkXZQ^uOo|s%B3nOLVXpKbb;e;==BSl{@x%ud{mRksw$)C^u>_qPiMVxIv3C zOvSbsG1gkQ=y*&Bj+l;^U^a_>LWKP$#|SS%#~>n~wYwc6EaC<&!h99mB22f|ib90J zx_#K>(YdFoDK;2S17~96qThemG0;cQ)j-c<+p}~u7;E1SqvP2D^laP!!{gklMcbib zTQrlkY6+DaR}haZXGAr zQ+ixnQ2A!Z)aF1}QybDio8pEVyg8v|qgSyl8)vKchxC5jYIcWmhr}9h6{~rS_({vd zNz3C8%@EvY=u7Z-&EN!sHNiirc}QH~R}VQR_ziS5!Q*smNS4XWbuGU~Rcy=eVXJd7 z&L2w$+7{Lo;b2Qb6J6)|?p-e((t^kT$d^)qft$Ac3fwLYL4ErCCWz5&1?%?|QdO>5S6Pz?({E-dXP$^F8Ql zRhc}JMzIg5C@CPQ>>jUjt5-}NZAnT`W%oEpR)-IE@G;@%63(G-*ZcClo}WVQ3#mIP zh*gpv(uf;D>7+!(D-{hC4u(;X@3>buHX372Co+Vs$Q~$tkJ9t$AuRf4gWS z)ULbb({m}&fxT-S!~GY!8txo@of2m_&UG!^Q5D<5ye`Mkpk zB_E=J8L_OEMrH)-DmiPG=F$9&K(>`0$_QpJ&>mbHsWl@m?8-{Vi2sJJHgXsTlHK98 zmm9RuPpa4!y53rAHWg(?;Z1CHWaE}QSApy5mbQy8`+BLAj%Eh4HFN>j z`E)HaF7Ut#$Ak_;R}!oTs zIx--zce!Jn|3X*eV9t&l9k}-%`!iPiik8e#2buHdRd~Rvq@*lA_Qvk4A#69rX9eqO zz@pD9sWfXYn?%R5g4u6$F)JMSr>tOcbSAlvF$C5wbqxL}bT#-iDjid1@Z-AHNgoy4 zI_YY4{**3`$-;I$AUn@(`F(1W2)>wRW~T%tXhh#*NfLB5#@&rLFeBsP`O^|xoF7zd zi*uC|%6!5em7T@5Q) zUdZ(hogEv@{zG4lO$&Tskz?h9(ACQ8X;|K*yfIwY5+12yTf)g!XUjTumR+}-WeR#X`q8SD|ZTs#Vp_d1Zpet5w}n6{oJ9AEG5~y?nz>?Na?c?KN84o3FG7 zcTeM}0zdt>M=*HBG%Mc_G~%8*Bdv9G>*$&M)IkGM)OZ&^;14whwmt%@K+HWi%~&KUj>B)vHwlzEyT=q~-|%8e?c_s0d8{uc}k)4Ff9yw4q#y3ZE0&B@SQxrwagy4h5&yDS z)R))GK48pJBs_Ufm%gt~2+hv}ez3Z0)*{t9Mzi)@Qmnt?g9fjgpjwlX=u+X}^mfi- z(7Z5?@k3RQqo~l$-)AB;Vjl=Kj|?@BMhYqljFE!iuYN0v(1+qlPnozk0>RdoYTv(n zJ85oF5L-(R7G*P{Q$+@^-w_gTFV5$bI_=Vb=w{J$JOdO>h;s?&Zv*vd0T0op2|N7m z@Hw~0X{(WSSUUBgTa+QM5ALL(;v9TQom(7JGBXit@=2TR5Z52E=^LS6TZ^v;`p_J- z9Q-NQ7uodvT%W3ZT?oEO9mTWQ&lF#h?fo%6b!`8|Sa(6cb1-H)M)y2zE}4Rt!;X@n z1INQ^tS^hg8Y}kmv-rj?C;h~5Q9p}@PaHbqyP5nG@~6hS3HV4j)zjkp`Z8r=zH0H^ z3S_Kz_eNBF`dp0f!#uC#U#^Ao6wK0LRE7OC2HreFS8UGr^XnP|FL002s}qxhr@>*n zr3SaFQa5|v{M48j=qwy{1x3hyq` zA5=7{m_14Iq(35#%|L6H^*bl?5au*9&gT*c8BJDoD8jAWlu%@iYRqc^5hvZ9vAsRLNl z>M}&AyK3=0!_Po-a5i+~_RniZ7|laJSE#HbG`Vb)#}+6vrcdSjm|5zky=AGUOH(mu zIDL98zJZFXv=0n)V_ooW1?6F^{b1@oQhVOgeW*dHZ!k-nVBOwUcVV4JavQ!27-r8? z=N@L-Mzslx?|FVyn%xVzzWu$L*yPLIu2>kxx_{OLV%eA(l}rot<)^V-8;CBkskC`o zoc_xxJcfST8H{?nbdg?}7BT#&!qt4yH5%jF{qd4Sedspju9&6WifP>vv$O-K_BLDB zis7gsm+6r~)nKs66hQD_yOgIPi|>nMoF3ml4!XtHOb<>E_WCFm*s}qDaHzd*z}UY? z2d6i&Z>ey`V|X?BaE1xDp{zWc?V%^iO`?A^`OX}}shPW2VavBOZ;0#~eK;q{=U^DV zx7JLEOwij0TyV27i8)@x@pKhWqG#s%n_g6X$EaL7 zw_|c}-$;(J_j0TU=C|QogY{>LK80POq2XTHH(-|Nt(v`04$*XbY2ppo6aO!L)@(K4 z|F2xA)wh!-r3ZF|gT73uVC&J#*hF}O|C8LR*lqqrn*aYK2hPG&;0+Gc9Dl|h!1b>+ zd0CTh(Wv=p{?|S~%$Kb7hYd*il@hB6rA(&{_~RI>nB)~!Ddh08zVDYq3o1h6dX}gx zp4AoW7R{?!;{{DN(4mTKmj+F%Zt1Oq}Hnrp~U*69Y93%)YGzkKiVu&C# z19Q0^<#pgKkWrz6a2}Y;>M%k05SYt{P&$FR+>6o$%w;FaEnqG)!v#UuugXebH()MX zQT+A`CZP>rSp*t~fy=`vNx)n-L<+)aU@qrIVO;=o`3g!IFqge36~J6JMGL|TU@k*r z1YrX(mxQtnn9F_fXb+gn+wmp5ssTSU@mnyEiM9c*@|)n zn9FH6i@yctG7(P}J-}SvMY#ja<)viQdrp<(Qv|^Wc)SUqEmaW0pm2FDT@Vt0x%A8w zgbZLVyG98@J}{RTMhikIFqg-&1Yr&^m&R;CSPIPLu3SN=0p_xOEN&w(m%rr+!sEbP z78(V?^b`~h))rzO0CRb)2=f4#OZO7Y17I!>Ou{?><}$Dp^8lF3ktqKL=JF!Sx4>L( zoQ#nG=JFeqJHT9S!w#)`UXdnYFBBgrTzcbt2?FNwJCrEk9>^g$2$O)5AorqV05?It ziINZ826+y}2;2c_K`90nrU}AdP|AQCAPJ=cxC!zp?9Gdx$Ng^tcphaF49$@KIQF*y zhe2*F$8hn=kT+(d5^xV>;vDz_Cqa%zISGsfCR~||(E{#-ES)C^Zv%7rCd!AvZIHS1 zVdp&LSW|@{T;~epJd|6&6_Be??f_Rq?n7~U0f|EPpy+_PtY3iT1l$1Wxe&_B1#P~wnE|SB|@UG0ZI>)Xnfb$ z0?fZ}EJ4`;Tn%{ur2)9K3b&Icul+o^2@hfnQ9kq*gzr)Kz;o&1#000Y7$?ns3tWF6 z*jwh-e6DxHWXR#wFhO!;=E4TIRBYSduQ5r|RbU)pSlZ&ULobRk0~*5z?S9PJXE{z{ z9eCWfaJ6dmaMk2`baeIHqa&f-5yI z45K%8ySO$f;V{Pgj?(+PLrf=3O2j2zJjs5I%_b$}eVTg2q{LjRsRvC;&?-%R!K6f8 zrm0OPCF*ib-Dgq;VYskCuMSFuqNfNOHN6~q*5b-k;X#ckRUFcUhcw-&=p%$pnx3QR z>B443@7H*eUZ)4xF-m=+l_k>kC*lSs;;!=1uUu8LX5(;SkY^&r{`Dy@+bu>X@w?H| z@z>Fw_^%N61EFj$4Ly*_w$XhDMvLD}rWX%Xu#M#WQoeYxl!{+U^>CZ4&JR~lw7rpb zzT}U8JvsPNn*PC3I|H1rzZAg&Nq;a0|He{!a1wK;ri1UKEibY2I&H7GPPDTuv{x3< z-a|>~*o8xf;(R99c`deATJ4ov#q{*yp?KT8aCnvebfI0Hmx}24t3h<;u(Ol!H|IiH z_4oPuMx&j>ib9(F%3wKjJ@a<@Rr)QD1{^sh-p!|Xk0j&YXKo*fj`Ov17sMI)c9mbU zSME~pQ9qh@)JJR|OEpJV>-Bkdu0Q7?P5`+b^JKdy_*k|6lUzG%+gP3j-DsBNAJ;Km zzXm5Gojca-aW&h{X$Sq~A6XcfH~&$sznx`g$j#PjJJalDH}S$~s%oy#53+Z8DNA$F zi(R93AFt4-jJ9jw?a|ySKeUc{_4~D-C+$7nn^v1?=kS5Ol0VYUBHJscsqN(<;I+Pnx zc|4h7=lvR$zLFtcN~XtNc~~Dj+|H7d!f&~LTGgtWiR)G_tXv~V{q82w*jFp`IpWE&Ys%9*3-z-u`Hez zo;HYY8R+rT1uT>>(7-q5vbj|K#w6B2ZEuWahpFG0QnrlB z&KSkEaC+v(DaXm{xegucZedpn zSW=icWRRraDuvbJS}TQ}wkn*8*(&LaBD-V@%pr{;QiJ|gD1JNNsW_^w-joe-t&HbO9Y{TRzc%KR~#XZ_%h zG3dg6P>1O~TpOqt*SX~XQ!Kii`%^6M|FWNAFc^)XLg_VJiLTs)I)xb5wSx|`8kFa(#D@-vEl5;^%%W} zt2_1LdVu_I#$qGP#dRcA-3;X$>0>uTu&W-r8OyiW%Qs`N-~I;sUJAbzi+#B8RyM0{ zsk^nuBPAH8H50-FQCPX4Y84+rej=$%Vol|S8Zf0eWcg{|kHriSgo$!^DjOu1=$VWB zJ7Z(ym;15x5RIJM?2t>|Jq-hujd$0^|mX=}b}jz7Ra% z_h`NvyS*BeGq=Dz(!VE9|5joAa{7~U;yOe+}UFni`-V0Id?@ziOnrNcb` zEkzh-NAam&m|^df1!gVYCvDYcfH^kOo>>dVU2b({k){LL_J+eS1m@T?r@)MKVBQ9E z(ShjzvoY7c))!#DabSAEY{R3wEiKU%iznJjOkIuSd#oN50=K7WJ%8=xoL==eJr-+%capQLXPreE3C>1 zO;Of;SOL>BofpTmhi(rEM{y;XtB=1 zJXxfST2XS7FEjQLrGr_nTr!BA1`+PXA|ZwjW`BrHyBr=_Yx; zAG+B*PVEC4N|X=#Vy}A6pGAS@yM%NYV;ClP`=jp-a(Dnnr&+EKK>Ixtl=d5woaBRn zY*2Vo@xAT$OyCUPK4B92@$J)B&EGEw>^@OlJvCL*5X= z46Ib%AHpJI+9vizLbJk9cWl)7n4sSFzB}4kBL5JAJ6bBA4Q0C^CWo={tU}%shK`iV z{|aNDuxf6Ll-mq!fP5zm!+JZMjR6bSP}9?BwyCtQSsv&Jm>vh_ESLs-i?GeOFTr?D zv1fh(Q|iFD;GF4jVEn;&PPMN!Vi2e%E7jMlYPmZCi652EMWQ#IvTGFXcXjKqC>F}( z#3=NmJen=SusEDKVJ9Jyo&Zrm27LWH~`o~>Y8lnR(D zqn<*?_-7Q`m>mEk;G2oc%wN5#as&R$soKi$v44fvl2Z~`S~UN>Vyk=;h8`kB{;fh;%E&=1PMIJVk&+{2_XF5xjM<-&coz#?5TxrvkjA2mDYs#y`_*#Wh$d<`3 zC-Jp9Lk>&EqUR)UC}B9phIajb#0arb5N2jfvy!OP_%MhrwoE<7d{ z!lOg=C@g}9f|tt?6X20L79MX;zz%vvUch^tSIoxCh613rV#GMW(U=mn(4)4HIT0-= zc)2`q5?Y8F2agkz;QJg$!%NYdrQ=~poQz8jPs4eNid^L1rm&&%!6^u*lY6JI&GMIp z=(obYFcnR>6{CrWGN8veYT`&&0u(Y0=u%0a^FFTLnFK??bf7g;fS%&0hoeC=ki)8} za4s}rM7_$9a;cna#H{$C95b_YCbrQ4b%84UA}mI!7SE%lvg<6iTv|F4%SxWCXM^S4 zvsi$4Grm^x&07?z*VQQRI-c^IvsjvUGd^kB)*r)@s37;Bjb*k$UOO9$E=)c&o9)M< zn=l7jhWr;*w9a9Fc(*y!)#JfZkl&e${rRLkZ63V+Wb-^WUhFEDKb*%>nP;oZe3s0_ zo^p9~1$3Q!e+8R~nR1~5``!-uMg_te-;i2Wt7X^%Ww;g{9eOZ Date: Tue, 9 Dec 2025 18:04:58 +0100 Subject: [PATCH 38/47] removed no longer needed comments --- bintree.c | 31 ++----------------------------- bintreeTests.c | 22 +--------------------- runbintreeTests.exe | Bin 102047 -> 102047 bytes 3 files changed, 3 insertions(+), 50 deletions(-) diff --git a/bintree.c b/bintree.c index 3ecf028..0f2f187 100644 --- a/bintree.c +++ b/bintree.c @@ -52,7 +52,6 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType { if ((currentNode == NULL)) { - // printf("Node == NULL\n"); if ((isDuplicate == NULL) || root) { return newNode; @@ -64,17 +63,14 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType } else if ((compareFct(currentNode->data, newNode->data) < 0)) { - // printf("<0\n"); currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0); } else if ((compareFct(currentNode->data, newNode->data) > 0)) { - // printf(">0\n"); currentNode->right = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate, 0); } else if ((compareFct(currentNode->data, newNode->data) == 0)) { - // printf("==0\n"); if (isDuplicate == NULL) { currentNode->left = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0); @@ -113,45 +109,22 @@ void clearTreeRec(TreeNode *currentNode) if (currentNode != NULL) { clearTree(currentNode->left); - clearTree(currentNode->right); - clearNode(currentNode); - /* - printf("1\n"); - free(¤tNode->data); - currentNode->data = NULL; - printf("2\n"); - // free(currentNode); - // currentNode = NULL; - printf("3\n"); - // */ } } void clearNode(TreeNode *node) { - // printf("in clearNode\n"); - // printf("node-> data = %u\n", node->data); - // printf("node-> data = %u\n", _ADDRESSOF(node->data)); - // printf("data = %p\n", node->data); free(node->data); node->data = NULL; - // printf("data = %p\n", node->data); - // printf("node-> data = %u\n", &node->data); - // printf("data freed \n"); + node->left = NULL; node->right = NULL; - // printf("left & right = Null\n"); - // printf("node = %p\n", node); - // printf("node = %u\n", _ADDRESSOF(node)); + free(node); - // printf("node = %d\n", node); node = NULL; - // printf("node = %p\n", node); - // printf("node = %u\n", &node); - // printf("freed node\n"); } diff --git a/bintreeTests.c b/bintreeTests.c index a451d99..eddc237 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -11,6 +11,7 @@ void setUp(void) { // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden } + void tearDown(void) { // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden } @@ -92,7 +93,6 @@ void test_nextTreeDataReturnsNextDataCorrectly(void) } - // test if clear Tree frees all node.name and node memory AND sets them to zero // aditionally tests if the memoryspaces have been cleared void test_clearTreeworksLikeExpected(void) @@ -114,7 +114,6 @@ void test_clearTreeworksLikeExpected(void) testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); - // printf("Tree Filled\n"); // Save all Adresses TreeNode *node1 = testRoot; @@ -124,37 +123,18 @@ void test_clearTreeworksLikeExpected(void) TreeNode *node5 = testRoot->right; TreeNode *node6 = testRoot->right->left; TreeNode *node7 = testRoot->right->right; - - // printf("Adresses Saved\n"); clearTree(testRoot); - // printf("Tree Cleared\n"); // Check if everything has been set to NULL TEST_ASSERT_NULL(node1->data); - //TEST_ASSERT_NULL(testRoot); - TEST_ASSERT_NULL(node1->data); - // TEST_ASSERT_NULL(node1); - TEST_ASSERT_NULL(node2->data); - // TEST_ASSERT_NULL(node2); - TEST_ASSERT_NULL(node3->data); - // TEST_ASSERT_NULL(node3); - TEST_ASSERT_NULL(node4->data); - // TEST_ASSERT_NULL(node4); - TEST_ASSERT_NULL(node5->data); - // TEST_ASSERT_NULL(node5); - TEST_ASSERT_NULL(node6->data); - // TEST_ASSERT_NULL(node6); - TEST_ASSERT_NULL(node7->data); - // TEST_ASSERT_NULL(node7); - // */ } diff --git a/runbintreeTests.exe b/runbintreeTests.exe index 800c7aca39394144e586b7e98a8f1c6b1ce05e85..13bdb19ef48a964f30b062634ed040939d694a97 100644 GIT binary patch delta 827 zcmbu--)mA~7zgn8dGkkOPSZRKQRbHYw06--V{7JqxN^-(NkT%H+72{YI`qieYDsO? z3Zk7ouJr>M(OnSClo*X&1YLH~MHeoDi0%emME^kVUf=$LZl3e~Jj&rc-*c8ry5*8? zevUr6s6ISL_ekZh-bUy|v!NZj&~I=;Hx3()fDcucPhy#6KmIhhpa=C$9_U41lMDJV z$#Op~u^hlPmIv@R%coE>df+q;86z-+C1V$au*Py2-KO0Tshl%uYaqhwMz z%zcbZ2?x17^h+u(7o4f_x(@M0=q%w I?Z&U_U+Fo{jQ{`u delta 827 zcmbu--%C?r7zgn8dE1Y~xwW4p8%|w6S6yUnWonyk#?+OQ7AzRJEe|BwCfgaMr6U3< z3GDbd3PL1`ep}jh5lKQ&H{nGWUCbyVx)ZvH{()ZKz5NBp)HV*Iko-;qEnV-|# zx=#J4m8p~T+tkt*Z!H`~qi!FxqEF|9HXP9Hhjvt0?!YCMkK#|A3w)@p^MD^a>Rix? zNtTb{ZI%PL%yJNav)qMNy$6nCuf898a87>&da=TCAG!_A5GkE7m?=zR(&&U6c$LkY zc#q9#e8=Vt{$R6+U~;~1cl#`=bNjfz&CXvV1RlZJ8b|Fv1pW;-@^i(KD z^-Rx%qSVUtTqr^vObbF`>SC&YAsC`=#+O1tQj3eJMtnO{OkFZmPnh5*Y$2n Date: Tue, 9 Dec 2025 18:41:02 +0100 Subject: [PATCH 39/47] treeSize and treeSize test now workingW --- bintree.c | 16 ++++++++++------ bintree.o | Bin 2243 -> 2243 bytes bintreeTests.c | 3 +-- runbintreeTests.exe | Bin 102047 -> 102047 bytes 4 files changed, 11 insertions(+), 8 deletions(-) diff --git a/bintree.c b/bintree.c index 0f2f187..2cf83f8 100644 --- a/bintree.c +++ b/bintree.c @@ -24,7 +24,7 @@ TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root); void clearTreeRec (TreeNode *currentNode); void clearNode (TreeNode *node); - void treeSizeRec (const TreeNode *currentNode, unsigned int *nodeCount); + int treeSizeRec (const TreeNode *currentNode); // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates @@ -134,19 +134,23 @@ unsigned int treeSize(const TreeNode *root) unsigned int amountOfNodes = 0; - treeSizeRec(root, &amountOfNodes); + amountOfNodes = treeSizeRec(root); return amountOfNodes; } -void treeSizeRec(const TreeNode *currentNode, unsigned int *nodeCount) + +int treeSizeRec(const TreeNode *currentNode) { + int nodeCount = 0; + + if (currentNode != NULL) { - treeSizeRec(currentNode->left, nodeCount); - *nodeCount++; - treeSizeRec(currentNode->right, nodeCount); + nodeCount += treeSizeRec(currentNode->left); + nodeCount += treeSizeRec(currentNode->right); + return nodeCount + 1; } } diff --git a/bintree.o b/bintree.o index 96c8f39a5e111e8ddb6c6941f742f92a26006228..48f3a9c95e67e4330fb83d9cf1d097fde2c8517e 100644 GIT binary patch delta 177 zcmX>scvx`5Mdtc$R{@XCgD-d(7#KQT|8%?l@n}9`5PLY(qw}dp^BV(?PG5oJu77~C z3?9w30t_X39v~gv4jdp|*Z%+i&j{245ds@@7$O8TsQCcnYoI2OX%kQYBL_1pM-dA% wV*mrgscvx`5Mdtcm*FPTJz5*VdhhA_pFfeojxy?rmVh@LUbUyWHexu;g36czz@Mx|T zU??&1=ynzG=yu@n=mrXP9(-~2|Ns9$F`)DT7LQIK4Uq?`fyi$K%1;2As1SR20t_&6 zFtc(Lu`n|RFfdFGVDV%$nmmgoi1#TI1A`0D2_V{h^G_CcCdQ|e9oeNB%{Rxgr!fKm D>AgX- diff --git a/bintreeTests.c b/bintreeTests.c index eddc237..c187aaf 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -163,7 +163,6 @@ void test_treeSizeWorkingLikeExpected(void) testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); - testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); testTreeSize = treeSize(testRoot); @@ -182,7 +181,7 @@ int main() RUN_TEST(test_addToTreeExpandsTreeCorrectly); // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); RUN_TEST(test_clearTreeworksLikeExpected); - // RUN_TEST(test_treeSizeWorkingLikeExpected); + RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); } diff --git a/runbintreeTests.exe b/runbintreeTests.exe index 13bdb19ef48a964f30b062634ed040939d694a97..6e09e247fb89f41297861e1b839295ee6906e127 100644 GIT binary patch delta 15434 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 delta 15359 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 X71vi;!&czq4U7fN0gr|3naKYEPVU^! From 9d0897051325ebff95ad98fafb17a2613b954ace Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 21:12:03 +0100 Subject: [PATCH 40/47] wrote nextTreeData() and nextTreeDataRec() --- bintree.c | 51 ++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 42 insertions(+), 9 deletions(-) diff --git a/bintree.c b/bintree.c index 2cf83f8..b475f5e 100644 --- a/bintree.c +++ b/bintree.c @@ -12,19 +12,21 @@ * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */ - static TreeNode *root = NULL; + static TreeNode *root = NULL; + static StackNode *stackRoot = NULL; - TreeNode *addToTree (TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate); - void *nextTreeData (TreeNode *root); - void clearTree (TreeNode *root); - unsigned int treeSize (const TreeNode *root); + TreeNode *addToTree (TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate); + void *nextTreeData (TreeNode *root); + void clearTree (TreeNode *root); + unsigned int treeSize (const TreeNode *root); // self declared functions - TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root); - void clearTreeRec (TreeNode *currentNode); - void clearNode (TreeNode *node); - int treeSizeRec (const TreeNode *currentNode); + TreeNode *addToTreeRec (TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root); + void clearTreeRec (TreeNode *currentNode); + void clearNode (TreeNode *node); + int treeSizeRec (const TreeNode *currentNode); + void *nextTreeDataRec (TreeNode *node, StackNode *stack); // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates @@ -91,9 +93,40 @@ TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType // push the top node and push all its left nodes. // Needs stack!! +// Stack functions: push(), pop(), top(), clearStack() void *nextTreeData(TreeNode *root) { + void *pointerToReturn = NULL; + if (root != NULL) + { + // Add tree to stack so that bigest entry is ontop + stackRoot = nextTreeDataRec(root, stackRoot); + pointerToReturn = stackRoot; + } + else + { + // return current top entry and then pop that top entry + pointerToReturn = top(stackRoot); + stackRoot = pop(stackRoot); + } + + + return pointerToReturn; +} + + +void *nextTreeDataRec(TreeNode *tree, StackNode *stack) +{ + if (tree != NULL) + { + stack = nextTreeDataRec (tree->left, stack); + stack = push (stack, tree->data); + stack = nextTreeDataRec (tree->right, stack); + } + + + return stack; } From e4a8afabdd8c4ecc564c88ee631cff8b7cd2290b Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 21:48:43 +0100 Subject: [PATCH 41/47] wrote test_nextTreeDataReturnsNextDataCorrectly() --- bintree.o | Bin 2243 -> 2715 bytes bintreeTests.c | 36 ++++++++++++++++++++++++++++++++++++ runbintreeTests.exe | Bin 102047 -> 0 bytes 3 files changed, 36 insertions(+) delete mode 100644 runbintreeTests.exe diff --git a/bintree.o b/bintree.o index 48f3a9c95e67e4330fb83d9cf1d097fde2c8517e..49eaac05aa58b1aa555c650225999a15de30ff84 100644 GIT binary patch literal 2715 zcma)8&ube;6dpx#s+N)}B?a|ow!}~w?5*m$X($bBV=vx-RfKEf9$IQy+B9kvOGv9C zi>3rb3d>&dKQ#1M=%vseik$?MOQ95+{~%CfAA0n`MESlMX?E9E(hiK~d*6He=Djy> zS5x`^q~Lh)j1Y!IDPekU$CFt7WKu$;5<+~aOvNeChA6I^m6BJA*o}jhC~lh@tyWZ* zi3&q}gLa*`!y0sFCgR4H$XjOPxZMrd-5*JKzo+KO>jEm6oQY`j$*o@_}%I zg5d{ouL&Ia(efy&+iUn%pZ->>0Qr=_E{`B z;hpSV&kOHa_{#2{h9^4RO)HRf0)~hwurHF>`DpOx&F!uC6=|ixA`%rOBVit4B;O7O z1H_5?TuSf$%&@S@c$eSJ4P9oQ?s6)0nb|8n*Oio&ZV zQyVVIodPS()?i=!&7$}$Esu&PCTSU>rY-Qw{KwEdi+v28oZ5#@;1ut+xHU%2-tne& z2(bKJo(Z?c9*}<;$xrd3nu^vkN{W3VRmJd)0IlB$>0H|MZTXhO!^^Wuefv;*f%E4f z`1WC7AI1tAGnEOM(S#l#fdn3rL8_eYDhiHz+lf8CU+9Tjk&#FzC(_MSGJy|<#LG{> zvl0IP;4yxf;cfn4aQzpp%1pVsCxqZ9i0dDilfYc}G4sG&XOs9Y19J^99bm4%V6Fgj zP2u~!4!k%&|ACR~TsZ&5`MH@!y;beZwA`yRP4}Dpv~j6jt$D`AmQko~F0Rc`th9_q zv;LJ^_NI(?-Zf`UZWe}muOlsJXxUXsxM?UF`CtzFUFry6~xwdAGfFk@#)a>)uE}8BrUK7cg13ka?LjMnV|k1V5x>#yN1eF{O>vvo7r6 zkhutkog6X+Fzn}$Sp&na4jE?0-c}4#_@vr(+2NthCT!T}iizG{7;ZAb{%4)T5xu!! zJJ^J}5sKbg;2bvWo%o2}Sg;9fYHaa`=wN= rtkhR%uhFtw7Mr**l3n11Fe*@4uDPYAd`2Tpe_XG)VsxrxBfCBZPRJhw delta 717 zcmY+Bze~eF6vr>gU7LnhY*4GMLa|jG`U`(R2ZfYYP*I2|=+Gg>1`%;70VPYpK@bbME>6z=0pjF8;L=TJ7vIa-s~)_(&walycgcGb8f#rX*<*S_I8JO^`HB_s=s*?}kkV}6FH0%QJwXaHlLhtIWnkL`8w1RB-| z@?bv^YNt?_4(UM>Y)KqKgLnF*1DTI7w)8_Y**TODb7hMNVg(2?3g$P ze@tAwEHz6K{;F`-q_!yu8;x#8BfC=EmxPlu`CGJZ01yRwt13Zltc#tw?<;7LS%^=V zKv)wh3-H9543rg6a54jB0~DN(P`r-o?i~3pPH9ks--WXhO38E2JpQgH7|xFIo?cgU sUX10GCf| #include "unity.h" #include "bintree.h" +#include "stack.h" #define MAX_TEST_NAME_LEN 10 @@ -89,7 +90,42 @@ void test_addToTreeExpandsTreeCorrectly(void) // needs Stack!!! void test_nextTreeDataReturnsNextDataCorrectly(void) { + TreeNode *testRoot = NULL; + int score1 = 12; + int score2 = 6; + int score3 = 18; + int score4 = 3; + int score5 = 9; + int score6 = 15; + int score7 = 21; + + // Prepare a Tree + testRoot = addToTree(testRoot, &score1, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score2, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score3, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score4, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score5, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); + testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); + + + // Create Stack + StackNode *entry = nextTreeData(testRoot); + + // check if nextTreeData returns Data correctly + TEST_ASSERT_NOT_NULL(entry); + + TEST_ASSERT_EQUAL(score7, *(int *)nextTreeData(NULL)); + TEST_ASSERT_EQUAL(score3, *(int *)nextTreeData(NULL)); + TEST_ASSERT_EQUAL(score6, *(int *)nextTreeData(NULL)); + TEST_ASSERT_EQUAL(score1, *(int *)nextTreeData(NULL)); + TEST_ASSERT_EQUAL(score5, *(int *)nextTreeData(NULL)); + TEST_ASSERT_EQUAL(score2, *(int *)nextTreeData(NULL)); + TEST_ASSERT_EQUAL(score4, *(int *)nextTreeData(NULL)); + + clearStack(entry); + clearTree(testRoot); } diff --git a/runbintreeTests.exe b/runbintreeTests.exe deleted file mode 100644 index 6e09e247fb89f41297861e1b839295ee6906e127..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 102047 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

V$p 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 JYL6!6{y%#$1eX8+ From 2368c9f3b9750a32591af020445e8c71f8878111 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 22:27:14 +0100 Subject: [PATCH 42/47] added stack to makefile --- makefile | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/makefile b/makefile index f827225..75e302c 100644 --- a/makefile +++ b/makefile @@ -38,6 +38,12 @@ $(program_obj_filesobj_files): %.o: %.c # unitTests: # echo "needs to be implemented" +stack: stack.c + $(CC) $(FLAGS) -c stack stack.c + +test_stack: stack.o test_stack.c $(unityfolder)/unity.c + $(CC) $(FLAGS) -o runstackTests test_stack.c stack.o $(unityfolder)/unity.c + bintree: bintree.c $(CC) $(FLAGS) -c bintree bintree.c From 82b2fb283f850221a404a4b97a812ec4d87c0dfd Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 22:28:31 +0100 Subject: [PATCH 43/47] merged branchjens --- makefile | 6 ------ 1 file changed, 6 deletions(-) diff --git a/makefile b/makefile index 542b37c..0b640f6 100644 --- a/makefile +++ b/makefile @@ -38,12 +38,6 @@ $(program_obj_filesobj_files): %.o: %.c # unitTests: # echo "needs to be implemented" -stack: stack.c - $(CC) $(FLAGS) -c stack stack.c - -test_stack: stack.o test_stack.c $(unityfolder)/unity.c - $(CC) $(FLAGS) -o runstackTests test_stack.c stack.o $(unityfolder)/unity.c - bintree: bintree.c $(CC) $(FLAGS) -c bintree bintree.c From ef3e0b78919b46ca0168f952e73bc9c4a36b64a6 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 22:41:35 +0100 Subject: [PATCH 44/47] changed binTreeTest makefile, test_nextTreeDataReturnsNextDataCorrectly() not yet working --- bintreeTests.c | 8 ++++---- makefile | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/bintreeTests.c b/bintreeTests.c index 495a8fb..b0fb302 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -214,10 +214,10 @@ int main() UNITY_BEGIN(); printf("\n============================\nBinary Tree tests\n============================\n"); - RUN_TEST(test_addToTreeExpandsTreeCorrectly); - // RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); - RUN_TEST(test_clearTreeworksLikeExpected); - RUN_TEST(test_treeSizeWorkingLikeExpected); + // RUN_TEST(test_addToTreeExpandsTreeCorrectly); + RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); + // RUN_TEST(test_clearTreeworksLikeExpected); + // RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); } diff --git a/makefile b/makefile index 0b640f6..cbeb1ca 100644 --- a/makefile +++ b/makefile @@ -41,8 +41,8 @@ $(program_obj_filesobj_files): %.o: %.c bintree: bintree.c $(CC) $(FLAGS) -c bintree bintree.c -bintreeTests: bintree.o bintreeTests.c $(unityfolder)/unity.c - $(CC) $(FLAGS) -o runbintreeTests bintreeTests.c bintree.o $(unityfolder)/unity.c +bintreeTests: stack.o bintree.o bintreeTests.c $(unityfolder)/unity.c + $(CC) $(FLAGS) -o runbintreeTests bintreeTests.c bintree.o stack.o $(unityfolder)/unity.c stack: stack.c $(CC) $(FLAGS) -c stack stack.c From 6a9461bf5bbabc89e7919238e2adf8bd40b8d796 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 23:13:39 +0100 Subject: [PATCH 45/47] all binaryTree functions and Tests working --- bintree.c | 8 ++++---- bintreeTests.c | 9 ++++----- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/bintree.c b/bintree.c index b475f5e..6379392 100644 --- a/bintree.c +++ b/bintree.c @@ -6,10 +6,10 @@ //TODO: binären Suchbaum implementieren -/* * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv), Done - * `clearTree`: gibt den gesamten Baum frei (rekursiv), Done - * `treeSize`: zählt die Knoten im Baum (rekursiv), Done - * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */ +/* * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv), Done + * `clearTree`: gibt den gesamten Baum frei (rekursiv), Done + * `treeSize`: zählt die Knoten im Baum (rekursiv), Done + * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. Done */ static TreeNode *root = NULL; diff --git a/bintreeTests.c b/bintreeTests.c index b0fb302..dfc862e 100644 --- a/bintreeTests.c +++ b/bintreeTests.c @@ -109,7 +109,6 @@ void test_nextTreeDataReturnsNextDataCorrectly(void) testRoot = addToTree(testRoot, &score6, sizeof(int), compareIntEntries, NULL); testRoot = addToTree(testRoot, &score7, sizeof(int), compareIntEntries, NULL); - // Create Stack StackNode *entry = nextTreeData(testRoot); @@ -124,7 +123,7 @@ void test_nextTreeDataReturnsNextDataCorrectly(void) TEST_ASSERT_EQUAL(score2, *(int *)nextTreeData(NULL)); TEST_ASSERT_EQUAL(score4, *(int *)nextTreeData(NULL)); - clearStack(entry); + clearTree(testRoot); } @@ -214,10 +213,10 @@ int main() UNITY_BEGIN(); printf("\n============================\nBinary Tree tests\n============================\n"); - // RUN_TEST(test_addToTreeExpandsTreeCorrectly); + RUN_TEST(test_addToTreeExpandsTreeCorrectly); RUN_TEST(test_nextTreeDataReturnsNextDataCorrectly); - // RUN_TEST(test_clearTreeworksLikeExpected); - // RUN_TEST(test_treeSizeWorkingLikeExpected); + RUN_TEST(test_clearTreeworksLikeExpected); + RUN_TEST(test_treeSizeWorkingLikeExpected); return UNITY_END(); } From e3501e85508783062089807ff18267fdb029785d Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Tue, 9 Dec 2025 23:18:36 +0100 Subject: [PATCH 46/47] added runbintreeTests.exe and stack.o --- runbintreeTests.exe | Bin 0 -> 104510 bytes stack.o | Bin 0 -> 1253 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 runbintreeTests.exe create mode 100644 stack.o diff --git a/runbintreeTests.exe b/runbintreeTests.exe new file mode 100644 index 0000000000000000000000000000000000000000..031048829e5e551dc6858db7660104964086b9bf GIT binary patch literal 104510 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 @Q@-T)qY&`a$G(@I5`> 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 LwTkwrL+<|t7>qlT literal 0 HcmV?d00001 diff --git a/stack.o b/stack.o new file mode 100644 index 0000000000000000000000000000000000000000..7a38f3876cec303a0df0f8e190d513f0a9795b90 GIT binary patch literal 1253 zcmZux&5P4O6o1pCHV4Im9~9lg99CFi8>71{;we~kb14L+coH|;X5DJEAxWiH7KDNj z_OgG5M~`|_^z42A070mSy$E|!-PPWr=H{IZ<1-*(bL=TjRCe^QT=-aB;`2d6M?eI$Q* z)j7n-;h^KB?F?dzYY4pfW6wN=s4SDm?+MW_R_SQg>~Q@^x literal 0 HcmV?d00001 From 284cdbdcfb95573bf44603e63957f48c96104020 Mon Sep 17 00:00:00 2001 From: Hofmann Jonas Date: Wed, 10 Dec 2025 12:18:49 +0100 Subject: [PATCH 47/47] made runbintreeTests.exe --- runbintreeTests.exe | Bin 104510 -> 104510 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/runbintreeTests.exe b/runbintreeTests.exe index 031048829e5e551dc6858db7660104964086b9bf..945294b3668b498ce9cefa27e2987ced644d34df 100644 GIT binary patch delta 26 icmdnDfo8h6}#{