BA / SerialCom

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of OmniWheels by Gustav Atmel

mbed-os/features/frameworks/unity/source/unity.c@1:9c5af431a1f1, 2018-05-01 (annotated)

Committer:
gustavatmel
Date:
Tue May 01 15:47:08 2018 +0000
Revision:
1:9c5af431a1f1
sdf

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gustavatmel 1:9c5af431a1f1 1 /* =========================================================================
gustavatmel 1:9c5af431a1f1 2 Unity Project - A Test Framework for C
gustavatmel 1:9c5af431a1f1 3 Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
gustavatmel 1:9c5af431a1f1 4 [Released under MIT License. Please refer to license.txt for details]
gustavatmel 1:9c5af431a1f1 5 ============================================================================ */
gustavatmel 1:9c5af431a1f1 6
gustavatmel 1:9c5af431a1f1 7 #include "unity/unity.h"
gustavatmel 1:9c5af431a1f1 8 #include "utest/unity_handler.h"
gustavatmel 1:9c5af431a1f1 9 #include <stddef.h>
gustavatmel 1:9c5af431a1f1 10
gustavatmel 1:9c5af431a1f1 11 /* If omitted from header, declare overrideable prototypes here so they're ready for use */
gustavatmel 1:9c5af431a1f1 12 #ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
gustavatmel 1:9c5af431a1f1 13 int UNITY_OUTPUT_CHAR(int);
gustavatmel 1:9c5af431a1f1 14 #endif
gustavatmel 1:9c5af431a1f1 15 #ifdef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
gustavatmel 1:9c5af431a1f1 16 int UNITY_OUTPUT_FLUSH(void);
gustavatmel 1:9c5af431a1f1 17 #endif
gustavatmel 1:9c5af431a1f1 18
gustavatmel 1:9c5af431a1f1 19 /* Helpful macros for us to use here */
gustavatmel 1:9c5af431a1f1 20 #define UNITY_FAIL_AND_BAIL { UNITY_OUTPUT_CHAR('\n'); utest_unity_assert_failure(); }
gustavatmel 1:9c5af431a1f1 21 #define UNITY_IGNORE_AND_BAIL { UNITY_OUTPUT_CHAR('\n'); utest_unity_ignore_failure(); }
gustavatmel 1:9c5af431a1f1 22
gustavatmel 1:9c5af431a1f1 23 /* return prematurely if we are already in failure or ignore state */
gustavatmel 1:9c5af431a1f1 24 #define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
gustavatmel 1:9c5af431a1f1 25
gustavatmel 1:9c5af431a1f1 26 struct _Unity Unity;
gustavatmel 1:9c5af431a1f1 27
gustavatmel 1:9c5af431a1f1 28 static const char UnityStrOk[] = "OK";
gustavatmel 1:9c5af431a1f1 29 static const char UnityStrPass[] = "PASS";
gustavatmel 1:9c5af431a1f1 30 static const char UnityStrFail[] = "FAIL";
gustavatmel 1:9c5af431a1f1 31 static const char UnityStrIgnore[] = "IGNORE";
gustavatmel 1:9c5af431a1f1 32 static const char UnityStrNull[] = "NULL";
gustavatmel 1:9c5af431a1f1 33 static const char UnityStrSpacer[] = ". ";
gustavatmel 1:9c5af431a1f1 34 static const char UnityStrExpected[] = " Expected ";
gustavatmel 1:9c5af431a1f1 35 static const char UnityStrWas[] = " Was ";
gustavatmel 1:9c5af431a1f1 36 static const char UnityStrElement[] = " Element ";
gustavatmel 1:9c5af431a1f1 37 static const char UnityStrByte[] = " Byte ";
gustavatmel 1:9c5af431a1f1 38 static const char UnityStrMemory[] = " Memory Mismatch.";
gustavatmel 1:9c5af431a1f1 39 static const char UnityStrDelta[] = " Values Not Within Delta ";
gustavatmel 1:9c5af431a1f1 40 static const char UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless.";
gustavatmel 1:9c5af431a1f1 41 static const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL";
gustavatmel 1:9c5af431a1f1 42 static const char UnityStrNullPointerForActual[] = " Actual pointer was NULL";
gustavatmel 1:9c5af431a1f1 43 static const char UnityStrNot[] = "Not ";
gustavatmel 1:9c5af431a1f1 44 static const char UnityStrInf[] = "Infinity";
gustavatmel 1:9c5af431a1f1 45 static const char UnityStrNegInf[] = "Negative Infinity";
gustavatmel 1:9c5af431a1f1 46 static const char UnityStrNaN[] = "NaN";
gustavatmel 1:9c5af431a1f1 47 static const char UnityStrDet[] = "Determinate";
gustavatmel 1:9c5af431a1f1 48 static const char UnityStrInvalidFloatTrait[] = "Invalid Float Trait";
gustavatmel 1:9c5af431a1f1 49 const char UnityStrErrFloat[] = "Unity Floating Point Disabled";
gustavatmel 1:9c5af431a1f1 50 const char UnityStrErrDouble[] = "Unity Double Precision Disabled";
gustavatmel 1:9c5af431a1f1 51 const char UnityStrErr64[] = "Unity 64-bit Support Disabled";
gustavatmel 1:9c5af431a1f1 52 static const char UnityStrBreaker[] = "-----------------------";
gustavatmel 1:9c5af431a1f1 53 static const char UnityStrResultsTests[] = " Tests ";
gustavatmel 1:9c5af431a1f1 54 static const char UnityStrResultsFailures[] = " Failures ";
gustavatmel 1:9c5af431a1f1 55 static const char UnityStrResultsIgnored[] = " Ignored ";
gustavatmel 1:9c5af431a1f1 56 static const char UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " ";
gustavatmel 1:9c5af431a1f1 57 static const char UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " ";
gustavatmel 1:9c5af431a1f1 58
gustavatmel 1:9c5af431a1f1 59 #ifdef UNITY_FLOAT_NEEDS_ZERO
gustavatmel 1:9c5af431a1f1 60 /* Dividing by these constants produces +/- infinity.
gustavatmel 1:9c5af431a1f1 61 * The rationale is given in UnityAssertFloatIsInf's body. */
gustavatmel 1:9c5af431a1f1 62 static const _UF f_zero = 0.0f;
gustavatmel 1:9c5af431a1f1 63 #endif
gustavatmel 1:9c5af431a1f1 64
gustavatmel 1:9c5af431a1f1 65 /* compiler-generic print formatting masks */
gustavatmel 1:9c5af431a1f1 66 static const _U_UINT UnitySizeMask[] =
gustavatmel 1:9c5af431a1f1 67 {
gustavatmel 1:9c5af431a1f1 68 255u, /* 0xFF */
gustavatmel 1:9c5af431a1f1 69 65535u, /* 0xFFFF */
gustavatmel 1:9c5af431a1f1 70 65535u,
gustavatmel 1:9c5af431a1f1 71 4294967295u, /* 0xFFFFFFFF */
gustavatmel 1:9c5af431a1f1 72 4294967295u,
gustavatmel 1:9c5af431a1f1 73 4294967295u,
gustavatmel 1:9c5af431a1f1 74 4294967295u
gustavatmel 1:9c5af431a1f1 75 #ifdef UNITY_SUPPORT_64
gustavatmel 1:9c5af431a1f1 76 ,0xFFFFFFFFFFFFFFFFull
gustavatmel 1:9c5af431a1f1 77 #endif
gustavatmel 1:9c5af431a1f1 78 };
gustavatmel 1:9c5af431a1f1 79
gustavatmel 1:9c5af431a1f1 80 /*-----------------------------------------------
gustavatmel 1:9c5af431a1f1 81 * Pretty Printers & Test Result Output Handlers
gustavatmel 1:9c5af431a1f1 82 *-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 83
gustavatmel 1:9c5af431a1f1 84 void UnityPrint(const char* string)
gustavatmel 1:9c5af431a1f1 85 {
gustavatmel 1:9c5af431a1f1 86 const char* pch = string;
gustavatmel 1:9c5af431a1f1 87
gustavatmel 1:9c5af431a1f1 88 if (pch != NULL)
gustavatmel 1:9c5af431a1f1 89 {
gustavatmel 1:9c5af431a1f1 90 while (*pch)
gustavatmel 1:9c5af431a1f1 91 {
gustavatmel 1:9c5af431a1f1 92 /* printable characters plus CR & LF are printed */
gustavatmel 1:9c5af431a1f1 93 if ((*pch <= 126) && (*pch >= 32))
gustavatmel 1:9c5af431a1f1 94 {
gustavatmel 1:9c5af431a1f1 95 UNITY_OUTPUT_CHAR(*pch);
gustavatmel 1:9c5af431a1f1 96 }
gustavatmel 1:9c5af431a1f1 97 /* write escaped carriage returns */
gustavatmel 1:9c5af431a1f1 98 else if (*pch == 13)
gustavatmel 1:9c5af431a1f1 99 {
gustavatmel 1:9c5af431a1f1 100 UNITY_OUTPUT_CHAR('\\');
gustavatmel 1:9c5af431a1f1 101 UNITY_OUTPUT_CHAR('r');
gustavatmel 1:9c5af431a1f1 102 }
gustavatmel 1:9c5af431a1f1 103 /* write escaped line feeds */
gustavatmel 1:9c5af431a1f1 104 else if (*pch == 10)
gustavatmel 1:9c5af431a1f1 105 {
gustavatmel 1:9c5af431a1f1 106 UNITY_OUTPUT_CHAR('\\');
gustavatmel 1:9c5af431a1f1 107 UNITY_OUTPUT_CHAR('n');
gustavatmel 1:9c5af431a1f1 108 }
gustavatmel 1:9c5af431a1f1 109 /* unprintable characters are shown as codes */
gustavatmel 1:9c5af431a1f1 110 else
gustavatmel 1:9c5af431a1f1 111 {
gustavatmel 1:9c5af431a1f1 112 UNITY_OUTPUT_CHAR('\\');
gustavatmel 1:9c5af431a1f1 113 UnityPrintNumberHex((_U_UINT)*pch, 2);
gustavatmel 1:9c5af431a1f1 114 }
gustavatmel 1:9c5af431a1f1 115 pch++;
gustavatmel 1:9c5af431a1f1 116 }
gustavatmel 1:9c5af431a1f1 117 }
gustavatmel 1:9c5af431a1f1 118 }
gustavatmel 1:9c5af431a1f1 119
gustavatmel 1:9c5af431a1f1 120 void UnityPrintLen(const char* string, const _UU32 length);
gustavatmel 1:9c5af431a1f1 121 void UnityPrintLen(const char* string, const _UU32 length)
gustavatmel 1:9c5af431a1f1 122 {
gustavatmel 1:9c5af431a1f1 123 const char* pch = string;
gustavatmel 1:9c5af431a1f1 124
gustavatmel 1:9c5af431a1f1 125 if (pch != NULL)
gustavatmel 1:9c5af431a1f1 126 {
gustavatmel 1:9c5af431a1f1 127 while (*pch && (_UU32)(pch - string) < length)
gustavatmel 1:9c5af431a1f1 128 {
gustavatmel 1:9c5af431a1f1 129 /* printable characters plus CR & LF are printed */
gustavatmel 1:9c5af431a1f1 130 if ((*pch <= 126) && (*pch >= 32))
gustavatmel 1:9c5af431a1f1 131 {
gustavatmel 1:9c5af431a1f1 132 UNITY_OUTPUT_CHAR(*pch);
gustavatmel 1:9c5af431a1f1 133 }
gustavatmel 1:9c5af431a1f1 134 /* write escaped carriage returns */
gustavatmel 1:9c5af431a1f1 135 else if (*pch == 13)
gustavatmel 1:9c5af431a1f1 136 {
gustavatmel 1:9c5af431a1f1 137 UNITY_OUTPUT_CHAR('\\');
gustavatmel 1:9c5af431a1f1 138 UNITY_OUTPUT_CHAR('r');
gustavatmel 1:9c5af431a1f1 139 }
gustavatmel 1:9c5af431a1f1 140 /* write escaped line feeds */
gustavatmel 1:9c5af431a1f1 141 else if (*pch == 10)
gustavatmel 1:9c5af431a1f1 142 {
gustavatmel 1:9c5af431a1f1 143 UNITY_OUTPUT_CHAR('\\');
gustavatmel 1:9c5af431a1f1 144 UNITY_OUTPUT_CHAR('n');
gustavatmel 1:9c5af431a1f1 145 }
gustavatmel 1:9c5af431a1f1 146 /* unprintable characters are shown as codes */
gustavatmel 1:9c5af431a1f1 147 else
gustavatmel 1:9c5af431a1f1 148 {
gustavatmel 1:9c5af431a1f1 149 UNITY_OUTPUT_CHAR('\\');
gustavatmel 1:9c5af431a1f1 150 UnityPrintNumberHex((_U_UINT)*pch, 2);
gustavatmel 1:9c5af431a1f1 151 }
gustavatmel 1:9c5af431a1f1 152 pch++;
gustavatmel 1:9c5af431a1f1 153 }
gustavatmel 1:9c5af431a1f1 154 }
gustavatmel 1:9c5af431a1f1 155 }
gustavatmel 1:9c5af431a1f1 156
gustavatmel 1:9c5af431a1f1 157 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 158 void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
gustavatmel 1:9c5af431a1f1 159 {
gustavatmel 1:9c5af431a1f1 160 if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
gustavatmel 1:9c5af431a1f1 161 {
gustavatmel 1:9c5af431a1f1 162 UnityPrintNumber(number);
gustavatmel 1:9c5af431a1f1 163 }
gustavatmel 1:9c5af431a1f1 164 else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
gustavatmel 1:9c5af431a1f1 165 {
gustavatmel 1:9c5af431a1f1 166 UnityPrintNumberUnsigned( (_U_UINT)number & UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1] );
gustavatmel 1:9c5af431a1f1 167 }
gustavatmel 1:9c5af431a1f1 168 else
gustavatmel 1:9c5af431a1f1 169 {
gustavatmel 1:9c5af431a1f1 170 UnityPrintNumberHex((_U_UINT)number, (char)((style & 0x000F) << 1));
gustavatmel 1:9c5af431a1f1 171 }
gustavatmel 1:9c5af431a1f1 172 }
gustavatmel 1:9c5af431a1f1 173
gustavatmel 1:9c5af431a1f1 174 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 175 void UnityPrintNumber(const _U_SINT number_to_print)
gustavatmel 1:9c5af431a1f1 176 {
gustavatmel 1:9c5af431a1f1 177 _U_UINT number = (_U_UINT)number_to_print;
gustavatmel 1:9c5af431a1f1 178
gustavatmel 1:9c5af431a1f1 179 if (number_to_print < 0)
gustavatmel 1:9c5af431a1f1 180 {
gustavatmel 1:9c5af431a1f1 181 /* A negative number, including MIN negative */
gustavatmel 1:9c5af431a1f1 182 UNITY_OUTPUT_CHAR('-');
gustavatmel 1:9c5af431a1f1 183 number = (_U_UINT)(-number_to_print);
gustavatmel 1:9c5af431a1f1 184 }
gustavatmel 1:9c5af431a1f1 185 UnityPrintNumberUnsigned(number);
gustavatmel 1:9c5af431a1f1 186 }
gustavatmel 1:9c5af431a1f1 187
gustavatmel 1:9c5af431a1f1 188 /*-----------------------------------------------
gustavatmel 1:9c5af431a1f1 189 * basically do an itoa using as little ram as possible */
gustavatmel 1:9c5af431a1f1 190 void UnityPrintNumberUnsigned(const _U_UINT number)
gustavatmel 1:9c5af431a1f1 191 {
gustavatmel 1:9c5af431a1f1 192 _U_UINT divisor = 1;
gustavatmel 1:9c5af431a1f1 193
gustavatmel 1:9c5af431a1f1 194 /* figure out initial divisor */
gustavatmel 1:9c5af431a1f1 195 while (number / divisor > 9)
gustavatmel 1:9c5af431a1f1 196 {
gustavatmel 1:9c5af431a1f1 197 divisor *= 10;
gustavatmel 1:9c5af431a1f1 198 }
gustavatmel 1:9c5af431a1f1 199
gustavatmel 1:9c5af431a1f1 200 /* now mod and print, then divide divisor */
gustavatmel 1:9c5af431a1f1 201 do
gustavatmel 1:9c5af431a1f1 202 {
gustavatmel 1:9c5af431a1f1 203 UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
gustavatmel 1:9c5af431a1f1 204 divisor /= 10;
gustavatmel 1:9c5af431a1f1 205 }
gustavatmel 1:9c5af431a1f1 206 while (divisor > 0);
gustavatmel 1:9c5af431a1f1 207 }
gustavatmel 1:9c5af431a1f1 208
gustavatmel 1:9c5af431a1f1 209 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 210 void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
gustavatmel 1:9c5af431a1f1 211 {
gustavatmel 1:9c5af431a1f1 212 _U_UINT nibble;
gustavatmel 1:9c5af431a1f1 213 char nibbles = nibbles_to_print;
gustavatmel 1:9c5af431a1f1 214 UNITY_OUTPUT_CHAR('0');
gustavatmel 1:9c5af431a1f1 215 UNITY_OUTPUT_CHAR('x');
gustavatmel 1:9c5af431a1f1 216
gustavatmel 1:9c5af431a1f1 217 while (nibbles > 0)
gustavatmel 1:9c5af431a1f1 218 {
gustavatmel 1:9c5af431a1f1 219 nibble = (number >> (--nibbles << 2)) & 0x0000000F;
gustavatmel 1:9c5af431a1f1 220 if (nibble <= 9)
gustavatmel 1:9c5af431a1f1 221 {
gustavatmel 1:9c5af431a1f1 222 UNITY_OUTPUT_CHAR((char)('0' + nibble));
gustavatmel 1:9c5af431a1f1 223 }
gustavatmel 1:9c5af431a1f1 224 else
gustavatmel 1:9c5af431a1f1 225 {
gustavatmel 1:9c5af431a1f1 226 UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
gustavatmel 1:9c5af431a1f1 227 }
gustavatmel 1:9c5af431a1f1 228 }
gustavatmel 1:9c5af431a1f1 229 }
gustavatmel 1:9c5af431a1f1 230
gustavatmel 1:9c5af431a1f1 231 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 232 void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
gustavatmel 1:9c5af431a1f1 233 {
gustavatmel 1:9c5af431a1f1 234 _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
gustavatmel 1:9c5af431a1f1 235 _US32 i;
gustavatmel 1:9c5af431a1f1 236
gustavatmel 1:9c5af431a1f1 237 for (i = 0; i < UNITY_INT_WIDTH; i++)
gustavatmel 1:9c5af431a1f1 238 {
gustavatmel 1:9c5af431a1f1 239 if (current_bit & mask)
gustavatmel 1:9c5af431a1f1 240 {
gustavatmel 1:9c5af431a1f1 241 if (current_bit & number)
gustavatmel 1:9c5af431a1f1 242 {
gustavatmel 1:9c5af431a1f1 243 UNITY_OUTPUT_CHAR('1');
gustavatmel 1:9c5af431a1f1 244 }
gustavatmel 1:9c5af431a1f1 245 else
gustavatmel 1:9c5af431a1f1 246 {
gustavatmel 1:9c5af431a1f1 247 UNITY_OUTPUT_CHAR('0');
gustavatmel 1:9c5af431a1f1 248 }
gustavatmel 1:9c5af431a1f1 249 }
gustavatmel 1:9c5af431a1f1 250 else
gustavatmel 1:9c5af431a1f1 251 {
gustavatmel 1:9c5af431a1f1 252 UNITY_OUTPUT_CHAR('.');
gustavatmel 1:9c5af431a1f1 253 }
gustavatmel 1:9c5af431a1f1 254 current_bit = current_bit >> 1;
gustavatmel 1:9c5af431a1f1 255 }
gustavatmel 1:9c5af431a1f1 256 }
gustavatmel 1:9c5af431a1f1 257
gustavatmel 1:9c5af431a1f1 258 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 259 #ifdef UNITY_FLOAT_VERBOSE
gustavatmel 1:9c5af431a1f1 260 #include <stdio.h>
gustavatmel 1:9c5af431a1f1 261
gustavatmel 1:9c5af431a1f1 262 #ifndef UNITY_VERBOSE_NUMBER_MAX_LENGTH
gustavatmel 1:9c5af431a1f1 263 # ifdef UNITY_DOUBLE_VERBOSE
gustavatmel 1:9c5af431a1f1 264 # define UNITY_VERBOSE_NUMBER_MAX_LENGTH 317
gustavatmel 1:9c5af431a1f1 265 # else
gustavatmel 1:9c5af431a1f1 266 # define UNITY_VERBOSE_NUMBER_MAX_LENGTH 47
gustavatmel 1:9c5af431a1f1 267 # endif
gustavatmel 1:9c5af431a1f1 268 #endif
gustavatmel 1:9c5af431a1f1 269
gustavatmel 1:9c5af431a1f1 270 void UnityPrintFloat(_UF number)
gustavatmel 1:9c5af431a1f1 271 {
gustavatmel 1:9c5af431a1f1 272 char TempBuffer[UNITY_VERBOSE_NUMBER_MAX_LENGTH + 1];
gustavatmel 1:9c5af431a1f1 273 snprintf(TempBuffer, sizeof(TempBuffer), "%.6f", number);
gustavatmel 1:9c5af431a1f1 274 UnityPrint(TempBuffer);
gustavatmel 1:9c5af431a1f1 275 }
gustavatmel 1:9c5af431a1f1 276 #endif
gustavatmel 1:9c5af431a1f1 277
gustavatmel 1:9c5af431a1f1 278 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 279
gustavatmel 1:9c5af431a1f1 280 void UnityPrintFail(void);
gustavatmel 1:9c5af431a1f1 281 void UnityPrintFail(void)
gustavatmel 1:9c5af431a1f1 282 {
gustavatmel 1:9c5af431a1f1 283 UnityPrint(UnityStrFail);
gustavatmel 1:9c5af431a1f1 284 }
gustavatmel 1:9c5af431a1f1 285
gustavatmel 1:9c5af431a1f1 286 void UnityPrintOk(void);
gustavatmel 1:9c5af431a1f1 287 void UnityPrintOk(void)
gustavatmel 1:9c5af431a1f1 288 {
gustavatmel 1:9c5af431a1f1 289 UnityPrint(UnityStrOk);
gustavatmel 1:9c5af431a1f1 290 }
gustavatmel 1:9c5af431a1f1 291
gustavatmel 1:9c5af431a1f1 292 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 293 static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line);
gustavatmel 1:9c5af431a1f1 294 static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
gustavatmel 1:9c5af431a1f1 295 {
gustavatmel 1:9c5af431a1f1 296 #ifndef UNITY_FIXTURES
gustavatmel 1:9c5af431a1f1 297 UnityPrint(file);
gustavatmel 1:9c5af431a1f1 298 UNITY_OUTPUT_CHAR(':');
gustavatmel 1:9c5af431a1f1 299 UnityPrintNumber((_U_SINT)line);
gustavatmel 1:9c5af431a1f1 300 UNITY_OUTPUT_CHAR(':');
gustavatmel 1:9c5af431a1f1 301 UnityPrint(Unity.CurrentTestName);
gustavatmel 1:9c5af431a1f1 302 UNITY_OUTPUT_CHAR(':');
gustavatmel 1:9c5af431a1f1 303 #else
gustavatmel 1:9c5af431a1f1 304 UNITY_UNUSED(file);
gustavatmel 1:9c5af431a1f1 305 UNITY_UNUSED(line);
gustavatmel 1:9c5af431a1f1 306 #endif
gustavatmel 1:9c5af431a1f1 307 }
gustavatmel 1:9c5af431a1f1 308
gustavatmel 1:9c5af431a1f1 309 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 310 static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line);
gustavatmel 1:9c5af431a1f1 311 static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
gustavatmel 1:9c5af431a1f1 312 {
gustavatmel 1:9c5af431a1f1 313 #ifndef UNITY_FIXTURES
gustavatmel 1:9c5af431a1f1 314 UnityTestResultsBegin(Unity.TestFile, line);
gustavatmel 1:9c5af431a1f1 315 #else
gustavatmel 1:9c5af431a1f1 316 UNITY_UNUSED(line);
gustavatmel 1:9c5af431a1f1 317 #endif
gustavatmel 1:9c5af431a1f1 318 UnityPrint(UnityStrFail);
gustavatmel 1:9c5af431a1f1 319 UNITY_OUTPUT_CHAR(':');
gustavatmel 1:9c5af431a1f1 320 }
gustavatmel 1:9c5af431a1f1 321
gustavatmel 1:9c5af431a1f1 322 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 323 void UnityConcludeTest(void)
gustavatmel 1:9c5af431a1f1 324 {
gustavatmel 1:9c5af431a1f1 325 if (Unity.CurrentTestIgnored)
gustavatmel 1:9c5af431a1f1 326 {
gustavatmel 1:9c5af431a1f1 327 Unity.TestIgnores++;
gustavatmel 1:9c5af431a1f1 328 }
gustavatmel 1:9c5af431a1f1 329 else if (!Unity.CurrentTestFailed)
gustavatmel 1:9c5af431a1f1 330 {
gustavatmel 1:9c5af431a1f1 331 UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
gustavatmel 1:9c5af431a1f1 332 UnityPrint(UnityStrPass);
gustavatmel 1:9c5af431a1f1 333 }
gustavatmel 1:9c5af431a1f1 334 else
gustavatmel 1:9c5af431a1f1 335 {
gustavatmel 1:9c5af431a1f1 336 Unity.TestFailures++;
gustavatmel 1:9c5af431a1f1 337 }
gustavatmel 1:9c5af431a1f1 338
gustavatmel 1:9c5af431a1f1 339 Unity.CurrentTestFailed = 0;
gustavatmel 1:9c5af431a1f1 340 Unity.CurrentTestIgnored = 0;
gustavatmel 1:9c5af431a1f1 341 UNITY_PRINT_EOL();
gustavatmel 1:9c5af431a1f1 342 UNITY_OUTPUT_FLUSH();
gustavatmel 1:9c5af431a1f1 343 }
gustavatmel 1:9c5af431a1f1 344
gustavatmel 1:9c5af431a1f1 345 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 346 static void UnityAddMsgIfSpecified(const char* msg);
gustavatmel 1:9c5af431a1f1 347 static void UnityAddMsgIfSpecified(const char* msg)
gustavatmel 1:9c5af431a1f1 348 {
gustavatmel 1:9c5af431a1f1 349 if (msg)
gustavatmel 1:9c5af431a1f1 350 {
gustavatmel 1:9c5af431a1f1 351 UnityPrint(UnityStrSpacer);
gustavatmel 1:9c5af431a1f1 352 #ifndef UNITY_EXCLUDE_DETAILS
gustavatmel 1:9c5af431a1f1 353 if (Unity.CurrentDetail1)
gustavatmel 1:9c5af431a1f1 354 {
gustavatmel 1:9c5af431a1f1 355 UnityPrint(UnityStrDetail1Name);
gustavatmel 1:9c5af431a1f1 356 UnityPrint(Unity.CurrentDetail1);
gustavatmel 1:9c5af431a1f1 357 if (Unity.CurrentDetail2)
gustavatmel 1:9c5af431a1f1 358 {
gustavatmel 1:9c5af431a1f1 359 UnityPrint(UnityStrDetail2Name);
gustavatmel 1:9c5af431a1f1 360 UnityPrint(Unity.CurrentDetail2);
gustavatmel 1:9c5af431a1f1 361 }
gustavatmel 1:9c5af431a1f1 362 UnityPrint(UnityStrSpacer);
gustavatmel 1:9c5af431a1f1 363 }
gustavatmel 1:9c5af431a1f1 364 #endif
gustavatmel 1:9c5af431a1f1 365 UnityPrint(msg);
gustavatmel 1:9c5af431a1f1 366 }
gustavatmel 1:9c5af431a1f1 367 }
gustavatmel 1:9c5af431a1f1 368
gustavatmel 1:9c5af431a1f1 369 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 370 static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual);
gustavatmel 1:9c5af431a1f1 371 static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
gustavatmel 1:9c5af431a1f1 372 {
gustavatmel 1:9c5af431a1f1 373 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 374 if (expected != NULL)
gustavatmel 1:9c5af431a1f1 375 {
gustavatmel 1:9c5af431a1f1 376 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 377 UnityPrint(expected);
gustavatmel 1:9c5af431a1f1 378 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 379 }
gustavatmel 1:9c5af431a1f1 380 else
gustavatmel 1:9c5af431a1f1 381 {
gustavatmel 1:9c5af431a1f1 382 UnityPrint(UnityStrNull);
gustavatmel 1:9c5af431a1f1 383 }
gustavatmel 1:9c5af431a1f1 384 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 385 if (actual != NULL)
gustavatmel 1:9c5af431a1f1 386 {
gustavatmel 1:9c5af431a1f1 387 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 388 UnityPrint(actual);
gustavatmel 1:9c5af431a1f1 389 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 390 }
gustavatmel 1:9c5af431a1f1 391 else
gustavatmel 1:9c5af431a1f1 392 {
gustavatmel 1:9c5af431a1f1 393 UnityPrint(UnityStrNull);
gustavatmel 1:9c5af431a1f1 394 }
gustavatmel 1:9c5af431a1f1 395 }
gustavatmel 1:9c5af431a1f1 396
gustavatmel 1:9c5af431a1f1 397 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 398 static void UnityPrintExpectedAndActualStringsLen(const char* expected, const char* actual, const _UU32 length)
gustavatmel 1:9c5af431a1f1 399 {
gustavatmel 1:9c5af431a1f1 400 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 401 if (expected != NULL)
gustavatmel 1:9c5af431a1f1 402 {
gustavatmel 1:9c5af431a1f1 403 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 404 UnityPrintLen(expected, length);
gustavatmel 1:9c5af431a1f1 405 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 406 }
gustavatmel 1:9c5af431a1f1 407 else
gustavatmel 1:9c5af431a1f1 408 {
gustavatmel 1:9c5af431a1f1 409 UnityPrint(UnityStrNull);
gustavatmel 1:9c5af431a1f1 410 }
gustavatmel 1:9c5af431a1f1 411 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 412 if (actual != NULL)
gustavatmel 1:9c5af431a1f1 413 {
gustavatmel 1:9c5af431a1f1 414 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 415 UnityPrintLen(actual, length);
gustavatmel 1:9c5af431a1f1 416 UNITY_OUTPUT_CHAR('\'');
gustavatmel 1:9c5af431a1f1 417 }
gustavatmel 1:9c5af431a1f1 418 else
gustavatmel 1:9c5af431a1f1 419 {
gustavatmel 1:9c5af431a1f1 420 UnityPrint(UnityStrNull);
gustavatmel 1:9c5af431a1f1 421 }
gustavatmel 1:9c5af431a1f1 422 }
gustavatmel 1:9c5af431a1f1 423
gustavatmel 1:9c5af431a1f1 424
gustavatmel 1:9c5af431a1f1 425
gustavatmel 1:9c5af431a1f1 426 /*-----------------------------------------------
gustavatmel 1:9c5af431a1f1 427 * Assertion & Control Helpers
gustavatmel 1:9c5af431a1f1 428 *-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 429
gustavatmel 1:9c5af431a1f1 430 static int UnityCheckArraysForNull(UNITY_INTERNAL_PTR expected, UNITY_INTERNAL_PTR actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
gustavatmel 1:9c5af431a1f1 431 {
gustavatmel 1:9c5af431a1f1 432 /* return true if they are both NULL */
gustavatmel 1:9c5af431a1f1 433 if ((expected == NULL) && (actual == NULL))
gustavatmel 1:9c5af431a1f1 434 return 1;
gustavatmel 1:9c5af431a1f1 435
gustavatmel 1:9c5af431a1f1 436 /* throw error if just expected is NULL */
gustavatmel 1:9c5af431a1f1 437 if (expected == NULL)
gustavatmel 1:9c5af431a1f1 438 {
gustavatmel 1:9c5af431a1f1 439 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 440 UnityPrint(UnityStrNullPointerForExpected);
gustavatmel 1:9c5af431a1f1 441 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 442 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 443 }
gustavatmel 1:9c5af431a1f1 444
gustavatmel 1:9c5af431a1f1 445 /* throw error if just actual is NULL */
gustavatmel 1:9c5af431a1f1 446 if (actual == NULL)
gustavatmel 1:9c5af431a1f1 447 {
gustavatmel 1:9c5af431a1f1 448 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 449 UnityPrint(UnityStrNullPointerForActual);
gustavatmel 1:9c5af431a1f1 450 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 451 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 452 }
gustavatmel 1:9c5af431a1f1 453
gustavatmel 1:9c5af431a1f1 454 /* return false if neither is NULL */
gustavatmel 1:9c5af431a1f1 455 return 0;
gustavatmel 1:9c5af431a1f1 456 }
gustavatmel 1:9c5af431a1f1 457
gustavatmel 1:9c5af431a1f1 458 /*-----------------------------------------------
gustavatmel 1:9c5af431a1f1 459 * Assertion Functions
gustavatmel 1:9c5af431a1f1 460 *-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 461
gustavatmel 1:9c5af431a1f1 462 void UnityAssertBits(const _U_SINT mask,
gustavatmel 1:9c5af431a1f1 463 const _U_SINT expected,
gustavatmel 1:9c5af431a1f1 464 const _U_SINT actual,
gustavatmel 1:9c5af431a1f1 465 const char* msg,
gustavatmel 1:9c5af431a1f1 466 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 467 {
gustavatmel 1:9c5af431a1f1 468 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 469
gustavatmel 1:9c5af431a1f1 470 if ((mask & expected) != (mask & actual))
gustavatmel 1:9c5af431a1f1 471 {
gustavatmel 1:9c5af431a1f1 472 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 473 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 474 UnityPrintMask((_U_UINT)mask, (_U_UINT)expected);
gustavatmel 1:9c5af431a1f1 475 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 476 UnityPrintMask((_U_UINT)mask, (_U_UINT)actual);
gustavatmel 1:9c5af431a1f1 477 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 478 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 479 }
gustavatmel 1:9c5af431a1f1 480 }
gustavatmel 1:9c5af431a1f1 481
gustavatmel 1:9c5af431a1f1 482 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 483 void UnityAssertEqualNumber(const _U_SINT expected,
gustavatmel 1:9c5af431a1f1 484 const _U_SINT actual,
gustavatmel 1:9c5af431a1f1 485 const char* msg,
gustavatmel 1:9c5af431a1f1 486 const UNITY_LINE_TYPE lineNumber,
gustavatmel 1:9c5af431a1f1 487 const UNITY_DISPLAY_STYLE_T style)
gustavatmel 1:9c5af431a1f1 488 {
gustavatmel 1:9c5af431a1f1 489 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 490
gustavatmel 1:9c5af431a1f1 491 if (expected != actual)
gustavatmel 1:9c5af431a1f1 492 {
gustavatmel 1:9c5af431a1f1 493 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 494 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 495 UnityPrintNumberByStyle(expected, style);
gustavatmel 1:9c5af431a1f1 496 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 497 UnityPrintNumberByStyle(actual, style);
gustavatmel 1:9c5af431a1f1 498 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 499 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 500 }
gustavatmel 1:9c5af431a1f1 501 }
gustavatmel 1:9c5af431a1f1 502
gustavatmel 1:9c5af431a1f1 503 #define UnityPrintPointlessAndBail() \
gustavatmel 1:9c5af431a1f1 504 { \
gustavatmel 1:9c5af431a1f1 505 UnityTestResultsFailBegin(lineNumber); \
gustavatmel 1:9c5af431a1f1 506 UnityPrint(UnityStrPointless); \
gustavatmel 1:9c5af431a1f1 507 UnityAddMsgIfSpecified(msg); \
gustavatmel 1:9c5af431a1f1 508 UNITY_FAIL_AND_BAIL; }
gustavatmel 1:9c5af431a1f1 509
gustavatmel 1:9c5af431a1f1 510 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 511 void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
gustavatmel 1:9c5af431a1f1 512 UNITY_INTERNAL_PTR actual,
gustavatmel 1:9c5af431a1f1 513 const _UU32 num_elements,
gustavatmel 1:9c5af431a1f1 514 const char* msg,
gustavatmel 1:9c5af431a1f1 515 const UNITY_LINE_TYPE lineNumber,
gustavatmel 1:9c5af431a1f1 516 const UNITY_DISPLAY_STYLE_T style)
gustavatmel 1:9c5af431a1f1 517 {
gustavatmel 1:9c5af431a1f1 518 _UU32 elements = num_elements;
gustavatmel 1:9c5af431a1f1 519 UNITY_INTERNAL_PTR ptr_exp = (UNITY_INTERNAL_PTR)expected;
gustavatmel 1:9c5af431a1f1 520 UNITY_INTERNAL_PTR ptr_act = (UNITY_INTERNAL_PTR)actual;
gustavatmel 1:9c5af431a1f1 521
gustavatmel 1:9c5af431a1f1 522 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 523
gustavatmel 1:9c5af431a1f1 524 if (elements == 0)
gustavatmel 1:9c5af431a1f1 525 {
gustavatmel 1:9c5af431a1f1 526 UnityPrintPointlessAndBail();
gustavatmel 1:9c5af431a1f1 527 }
gustavatmel 1:9c5af431a1f1 528
gustavatmel 1:9c5af431a1f1 529 if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
gustavatmel 1:9c5af431a1f1 530 return;
gustavatmel 1:9c5af431a1f1 531
gustavatmel 1:9c5af431a1f1 532 /* If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case
gustavatmel 1:9c5af431a1f1 533 * as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific
gustavatmel 1:9c5af431a1f1 534 * variants do not. Therefore remove this flag. */
gustavatmel 1:9c5af431a1f1 535 switch(style & (UNITY_DISPLAY_STYLE_T)(~UNITY_DISPLAY_RANGE_AUTO))
gustavatmel 1:9c5af431a1f1 536 {
gustavatmel 1:9c5af431a1f1 537 case UNITY_DISPLAY_STYLE_HEX8:
gustavatmel 1:9c5af431a1f1 538 case UNITY_DISPLAY_STYLE_INT8:
gustavatmel 1:9c5af431a1f1 539 case UNITY_DISPLAY_STYLE_UINT8:
gustavatmel 1:9c5af431a1f1 540 while (elements--)
gustavatmel 1:9c5af431a1f1 541 {
gustavatmel 1:9c5af431a1f1 542 if (*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act)
gustavatmel 1:9c5af431a1f1 543 {
gustavatmel 1:9c5af431a1f1 544 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 545 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 546 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 547 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 548 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp, style);
gustavatmel 1:9c5af431a1f1 549 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 550 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act, style);
gustavatmel 1:9c5af431a1f1 551 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 552 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 553 }
gustavatmel 1:9c5af431a1f1 554 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
gustavatmel 1:9c5af431a1f1 555 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
gustavatmel 1:9c5af431a1f1 556 }
gustavatmel 1:9c5af431a1f1 557 break;
gustavatmel 1:9c5af431a1f1 558 case UNITY_DISPLAY_STYLE_HEX16:
gustavatmel 1:9c5af431a1f1 559 case UNITY_DISPLAY_STYLE_INT16:
gustavatmel 1:9c5af431a1f1 560 case UNITY_DISPLAY_STYLE_UINT16:
gustavatmel 1:9c5af431a1f1 561 while (elements--)
gustavatmel 1:9c5af431a1f1 562 {
gustavatmel 1:9c5af431a1f1 563 if (*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act)
gustavatmel 1:9c5af431a1f1 564 {
gustavatmel 1:9c5af431a1f1 565 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 566 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 567 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 568 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 569 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp, style);
gustavatmel 1:9c5af431a1f1 570 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 571 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act, style);
gustavatmel 1:9c5af431a1f1 572 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 573 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 574 }
gustavatmel 1:9c5af431a1f1 575 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 2);
gustavatmel 1:9c5af431a1f1 576 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 2);
gustavatmel 1:9c5af431a1f1 577 }
gustavatmel 1:9c5af431a1f1 578 break;
gustavatmel 1:9c5af431a1f1 579 #ifdef UNITY_SUPPORT_64
gustavatmel 1:9c5af431a1f1 580 case UNITY_DISPLAY_STYLE_HEX64:
gustavatmel 1:9c5af431a1f1 581 case UNITY_DISPLAY_STYLE_INT64:
gustavatmel 1:9c5af431a1f1 582 case UNITY_DISPLAY_STYLE_UINT64:
gustavatmel 1:9c5af431a1f1 583 while (elements--)
gustavatmel 1:9c5af431a1f1 584 {
gustavatmel 1:9c5af431a1f1 585 if (*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act)
gustavatmel 1:9c5af431a1f1 586 {
gustavatmel 1:9c5af431a1f1 587 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 588 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 589 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 590 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 591 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp, style);
gustavatmel 1:9c5af431a1f1 592 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 593 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act, style);
gustavatmel 1:9c5af431a1f1 594 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 595 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 596 }
gustavatmel 1:9c5af431a1f1 597 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 8);
gustavatmel 1:9c5af431a1f1 598 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 8);
gustavatmel 1:9c5af431a1f1 599 }
gustavatmel 1:9c5af431a1f1 600 break;
gustavatmel 1:9c5af431a1f1 601 #endif
gustavatmel 1:9c5af431a1f1 602 default:
gustavatmel 1:9c5af431a1f1 603 while (elements--)
gustavatmel 1:9c5af431a1f1 604 {
gustavatmel 1:9c5af431a1f1 605 if (*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act)
gustavatmel 1:9c5af431a1f1 606 {
gustavatmel 1:9c5af431a1f1 607 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 608 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 609 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 610 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 611 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp, style);
gustavatmel 1:9c5af431a1f1 612 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 613 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act, style);
gustavatmel 1:9c5af431a1f1 614 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 615 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 616 }
gustavatmel 1:9c5af431a1f1 617 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 4);
gustavatmel 1:9c5af431a1f1 618 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 4);
gustavatmel 1:9c5af431a1f1 619 }
gustavatmel 1:9c5af431a1f1 620 break;
gustavatmel 1:9c5af431a1f1 621 }
gustavatmel 1:9c5af431a1f1 622 }
gustavatmel 1:9c5af431a1f1 623
gustavatmel 1:9c5af431a1f1 624 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 625 #ifndef UNITY_EXCLUDE_FLOAT
gustavatmel 1:9c5af431a1f1 626 void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
gustavatmel 1:9c5af431a1f1 627 UNITY_PTR_ATTRIBUTE const _UF* actual,
gustavatmel 1:9c5af431a1f1 628 const _UU32 num_elements,
gustavatmel 1:9c5af431a1f1 629 const char* msg,
gustavatmel 1:9c5af431a1f1 630 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 631 {
gustavatmel 1:9c5af431a1f1 632 _UU32 elements = num_elements;
gustavatmel 1:9c5af431a1f1 633 UNITY_PTR_ATTRIBUTE const _UF* ptr_expected = expected;
gustavatmel 1:9c5af431a1f1 634 UNITY_PTR_ATTRIBUTE const _UF* ptr_actual = actual;
gustavatmel 1:9c5af431a1f1 635 _UF diff, tol;
gustavatmel 1:9c5af431a1f1 636
gustavatmel 1:9c5af431a1f1 637 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 638
gustavatmel 1:9c5af431a1f1 639 if (elements == 0)
gustavatmel 1:9c5af431a1f1 640 {
gustavatmel 1:9c5af431a1f1 641 UnityPrintPointlessAndBail();
gustavatmel 1:9c5af431a1f1 642 }
gustavatmel 1:9c5af431a1f1 643
gustavatmel 1:9c5af431a1f1 644 if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
gustavatmel 1:9c5af431a1f1 645 return;
gustavatmel 1:9c5af431a1f1 646
gustavatmel 1:9c5af431a1f1 647 while (elements--)
gustavatmel 1:9c5af431a1f1 648 {
gustavatmel 1:9c5af431a1f1 649 diff = *ptr_expected - *ptr_actual;
gustavatmel 1:9c5af431a1f1 650 if (diff < 0.0f)
gustavatmel 1:9c5af431a1f1 651 diff = 0.0f - diff;
gustavatmel 1:9c5af431a1f1 652 tol = UNITY_FLOAT_PRECISION * *ptr_expected;
gustavatmel 1:9c5af431a1f1 653 if (tol < 0.0f)
gustavatmel 1:9c5af431a1f1 654 tol = 0.0f - tol;
gustavatmel 1:9c5af431a1f1 655
gustavatmel 1:9c5af431a1f1 656 /* This first part of this condition will catch any NaN or Infinite values */
gustavatmel 1:9c5af431a1f1 657 if (isnan(diff) || isinf(diff) || (diff > tol))
gustavatmel 1:9c5af431a1f1 658 {
gustavatmel 1:9c5af431a1f1 659 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 660 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 661 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 662 #ifdef UNITY_FLOAT_VERBOSE
gustavatmel 1:9c5af431a1f1 663 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 664 UnityPrintFloat(*ptr_expected);
gustavatmel 1:9c5af431a1f1 665 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 666 UnityPrintFloat(*ptr_actual);
gustavatmel 1:9c5af431a1f1 667 #else
gustavatmel 1:9c5af431a1f1 668 UnityPrint(UnityStrDelta);
gustavatmel 1:9c5af431a1f1 669 #endif
gustavatmel 1:9c5af431a1f1 670 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 671 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 672 }
gustavatmel 1:9c5af431a1f1 673 ptr_expected++;
gustavatmel 1:9c5af431a1f1 674 ptr_actual++;
gustavatmel 1:9c5af431a1f1 675 }
gustavatmel 1:9c5af431a1f1 676 }
gustavatmel 1:9c5af431a1f1 677
gustavatmel 1:9c5af431a1f1 678 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 679 void UnityAssertFloatsWithin(const _UF delta,
gustavatmel 1:9c5af431a1f1 680 const _UF expected,
gustavatmel 1:9c5af431a1f1 681 const _UF actual,
gustavatmel 1:9c5af431a1f1 682 const char* msg,
gustavatmel 1:9c5af431a1f1 683 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 684 {
gustavatmel 1:9c5af431a1f1 685 _UF diff = actual - expected;
gustavatmel 1:9c5af431a1f1 686 _UF pos_delta = delta;
gustavatmel 1:9c5af431a1f1 687
gustavatmel 1:9c5af431a1f1 688 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 689
gustavatmel 1:9c5af431a1f1 690 if (diff < 0.0f)
gustavatmel 1:9c5af431a1f1 691 {
gustavatmel 1:9c5af431a1f1 692 diff = 0.0f - diff;
gustavatmel 1:9c5af431a1f1 693 }
gustavatmel 1:9c5af431a1f1 694 if (pos_delta < 0.0f)
gustavatmel 1:9c5af431a1f1 695 {
gustavatmel 1:9c5af431a1f1 696 pos_delta = 0.0f - pos_delta;
gustavatmel 1:9c5af431a1f1 697 }
gustavatmel 1:9c5af431a1f1 698
gustavatmel 1:9c5af431a1f1 699 /* This first part of this condition will catch any NaN or Infinite values */
gustavatmel 1:9c5af431a1f1 700 if (isnan(diff) || isinf(diff) || (pos_delta < diff))
gustavatmel 1:9c5af431a1f1 701 {
gustavatmel 1:9c5af431a1f1 702 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 703 #ifdef UNITY_FLOAT_VERBOSE
gustavatmel 1:9c5af431a1f1 704 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 705 UnityPrintFloat(expected);
gustavatmel 1:9c5af431a1f1 706 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 707 UnityPrintFloat(actual);
gustavatmel 1:9c5af431a1f1 708 #else
gustavatmel 1:9c5af431a1f1 709 UnityPrint(UnityStrDelta);
gustavatmel 1:9c5af431a1f1 710 #endif
gustavatmel 1:9c5af431a1f1 711 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 712 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 713 }
gustavatmel 1:9c5af431a1f1 714 }
gustavatmel 1:9c5af431a1f1 715
gustavatmel 1:9c5af431a1f1 716 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 717 void UnityAssertFloatSpecial(const _UF actual,
gustavatmel 1:9c5af431a1f1 718 const char* msg,
gustavatmel 1:9c5af431a1f1 719 const UNITY_LINE_TYPE lineNumber,
gustavatmel 1:9c5af431a1f1 720 const UNITY_FLOAT_TRAIT_T style)
gustavatmel 1:9c5af431a1f1 721 {
gustavatmel 1:9c5af431a1f1 722 const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
gustavatmel 1:9c5af431a1f1 723 _U_SINT should_be_trait = ((_U_SINT)style & 1);
gustavatmel 1:9c5af431a1f1 724 _U_SINT is_trait = !should_be_trait;
gustavatmel 1:9c5af431a1f1 725 _U_SINT trait_index = (_U_SINT)(style >> 1);
gustavatmel 1:9c5af431a1f1 726
gustavatmel 1:9c5af431a1f1 727 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 728
gustavatmel 1:9c5af431a1f1 729 switch(style)
gustavatmel 1:9c5af431a1f1 730 {
gustavatmel 1:9c5af431a1f1 731 /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
gustavatmel 1:9c5af431a1f1 732 * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
gustavatmel 1:9c5af431a1f1 733 case UNITY_FLOAT_IS_INF:
gustavatmel 1:9c5af431a1f1 734 case UNITY_FLOAT_IS_NOT_INF:
gustavatmel 1:9c5af431a1f1 735 is_trait = isinf(actual) & ispos(actual);
gustavatmel 1:9c5af431a1f1 736 break;
gustavatmel 1:9c5af431a1f1 737 case UNITY_FLOAT_IS_NEG_INF:
gustavatmel 1:9c5af431a1f1 738 case UNITY_FLOAT_IS_NOT_NEG_INF:
gustavatmel 1:9c5af431a1f1 739 is_trait = isinf(actual) & isneg(actual);
gustavatmel 1:9c5af431a1f1 740 break;
gustavatmel 1:9c5af431a1f1 741
gustavatmel 1:9c5af431a1f1 742 /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
gustavatmel 1:9c5af431a1f1 743 case UNITY_FLOAT_IS_NAN:
gustavatmel 1:9c5af431a1f1 744 case UNITY_FLOAT_IS_NOT_NAN:
gustavatmel 1:9c5af431a1f1 745 is_trait = isnan(actual);
gustavatmel 1:9c5af431a1f1 746 break;
gustavatmel 1:9c5af431a1f1 747
gustavatmel 1:9c5af431a1f1 748 /* A determinate number is non infinite and not NaN. (therefore the opposite of the two above) */
gustavatmel 1:9c5af431a1f1 749 case UNITY_FLOAT_IS_DET:
gustavatmel 1:9c5af431a1f1 750 case UNITY_FLOAT_IS_NOT_DET:
gustavatmel 1:9c5af431a1f1 751 if (isinf(actual) | isnan(actual))
gustavatmel 1:9c5af431a1f1 752 is_trait = 0;
gustavatmel 1:9c5af431a1f1 753 else
gustavatmel 1:9c5af431a1f1 754 is_trait = 1;
gustavatmel 1:9c5af431a1f1 755 break;
gustavatmel 1:9c5af431a1f1 756
gustavatmel 1:9c5af431a1f1 757 default:
gustavatmel 1:9c5af431a1f1 758 trait_index = 0;
gustavatmel 1:9c5af431a1f1 759 trait_names[0] = UnityStrInvalidFloatTrait;
gustavatmel 1:9c5af431a1f1 760 break;
gustavatmel 1:9c5af431a1f1 761 }
gustavatmel 1:9c5af431a1f1 762
gustavatmel 1:9c5af431a1f1 763 if (is_trait != should_be_trait)
gustavatmel 1:9c5af431a1f1 764 {
gustavatmel 1:9c5af431a1f1 765 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 766 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 767 if (!should_be_trait)
gustavatmel 1:9c5af431a1f1 768 UnityPrint(UnityStrNot);
gustavatmel 1:9c5af431a1f1 769 UnityPrint(trait_names[trait_index]);
gustavatmel 1:9c5af431a1f1 770 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 771 #ifdef UNITY_FLOAT_VERBOSE
gustavatmel 1:9c5af431a1f1 772 UnityPrintFloat(actual);
gustavatmel 1:9c5af431a1f1 773 #else
gustavatmel 1:9c5af431a1f1 774 if (should_be_trait)
gustavatmel 1:9c5af431a1f1 775 UnityPrint(UnityStrNot);
gustavatmel 1:9c5af431a1f1 776 UnityPrint(trait_names[trait_index]);
gustavatmel 1:9c5af431a1f1 777 #endif
gustavatmel 1:9c5af431a1f1 778 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 779 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 780 }
gustavatmel 1:9c5af431a1f1 781 }
gustavatmel 1:9c5af431a1f1 782
gustavatmel 1:9c5af431a1f1 783 #endif /* not UNITY_EXCLUDE_FLOAT */
gustavatmel 1:9c5af431a1f1 784
gustavatmel 1:9c5af431a1f1 785 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 786 #ifndef UNITY_EXCLUDE_DOUBLE
gustavatmel 1:9c5af431a1f1 787 void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
gustavatmel 1:9c5af431a1f1 788 UNITY_PTR_ATTRIBUTE const _UD* actual,
gustavatmel 1:9c5af431a1f1 789 const _UU32 num_elements,
gustavatmel 1:9c5af431a1f1 790 const char* msg,
gustavatmel 1:9c5af431a1f1 791 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 792 {
gustavatmel 1:9c5af431a1f1 793 _UU32 elements = num_elements;
gustavatmel 1:9c5af431a1f1 794 UNITY_PTR_ATTRIBUTE const _UD* ptr_expected = expected;
gustavatmel 1:9c5af431a1f1 795 UNITY_PTR_ATTRIBUTE const _UD* ptr_actual = actual;
gustavatmel 1:9c5af431a1f1 796 _UD diff, tol;
gustavatmel 1:9c5af431a1f1 797
gustavatmel 1:9c5af431a1f1 798 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 799
gustavatmel 1:9c5af431a1f1 800 if (elements == 0)
gustavatmel 1:9c5af431a1f1 801 {
gustavatmel 1:9c5af431a1f1 802 UnityPrintPointlessAndBail();
gustavatmel 1:9c5af431a1f1 803 }
gustavatmel 1:9c5af431a1f1 804
gustavatmel 1:9c5af431a1f1 805 if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
gustavatmel 1:9c5af431a1f1 806 return;
gustavatmel 1:9c5af431a1f1 807
gustavatmel 1:9c5af431a1f1 808 while (elements--)
gustavatmel 1:9c5af431a1f1 809 {
gustavatmel 1:9c5af431a1f1 810 diff = *ptr_expected - *ptr_actual;
gustavatmel 1:9c5af431a1f1 811 if (diff < 0.0)
gustavatmel 1:9c5af431a1f1 812 diff = 0.0 - diff;
gustavatmel 1:9c5af431a1f1 813 tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
gustavatmel 1:9c5af431a1f1 814 if (tol < 0.0)
gustavatmel 1:9c5af431a1f1 815 tol = 0.0 - tol;
gustavatmel 1:9c5af431a1f1 816
gustavatmel 1:9c5af431a1f1 817 /* This first part of this condition will catch any NaN or Infinite values */
gustavatmel 1:9c5af431a1f1 818 if (isnan(diff) || isinf(diff) || (diff > tol))
gustavatmel 1:9c5af431a1f1 819 {
gustavatmel 1:9c5af431a1f1 820 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 821 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 822 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 823 #ifdef UNITY_DOUBLE_VERBOSE
gustavatmel 1:9c5af431a1f1 824 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 825 UnityPrintFloat((float)(*ptr_expected));
gustavatmel 1:9c5af431a1f1 826 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 827 UnityPrintFloat((float)(*ptr_actual));
gustavatmel 1:9c5af431a1f1 828 #else
gustavatmel 1:9c5af431a1f1 829 UnityPrint(UnityStrDelta);
gustavatmel 1:9c5af431a1f1 830 #endif
gustavatmel 1:9c5af431a1f1 831 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 832 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 833 }
gustavatmel 1:9c5af431a1f1 834 ptr_expected++;
gustavatmel 1:9c5af431a1f1 835 ptr_actual++;
gustavatmel 1:9c5af431a1f1 836 }
gustavatmel 1:9c5af431a1f1 837 }
gustavatmel 1:9c5af431a1f1 838
gustavatmel 1:9c5af431a1f1 839 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 840 void UnityAssertDoublesWithin(const _UD delta,
gustavatmel 1:9c5af431a1f1 841 const _UD expected,
gustavatmel 1:9c5af431a1f1 842 const _UD actual,
gustavatmel 1:9c5af431a1f1 843 const char* msg,
gustavatmel 1:9c5af431a1f1 844 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 845 {
gustavatmel 1:9c5af431a1f1 846 _UD diff = actual - expected;
gustavatmel 1:9c5af431a1f1 847 _UD pos_delta = delta;
gustavatmel 1:9c5af431a1f1 848
gustavatmel 1:9c5af431a1f1 849 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 850
gustavatmel 1:9c5af431a1f1 851 if (diff < 0.0)
gustavatmel 1:9c5af431a1f1 852 {
gustavatmel 1:9c5af431a1f1 853 diff = 0.0 - diff;
gustavatmel 1:9c5af431a1f1 854 }
gustavatmel 1:9c5af431a1f1 855 if (pos_delta < 0.0)
gustavatmel 1:9c5af431a1f1 856 {
gustavatmel 1:9c5af431a1f1 857 pos_delta = 0.0 - pos_delta;
gustavatmel 1:9c5af431a1f1 858 }
gustavatmel 1:9c5af431a1f1 859
gustavatmel 1:9c5af431a1f1 860 /* This first part of this condition will catch any NaN or Infinite values */
gustavatmel 1:9c5af431a1f1 861 if (isnan(diff) || isinf(diff) || (pos_delta < diff))
gustavatmel 1:9c5af431a1f1 862 {
gustavatmel 1:9c5af431a1f1 863 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 864 #ifdef UNITY_DOUBLE_VERBOSE
gustavatmel 1:9c5af431a1f1 865 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 866 UnityPrintFloat((float)expected);
gustavatmel 1:9c5af431a1f1 867 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 868 UnityPrintFloat((float)actual);
gustavatmel 1:9c5af431a1f1 869 #else
gustavatmel 1:9c5af431a1f1 870 UnityPrint(UnityStrDelta);
gustavatmel 1:9c5af431a1f1 871 #endif
gustavatmel 1:9c5af431a1f1 872 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 873 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 874 }
gustavatmel 1:9c5af431a1f1 875 }
gustavatmel 1:9c5af431a1f1 876
gustavatmel 1:9c5af431a1f1 877 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 878
gustavatmel 1:9c5af431a1f1 879 void UnityAssertDoubleSpecial(const _UD actual,
gustavatmel 1:9c5af431a1f1 880 const char* msg,
gustavatmel 1:9c5af431a1f1 881 const UNITY_LINE_TYPE lineNumber,
gustavatmel 1:9c5af431a1f1 882 const UNITY_FLOAT_TRAIT_T style)
gustavatmel 1:9c5af431a1f1 883 {
gustavatmel 1:9c5af431a1f1 884 const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
gustavatmel 1:9c5af431a1f1 885 _U_SINT should_be_trait = ((_U_SINT)style & 1);
gustavatmel 1:9c5af431a1f1 886 _U_SINT is_trait = !should_be_trait;
gustavatmel 1:9c5af431a1f1 887 _U_SINT trait_index = (_U_SINT)(style >> 1);
gustavatmel 1:9c5af431a1f1 888
gustavatmel 1:9c5af431a1f1 889 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 890
gustavatmel 1:9c5af431a1f1 891 switch(style)
gustavatmel 1:9c5af431a1f1 892 {
gustavatmel 1:9c5af431a1f1 893 /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
gustavatmel 1:9c5af431a1f1 894 * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
gustavatmel 1:9c5af431a1f1 895 case UNITY_FLOAT_IS_INF:
gustavatmel 1:9c5af431a1f1 896 case UNITY_FLOAT_IS_NOT_INF:
gustavatmel 1:9c5af431a1f1 897 is_trait = isinf(actual) & ispos(actual);
gustavatmel 1:9c5af431a1f1 898 break;
gustavatmel 1:9c5af431a1f1 899 case UNITY_FLOAT_IS_NEG_INF:
gustavatmel 1:9c5af431a1f1 900 case UNITY_FLOAT_IS_NOT_NEG_INF:
gustavatmel 1:9c5af431a1f1 901 is_trait = isinf(actual) & isneg(actual);
gustavatmel 1:9c5af431a1f1 902 break;
gustavatmel 1:9c5af431a1f1 903
gustavatmel 1:9c5af431a1f1 904 /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
gustavatmel 1:9c5af431a1f1 905 case UNITY_FLOAT_IS_NAN:
gustavatmel 1:9c5af431a1f1 906 case UNITY_FLOAT_IS_NOT_NAN:
gustavatmel 1:9c5af431a1f1 907 is_trait = isnan(actual);
gustavatmel 1:9c5af431a1f1 908 break;
gustavatmel 1:9c5af431a1f1 909
gustavatmel 1:9c5af431a1f1 910 /* A determinate number is non infinite and not NaN. (therefore the opposite of the two above) */
gustavatmel 1:9c5af431a1f1 911 case UNITY_FLOAT_IS_DET:
gustavatmel 1:9c5af431a1f1 912 case UNITY_FLOAT_IS_NOT_DET:
gustavatmel 1:9c5af431a1f1 913 if (isinf(actual) | isnan(actual))
gustavatmel 1:9c5af431a1f1 914 is_trait = 0;
gustavatmel 1:9c5af431a1f1 915 else
gustavatmel 1:9c5af431a1f1 916 is_trait = 1;
gustavatmel 1:9c5af431a1f1 917 break;
gustavatmel 1:9c5af431a1f1 918
gustavatmel 1:9c5af431a1f1 919 default:
gustavatmel 1:9c5af431a1f1 920 trait_index = 0;
gustavatmel 1:9c5af431a1f1 921 trait_names[0] = UnityStrInvalidFloatTrait;
gustavatmel 1:9c5af431a1f1 922 break;
gustavatmel 1:9c5af431a1f1 923 }
gustavatmel 1:9c5af431a1f1 924
gustavatmel 1:9c5af431a1f1 925 if (is_trait != should_be_trait)
gustavatmel 1:9c5af431a1f1 926 {
gustavatmel 1:9c5af431a1f1 927 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 928 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 929 if (!should_be_trait)
gustavatmel 1:9c5af431a1f1 930 UnityPrint(UnityStrNot);
gustavatmel 1:9c5af431a1f1 931 UnityPrint(trait_names[trait_index]);
gustavatmel 1:9c5af431a1f1 932 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 933 #ifdef UNITY_DOUBLE_VERBOSE
gustavatmel 1:9c5af431a1f1 934 UnityPrintFloat(actual);
gustavatmel 1:9c5af431a1f1 935 #else
gustavatmel 1:9c5af431a1f1 936 if (should_be_trait)
gustavatmel 1:9c5af431a1f1 937 UnityPrint(UnityStrNot);
gustavatmel 1:9c5af431a1f1 938 UnityPrint(trait_names[trait_index]);
gustavatmel 1:9c5af431a1f1 939 #endif
gustavatmel 1:9c5af431a1f1 940 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 941 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 942 }
gustavatmel 1:9c5af431a1f1 943 }
gustavatmel 1:9c5af431a1f1 944
gustavatmel 1:9c5af431a1f1 945
gustavatmel 1:9c5af431a1f1 946 #endif /* not UNITY_EXCLUDE_DOUBLE */
gustavatmel 1:9c5af431a1f1 947
gustavatmel 1:9c5af431a1f1 948 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 949 void UnityAssertNumbersWithin( const _U_UINT delta,
gustavatmel 1:9c5af431a1f1 950 const _U_SINT expected,
gustavatmel 1:9c5af431a1f1 951 const _U_SINT actual,
gustavatmel 1:9c5af431a1f1 952 const char* msg,
gustavatmel 1:9c5af431a1f1 953 const UNITY_LINE_TYPE lineNumber,
gustavatmel 1:9c5af431a1f1 954 const UNITY_DISPLAY_STYLE_T style)
gustavatmel 1:9c5af431a1f1 955 {
gustavatmel 1:9c5af431a1f1 956 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 957
gustavatmel 1:9c5af431a1f1 958 if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
gustavatmel 1:9c5af431a1f1 959 {
gustavatmel 1:9c5af431a1f1 960 if (actual > expected)
gustavatmel 1:9c5af431a1f1 961 Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > delta);
gustavatmel 1:9c5af431a1f1 962 else
gustavatmel 1:9c5af431a1f1 963 Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > delta);
gustavatmel 1:9c5af431a1f1 964 }
gustavatmel 1:9c5af431a1f1 965 else
gustavatmel 1:9c5af431a1f1 966 {
gustavatmel 1:9c5af431a1f1 967 if ((_U_UINT)actual > (_U_UINT)expected)
gustavatmel 1:9c5af431a1f1 968 Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > delta);
gustavatmel 1:9c5af431a1f1 969 else
gustavatmel 1:9c5af431a1f1 970 Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > delta);
gustavatmel 1:9c5af431a1f1 971 }
gustavatmel 1:9c5af431a1f1 972
gustavatmel 1:9c5af431a1f1 973 if (Unity.CurrentTestFailed)
gustavatmel 1:9c5af431a1f1 974 {
gustavatmel 1:9c5af431a1f1 975 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 976 UnityPrint(UnityStrDelta);
gustavatmel 1:9c5af431a1f1 977 UnityPrintNumberByStyle((_U_SINT)delta, style);
gustavatmel 1:9c5af431a1f1 978 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 979 UnityPrintNumberByStyle(expected, style);
gustavatmel 1:9c5af431a1f1 980 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 981 UnityPrintNumberByStyle(actual, style);
gustavatmel 1:9c5af431a1f1 982 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 983 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 984 }
gustavatmel 1:9c5af431a1f1 985 }
gustavatmel 1:9c5af431a1f1 986
gustavatmel 1:9c5af431a1f1 987 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 988 void UnityAssertEqualString(const char* expected,
gustavatmel 1:9c5af431a1f1 989 const char* actual,
gustavatmel 1:9c5af431a1f1 990 const char* msg,
gustavatmel 1:9c5af431a1f1 991 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 992 {
gustavatmel 1:9c5af431a1f1 993 _UU32 i;
gustavatmel 1:9c5af431a1f1 994
gustavatmel 1:9c5af431a1f1 995 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 996
gustavatmel 1:9c5af431a1f1 997 /* if both pointers not null compare the strings */
gustavatmel 1:9c5af431a1f1 998 if (expected && actual)
gustavatmel 1:9c5af431a1f1 999 {
gustavatmel 1:9c5af431a1f1 1000 for (i = 0; expected[i] || actual[i]; i++)
gustavatmel 1:9c5af431a1f1 1001 {
gustavatmel 1:9c5af431a1f1 1002 if (expected[i] != actual[i])
gustavatmel 1:9c5af431a1f1 1003 {
gustavatmel 1:9c5af431a1f1 1004 Unity.CurrentTestFailed = 1;
gustavatmel 1:9c5af431a1f1 1005 break;
gustavatmel 1:9c5af431a1f1 1006 }
gustavatmel 1:9c5af431a1f1 1007 }
gustavatmel 1:9c5af431a1f1 1008 }
gustavatmel 1:9c5af431a1f1 1009 else
gustavatmel 1:9c5af431a1f1 1010 { /* handle case of one pointers being null (if both null, test should pass) */
gustavatmel 1:9c5af431a1f1 1011 if (expected != actual)
gustavatmel 1:9c5af431a1f1 1012 {
gustavatmel 1:9c5af431a1f1 1013 Unity.CurrentTestFailed = 1;
gustavatmel 1:9c5af431a1f1 1014 }
gustavatmel 1:9c5af431a1f1 1015 }
gustavatmel 1:9c5af431a1f1 1016
gustavatmel 1:9c5af431a1f1 1017 if (Unity.CurrentTestFailed)
gustavatmel 1:9c5af431a1f1 1018 {
gustavatmel 1:9c5af431a1f1 1019 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 1020 UnityPrintExpectedAndActualStrings(expected, actual);
gustavatmel 1:9c5af431a1f1 1021 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 1022 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 1023 }
gustavatmel 1:9c5af431a1f1 1024 }
gustavatmel 1:9c5af431a1f1 1025
gustavatmel 1:9c5af431a1f1 1026 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1027 void UnityAssertEqualStringLen(const char* expected,
gustavatmel 1:9c5af431a1f1 1028 const char* actual,
gustavatmel 1:9c5af431a1f1 1029 const _UU32 length,
gustavatmel 1:9c5af431a1f1 1030 const char* msg,
gustavatmel 1:9c5af431a1f1 1031 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 1032 {
gustavatmel 1:9c5af431a1f1 1033 _UU32 i;
gustavatmel 1:9c5af431a1f1 1034
gustavatmel 1:9c5af431a1f1 1035 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 1036
gustavatmel 1:9c5af431a1f1 1037 /* if both pointers not null compare the strings */
gustavatmel 1:9c5af431a1f1 1038 if (expected && actual)
gustavatmel 1:9c5af431a1f1 1039 {
gustavatmel 1:9c5af431a1f1 1040 for (i = 0; (expected[i] || actual[i]) && i < length; i++)
gustavatmel 1:9c5af431a1f1 1041 {
gustavatmel 1:9c5af431a1f1 1042 if (expected[i] != actual[i])
gustavatmel 1:9c5af431a1f1 1043 {
gustavatmel 1:9c5af431a1f1 1044 Unity.CurrentTestFailed = 1;
gustavatmel 1:9c5af431a1f1 1045 break;
gustavatmel 1:9c5af431a1f1 1046 }
gustavatmel 1:9c5af431a1f1 1047 }
gustavatmel 1:9c5af431a1f1 1048 }
gustavatmel 1:9c5af431a1f1 1049 else
gustavatmel 1:9c5af431a1f1 1050 { /* handle case of one pointers being null (if both null, test should pass) */
gustavatmel 1:9c5af431a1f1 1051 if (expected != actual)
gustavatmel 1:9c5af431a1f1 1052 {
gustavatmel 1:9c5af431a1f1 1053 Unity.CurrentTestFailed = 1;
gustavatmel 1:9c5af431a1f1 1054 }
gustavatmel 1:9c5af431a1f1 1055 }
gustavatmel 1:9c5af431a1f1 1056
gustavatmel 1:9c5af431a1f1 1057 if (Unity.CurrentTestFailed)
gustavatmel 1:9c5af431a1f1 1058 {
gustavatmel 1:9c5af431a1f1 1059 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 1060 UnityPrintExpectedAndActualStringsLen(expected, actual, length);
gustavatmel 1:9c5af431a1f1 1061 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 1062 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 1063 }
gustavatmel 1:9c5af431a1f1 1064 }
gustavatmel 1:9c5af431a1f1 1065
gustavatmel 1:9c5af431a1f1 1066
gustavatmel 1:9c5af431a1f1 1067 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1068 void UnityAssertEqualStringArray( const char** expected,
gustavatmel 1:9c5af431a1f1 1069 const char** actual,
gustavatmel 1:9c5af431a1f1 1070 const _UU32 num_elements,
gustavatmel 1:9c5af431a1f1 1071 const char* msg,
gustavatmel 1:9c5af431a1f1 1072 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 1073 {
gustavatmel 1:9c5af431a1f1 1074 _UU32 i, j = 0;
gustavatmel 1:9c5af431a1f1 1075
gustavatmel 1:9c5af431a1f1 1076 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 1077
gustavatmel 1:9c5af431a1f1 1078 /* if no elements, it's an error */
gustavatmel 1:9c5af431a1f1 1079 if (num_elements == 0)
gustavatmel 1:9c5af431a1f1 1080 {
gustavatmel 1:9c5af431a1f1 1081 UnityPrintPointlessAndBail();
gustavatmel 1:9c5af431a1f1 1082 }
gustavatmel 1:9c5af431a1f1 1083
gustavatmel 1:9c5af431a1f1 1084 if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
gustavatmel 1:9c5af431a1f1 1085 return;
gustavatmel 1:9c5af431a1f1 1086
gustavatmel 1:9c5af431a1f1 1087 do
gustavatmel 1:9c5af431a1f1 1088 {
gustavatmel 1:9c5af431a1f1 1089 /* if both pointers not null compare the strings */
gustavatmel 1:9c5af431a1f1 1090 if (expected[j] && actual[j])
gustavatmel 1:9c5af431a1f1 1091 {
gustavatmel 1:9c5af431a1f1 1092 for (i = 0; expected[j][i] || actual[j][i]; i++)
gustavatmel 1:9c5af431a1f1 1093 {
gustavatmel 1:9c5af431a1f1 1094 if (expected[j][i] != actual[j][i])
gustavatmel 1:9c5af431a1f1 1095 {
gustavatmel 1:9c5af431a1f1 1096 Unity.CurrentTestFailed = 1;
gustavatmel 1:9c5af431a1f1 1097 break;
gustavatmel 1:9c5af431a1f1 1098 }
gustavatmel 1:9c5af431a1f1 1099 }
gustavatmel 1:9c5af431a1f1 1100 }
gustavatmel 1:9c5af431a1f1 1101 else
gustavatmel 1:9c5af431a1f1 1102 { /* handle case of one pointers being null (if both null, test should pass) */
gustavatmel 1:9c5af431a1f1 1103 if (expected[j] != actual[j])
gustavatmel 1:9c5af431a1f1 1104 {
gustavatmel 1:9c5af431a1f1 1105 Unity.CurrentTestFailed = 1;
gustavatmel 1:9c5af431a1f1 1106 }
gustavatmel 1:9c5af431a1f1 1107 }
gustavatmel 1:9c5af431a1f1 1108
gustavatmel 1:9c5af431a1f1 1109 if (Unity.CurrentTestFailed)
gustavatmel 1:9c5af431a1f1 1110 {
gustavatmel 1:9c5af431a1f1 1111 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 1112 if (num_elements > 1)
gustavatmel 1:9c5af431a1f1 1113 {
gustavatmel 1:9c5af431a1f1 1114 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 1115 UnityPrintNumberUnsigned(j);
gustavatmel 1:9c5af431a1f1 1116 }
gustavatmel 1:9c5af431a1f1 1117 UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
gustavatmel 1:9c5af431a1f1 1118 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 1119 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 1120 }
gustavatmel 1:9c5af431a1f1 1121 } while (++j < num_elements);
gustavatmel 1:9c5af431a1f1 1122 }
gustavatmel 1:9c5af431a1f1 1123
gustavatmel 1:9c5af431a1f1 1124 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1125 void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
gustavatmel 1:9c5af431a1f1 1126 UNITY_INTERNAL_PTR actual,
gustavatmel 1:9c5af431a1f1 1127 const _UU32 length,
gustavatmel 1:9c5af431a1f1 1128 const _UU32 num_elements,
gustavatmel 1:9c5af431a1f1 1129 const char* msg,
gustavatmel 1:9c5af431a1f1 1130 const UNITY_LINE_TYPE lineNumber)
gustavatmel 1:9c5af431a1f1 1131 {
gustavatmel 1:9c5af431a1f1 1132 UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected;
gustavatmel 1:9c5af431a1f1 1133 UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual;
gustavatmel 1:9c5af431a1f1 1134 _UU32 elements = num_elements;
gustavatmel 1:9c5af431a1f1 1135 _UU32 bytes;
gustavatmel 1:9c5af431a1f1 1136
gustavatmel 1:9c5af431a1f1 1137 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 1138
gustavatmel 1:9c5af431a1f1 1139 if ((elements == 0) || (length == 0))
gustavatmel 1:9c5af431a1f1 1140 {
gustavatmel 1:9c5af431a1f1 1141 UnityPrintPointlessAndBail();
gustavatmel 1:9c5af431a1f1 1142 }
gustavatmel 1:9c5af431a1f1 1143
gustavatmel 1:9c5af431a1f1 1144 if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
gustavatmel 1:9c5af431a1f1 1145 return;
gustavatmel 1:9c5af431a1f1 1146
gustavatmel 1:9c5af431a1f1 1147 while (elements--)
gustavatmel 1:9c5af431a1f1 1148 {
gustavatmel 1:9c5af431a1f1 1149 /* /////////////////////////////////// */
gustavatmel 1:9c5af431a1f1 1150 bytes = length;
gustavatmel 1:9c5af431a1f1 1151 while (bytes--)
gustavatmel 1:9c5af431a1f1 1152 {
gustavatmel 1:9c5af431a1f1 1153 if (*ptr_exp != *ptr_act)
gustavatmel 1:9c5af431a1f1 1154 {
gustavatmel 1:9c5af431a1f1 1155 UnityTestResultsFailBegin(lineNumber);
gustavatmel 1:9c5af431a1f1 1156 UnityPrint(UnityStrMemory);
gustavatmel 1:9c5af431a1f1 1157 if (num_elements > 1)
gustavatmel 1:9c5af431a1f1 1158 {
gustavatmel 1:9c5af431a1f1 1159 UnityPrint(UnityStrElement);
gustavatmel 1:9c5af431a1f1 1160 UnityPrintNumberUnsigned(num_elements - elements - 1);
gustavatmel 1:9c5af431a1f1 1161 }
gustavatmel 1:9c5af431a1f1 1162 UnityPrint(UnityStrByte);
gustavatmel 1:9c5af431a1f1 1163 UnityPrintNumberUnsigned(length - bytes - 1);
gustavatmel 1:9c5af431a1f1 1164 UnityPrint(UnityStrExpected);
gustavatmel 1:9c5af431a1f1 1165 UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
gustavatmel 1:9c5af431a1f1 1166 UnityPrint(UnityStrWas);
gustavatmel 1:9c5af431a1f1 1167 UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
gustavatmel 1:9c5af431a1f1 1168 UnityAddMsgIfSpecified(msg);
gustavatmel 1:9c5af431a1f1 1169 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 1170 }
gustavatmel 1:9c5af431a1f1 1171 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
gustavatmel 1:9c5af431a1f1 1172 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
gustavatmel 1:9c5af431a1f1 1173 }
gustavatmel 1:9c5af431a1f1 1174 /* /////////////////////////////////// */
gustavatmel 1:9c5af431a1f1 1175
gustavatmel 1:9c5af431a1f1 1176 }
gustavatmel 1:9c5af431a1f1 1177 }
gustavatmel 1:9c5af431a1f1 1178
gustavatmel 1:9c5af431a1f1 1179 /*-----------------------------------------------
gustavatmel 1:9c5af431a1f1 1180 * Control Functions
gustavatmel 1:9c5af431a1f1 1181 *-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1182
gustavatmel 1:9c5af431a1f1 1183 void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
gustavatmel 1:9c5af431a1f1 1184 {
gustavatmel 1:9c5af431a1f1 1185 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 1186
gustavatmel 1:9c5af431a1f1 1187 UnityTestResultsBegin(Unity.TestFile, line);
gustavatmel 1:9c5af431a1f1 1188 UnityPrintFail();
gustavatmel 1:9c5af431a1f1 1189 if (msg != NULL)
gustavatmel 1:9c5af431a1f1 1190 {
gustavatmel 1:9c5af431a1f1 1191 UNITY_OUTPUT_CHAR(':');
gustavatmel 1:9c5af431a1f1 1192
gustavatmel 1:9c5af431a1f1 1193 #ifndef UNITY_EXCLUDE_DETAILS
gustavatmel 1:9c5af431a1f1 1194 if (Unity.CurrentDetail1)
gustavatmel 1:9c5af431a1f1 1195 {
gustavatmel 1:9c5af431a1f1 1196 UnityPrint(UnityStrDetail1Name);
gustavatmel 1:9c5af431a1f1 1197 UnityPrint(Unity.CurrentDetail1);
gustavatmel 1:9c5af431a1f1 1198 if (Unity.CurrentDetail2)
gustavatmel 1:9c5af431a1f1 1199 {
gustavatmel 1:9c5af431a1f1 1200 UnityPrint(UnityStrDetail2Name);
gustavatmel 1:9c5af431a1f1 1201 UnityPrint(Unity.CurrentDetail2);
gustavatmel 1:9c5af431a1f1 1202 }
gustavatmel 1:9c5af431a1f1 1203 UnityPrint(UnityStrSpacer);
gustavatmel 1:9c5af431a1f1 1204 }
gustavatmel 1:9c5af431a1f1 1205 #endif
gustavatmel 1:9c5af431a1f1 1206 if (msg[0] != ' ')
gustavatmel 1:9c5af431a1f1 1207 {
gustavatmel 1:9c5af431a1f1 1208 UNITY_OUTPUT_CHAR(' ');
gustavatmel 1:9c5af431a1f1 1209 }
gustavatmel 1:9c5af431a1f1 1210 UnityPrint(msg);
gustavatmel 1:9c5af431a1f1 1211 }
gustavatmel 1:9c5af431a1f1 1212 UNITY_FAIL_AND_BAIL;
gustavatmel 1:9c5af431a1f1 1213 }
gustavatmel 1:9c5af431a1f1 1214
gustavatmel 1:9c5af431a1f1 1215 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1216 void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
gustavatmel 1:9c5af431a1f1 1217 {
gustavatmel 1:9c5af431a1f1 1218 UNITY_SKIP_EXECUTION;
gustavatmel 1:9c5af431a1f1 1219
gustavatmel 1:9c5af431a1f1 1220 UnityTestResultsBegin(Unity.TestFile, line);
gustavatmel 1:9c5af431a1f1 1221 UnityPrint(UnityStrIgnore);
gustavatmel 1:9c5af431a1f1 1222 if (msg != NULL)
gustavatmel 1:9c5af431a1f1 1223 {
gustavatmel 1:9c5af431a1f1 1224 UNITY_OUTPUT_CHAR(':');
gustavatmel 1:9c5af431a1f1 1225 UNITY_OUTPUT_CHAR(' ');
gustavatmel 1:9c5af431a1f1 1226 UnityPrint(msg);
gustavatmel 1:9c5af431a1f1 1227 }
gustavatmel 1:9c5af431a1f1 1228 UNITY_IGNORE_AND_BAIL;
gustavatmel 1:9c5af431a1f1 1229 }
gustavatmel 1:9c5af431a1f1 1230
gustavatmel 1:9c5af431a1f1 1231 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1232 #if defined(UNITY_WEAK_ATTRIBUTE)
gustavatmel 1:9c5af431a1f1 1233 UNITY_WEAK_ATTRIBUTE void setUp(void) { }
gustavatmel 1:9c5af431a1f1 1234 UNITY_WEAK_ATTRIBUTE void tearDown(void) { }
gustavatmel 1:9c5af431a1f1 1235 #elif defined(UNITY_WEAK_PRAGMA)
gustavatmel 1:9c5af431a1f1 1236 # pragma weak setUp
gustavatmel 1:9c5af431a1f1 1237 void setUp(void) { }
gustavatmel 1:9c5af431a1f1 1238 # pragma weak tearDown
gustavatmel 1:9c5af431a1f1 1239 void tearDown(void) { }
gustavatmel 1:9c5af431a1f1 1240 #endif
gustavatmel 1:9c5af431a1f1 1241 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1242 void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
gustavatmel 1:9c5af431a1f1 1243 {
gustavatmel 1:9c5af431a1f1 1244 Unity.CurrentTestName = FuncName;
gustavatmel 1:9c5af431a1f1 1245 Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
gustavatmel 1:9c5af431a1f1 1246 Unity.NumberOfTests++;
gustavatmel 1:9c5af431a1f1 1247 UNITY_CLR_DETAILS();
gustavatmel 1:9c5af431a1f1 1248 if (TEST_PROTECT())
gustavatmel 1:9c5af431a1f1 1249 {
gustavatmel 1:9c5af431a1f1 1250 setUp();
gustavatmel 1:9c5af431a1f1 1251 Func();
gustavatmel 1:9c5af431a1f1 1252 }
gustavatmel 1:9c5af431a1f1 1253 if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
gustavatmel 1:9c5af431a1f1 1254 {
gustavatmel 1:9c5af431a1f1 1255 tearDown();
gustavatmel 1:9c5af431a1f1 1256 }
gustavatmel 1:9c5af431a1f1 1257 UnityConcludeTest();
gustavatmel 1:9c5af431a1f1 1258 }
gustavatmel 1:9c5af431a1f1 1259
gustavatmel 1:9c5af431a1f1 1260 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1261 void UnityBegin(const char* filename)
gustavatmel 1:9c5af431a1f1 1262 {
gustavatmel 1:9c5af431a1f1 1263 Unity.TestFile = filename;
gustavatmel 1:9c5af431a1f1 1264 Unity.CurrentTestName = NULL;
gustavatmel 1:9c5af431a1f1 1265 Unity.CurrentTestLineNumber = 0;
gustavatmel 1:9c5af431a1f1 1266 Unity.NumberOfTests = 0;
gustavatmel 1:9c5af431a1f1 1267 Unity.TestFailures = 0;
gustavatmel 1:9c5af431a1f1 1268 Unity.TestIgnores = 0;
gustavatmel 1:9c5af431a1f1 1269 Unity.CurrentTestFailed = 0;
gustavatmel 1:9c5af431a1f1 1270 Unity.CurrentTestIgnored = 0;
gustavatmel 1:9c5af431a1f1 1271
gustavatmel 1:9c5af431a1f1 1272 UNITY_CLR_DETAILS();
gustavatmel 1:9c5af431a1f1 1273 UNITY_OUTPUT_START();
gustavatmel 1:9c5af431a1f1 1274 }
gustavatmel 1:9c5af431a1f1 1275
gustavatmel 1:9c5af431a1f1 1276 /*-----------------------------------------------*/
gustavatmel 1:9c5af431a1f1 1277 int UnityEnd(void)
gustavatmel 1:9c5af431a1f1 1278 {
gustavatmel 1:9c5af431a1f1 1279 UNITY_PRINT_EOL();
gustavatmel 1:9c5af431a1f1 1280 UnityPrint(UnityStrBreaker);
gustavatmel 1:9c5af431a1f1 1281 UNITY_PRINT_EOL();
gustavatmel 1:9c5af431a1f1 1282 UnityPrintNumber((_U_SINT)(Unity.NumberOfTests));
gustavatmel 1:9c5af431a1f1 1283 UnityPrint(UnityStrResultsTests);
gustavatmel 1:9c5af431a1f1 1284 UnityPrintNumber((_U_SINT)(Unity.TestFailures));
gustavatmel 1:9c5af431a1f1 1285 UnityPrint(UnityStrResultsFailures);
gustavatmel 1:9c5af431a1f1 1286 UnityPrintNumber((_U_SINT)(Unity.TestIgnores));
gustavatmel 1:9c5af431a1f1 1287 UnityPrint(UnityStrResultsIgnored);
gustavatmel 1:9c5af431a1f1 1288 UNITY_PRINT_EOL();
gustavatmel 1:9c5af431a1f1 1289 if (Unity.TestFailures == 0U)
gustavatmel 1:9c5af431a1f1 1290 {
gustavatmel 1:9c5af431a1f1 1291 UnityPrintOk();
gustavatmel 1:9c5af431a1f1 1292 }
gustavatmel 1:9c5af431a1f1 1293 else
gustavatmel 1:9c5af431a1f1 1294 {
gustavatmel 1:9c5af431a1f1 1295 UnityPrintFail();
gustavatmel 1:9c5af431a1f1 1296 #ifdef UNITY_DIFFERENTIATE_FINAL_FAIL
gustavatmel 1:9c5af431a1f1 1297 UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D');
gustavatmel 1:9c5af431a1f1 1298 #endif
gustavatmel 1:9c5af431a1f1 1299 }
gustavatmel 1:9c5af431a1f1 1300 UNITY_PRINT_EOL();
gustavatmel 1:9c5af431a1f1 1301 UNITY_OUTPUT_FLUSH();
gustavatmel 1:9c5af431a1f1 1302 UNITY_OUTPUT_COMPLETE();
gustavatmel 1:9c5af431a1f1 1303 return (int)(Unity.TestFailures);
gustavatmel 1:9c5af431a1f1 1304 }
gustavatmel 1:9c5af431a1f1 1305
gustavatmel 1:9c5af431a1f1 1306 /*-----------------------------------------------*/