Toyomasa Watarai / simple-mbed-cloud-client

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.

Dependents:  

mbed-cloud-client/mbed-client-pal/Test/Unity/src/unity.c@0:276e7a263c35, 2018-07-02 (annotated)

Committer:
MACRUM
Date:
Mon Jul 02 06:30:39 2018 +0000
Revision:
0:276e7a263c35
Initial commit

Who changed what in which revision?

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