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/test/tests/testunity.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 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 <setjmp.h>
MACRUM 0:276e7a263c35 8 #include "unity.h"
MACRUM 0:276e7a263c35 9 #include <string.h>
MACRUM 0:276e7a263c35 10
MACRUM 0:276e7a263c35 11 // Dividing by these constants produces +/- infinity.
MACRUM 0:276e7a263c35 12 // The rationale is given in UnityAssertFloatIsInf's body.
MACRUM 0:276e7a263c35 13 #ifndef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 14 static const _UF f_zero = 0.0f;
MACRUM 0:276e7a263c35 15 #endif
MACRUM 0:276e7a263c35 16
MACRUM 0:276e7a263c35 17 #ifndef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 18 static const _UD d_zero = 0.0;
MACRUM 0:276e7a263c35 19 #endif
MACRUM 0:276e7a263c35 20
MACRUM 0:276e7a263c35 21 #define EXPECT_ABORT_BEGIN \
MACRUM 0:276e7a263c35 22 if (TEST_PROTECT()) \
MACRUM 0:276e7a263c35 23 {
MACRUM 0:276e7a263c35 24
MACRUM 0:276e7a263c35 25 #define VERIFY_FAILS_END \
MACRUM 0:276e7a263c35 26 } \
MACRUM 0:276e7a263c35 27 Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \
MACRUM 0:276e7a263c35 28 if (Unity.CurrentTestFailed == 1) { \
MACRUM 0:276e7a263c35 29 SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
MACRUM 0:276e7a263c35 30 UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \
MACRUM 0:276e7a263c35 31 UNITY_OUTPUT_CHAR(':'); \
MACRUM 0:276e7a263c35 32 UnityPrint(Unity.CurrentTestName); \
MACRUM 0:276e7a263c35 33 UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]"); \
MACRUM 0:276e7a263c35 34 UNITY_OUTPUT_CHAR('\n'); \
MACRUM 0:276e7a263c35 35 }
MACRUM 0:276e7a263c35 36
MACRUM 0:276e7a263c35 37 #define VERIFY_IGNORES_END \
MACRUM 0:276e7a263c35 38 } \
MACRUM 0:276e7a263c35 39 Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \
MACRUM 0:276e7a263c35 40 Unity.CurrentTestIgnored = 0; \
MACRUM 0:276e7a263c35 41 if (Unity.CurrentTestFailed == 1) { \
MACRUM 0:276e7a263c35 42 SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
MACRUM 0:276e7a263c35 43 UnityPrint("[[[[ Previous Test Should Have Ignored But Did Not ]]]]"); \
MACRUM 0:276e7a263c35 44 UNITY_OUTPUT_CHAR('\n'); \
MACRUM 0:276e7a263c35 45 }
MACRUM 0:276e7a263c35 46
MACRUM 0:276e7a263c35 47 static int SetToOneToFailInTearDown;
MACRUM 0:276e7a263c35 48 static int SetToOneMeanWeAlreadyCheckedThisGuy;
MACRUM 0:276e7a263c35 49
MACRUM 0:276e7a263c35 50 void setUp(void)
MACRUM 0:276e7a263c35 51 {
MACRUM 0:276e7a263c35 52 SetToOneToFailInTearDown = 0;
MACRUM 0:276e7a263c35 53 SetToOneMeanWeAlreadyCheckedThisGuy = 0;
MACRUM 0:276e7a263c35 54 }
MACRUM 0:276e7a263c35 55
MACRUM 0:276e7a263c35 56 void tearDown(void)
MACRUM 0:276e7a263c35 57 {
MACRUM 0:276e7a263c35 58 if (SetToOneToFailInTearDown == 1)
MACRUM 0:276e7a263c35 59 TEST_FAIL_MESSAGE("<= Failed in tearDown");
MACRUM 0:276e7a263c35 60 if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
MACRUM 0:276e7a263c35 61 {
MACRUM 0:276e7a263c35 62 UnityPrint("[[[[ Previous Test Should Have Passed But Did Not ]]]]");
MACRUM 0:276e7a263c35 63 UNITY_OUTPUT_CHAR('\n');
MACRUM 0:276e7a263c35 64 }
MACRUM 0:276e7a263c35 65 }
MACRUM 0:276e7a263c35 66
MACRUM 0:276e7a263c35 67 void testUnitySizeInitializationReminder(void)
MACRUM 0:276e7a263c35 68 {
MACRUM 0:276e7a263c35 69 /* This test ensures that sizeof(struct _Unity) doesn't change. If this
MACRUM 0:276e7a263c35 70 * test breaks, go look at the initialization of the Unity global variable
MACRUM 0:276e7a263c35 71 * in unity.c and make sure we're filling in the proper fields. */
MACRUM 0:276e7a263c35 72 const char* message = "Unexpected size for _Unity struct. Please check that "
MACRUM 0:276e7a263c35 73 "the initialization of the Unity symbol in unity.c is "
MACRUM 0:276e7a263c35 74 "still correct.";
MACRUM 0:276e7a263c35 75
MACRUM 0:276e7a263c35 76 /* Define a structure with all the same fields as `struct _Unity`. */
MACRUM 0:276e7a263c35 77 #ifdef UNITY_EXCLUDE_DETAILS
MACRUM 0:276e7a263c35 78 struct {
MACRUM 0:276e7a263c35 79 const char* TestFile;
MACRUM 0:276e7a263c35 80 const char* CurrentTestName;
MACRUM 0:276e7a263c35 81 UNITY_LINE_TYPE CurrentTestLineNumber;
MACRUM 0:276e7a263c35 82 UNITY_COUNTER_TYPE NumberOfTests;
MACRUM 0:276e7a263c35 83 UNITY_COUNTER_TYPE TestFailures;
MACRUM 0:276e7a263c35 84 UNITY_COUNTER_TYPE TestIgnores;
MACRUM 0:276e7a263c35 85 UNITY_COUNTER_TYPE CurrentTestFailed;
MACRUM 0:276e7a263c35 86 UNITY_COUNTER_TYPE CurrentTestIgnored;
MACRUM 0:276e7a263c35 87 jmp_buf AbortFrame;
MACRUM 0:276e7a263c35 88 } _Expected_Unity;
MACRUM 0:276e7a263c35 89 #else
MACRUM 0:276e7a263c35 90 struct {
MACRUM 0:276e7a263c35 91 const char* TestFile;
MACRUM 0:276e7a263c35 92 const char* CurrentTestName;
MACRUM 0:276e7a263c35 93 const char* CurrentDetails1;
MACRUM 0:276e7a263c35 94 const char* CurrentDetails2;
MACRUM 0:276e7a263c35 95 UNITY_LINE_TYPE CurrentTestLineNumber;
MACRUM 0:276e7a263c35 96 UNITY_COUNTER_TYPE NumberOfTests;
MACRUM 0:276e7a263c35 97 UNITY_COUNTER_TYPE TestFailures;
MACRUM 0:276e7a263c35 98 UNITY_COUNTER_TYPE TestIgnores;
MACRUM 0:276e7a263c35 99 UNITY_COUNTER_TYPE CurrentTestFailed;
MACRUM 0:276e7a263c35 100 UNITY_COUNTER_TYPE CurrentTestIgnored;
MACRUM 0:276e7a263c35 101 jmp_buf AbortFrame;
MACRUM 0:276e7a263c35 102 } _Expected_Unity;
MACRUM 0:276e7a263c35 103 #endif
MACRUM 0:276e7a263c35 104
MACRUM 0:276e7a263c35 105 /* Compare our fake structure's size to the actual structure's size. They
MACRUM 0:276e7a263c35 106 * should be the same.
MACRUM 0:276e7a263c35 107 *
MACRUM 0:276e7a263c35 108 * This accounts for alignment, padding, and packing issues that might come
MACRUM 0:276e7a263c35 109 * up between different architectures. */
MACRUM 0:276e7a263c35 110 TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message);
MACRUM 0:276e7a263c35 111 }
MACRUM 0:276e7a263c35 112
MACRUM 0:276e7a263c35 113 void testPassShouldEndImmediatelyWithPass(void)
MACRUM 0:276e7a263c35 114 {
MACRUM 0:276e7a263c35 115 TEST_PASS();
MACRUM 0:276e7a263c35 116 TEST_FAIL_MESSAGE("We should have passed already and finished this test");
MACRUM 0:276e7a263c35 117 }
MACRUM 0:276e7a263c35 118
MACRUM 0:276e7a263c35 119 void testTrue(void)
MACRUM 0:276e7a263c35 120 {
MACRUM 0:276e7a263c35 121 TEST_ASSERT(1);
MACRUM 0:276e7a263c35 122
MACRUM 0:276e7a263c35 123 TEST_ASSERT_TRUE(1);
MACRUM 0:276e7a263c35 124 }
MACRUM 0:276e7a263c35 125
MACRUM 0:276e7a263c35 126 void testFalse(void)
MACRUM 0:276e7a263c35 127 {
MACRUM 0:276e7a263c35 128 TEST_ASSERT_FALSE(0);
MACRUM 0:276e7a263c35 129
MACRUM 0:276e7a263c35 130 TEST_ASSERT_UNLESS(0);
MACRUM 0:276e7a263c35 131 }
MACRUM 0:276e7a263c35 132
MACRUM 0:276e7a263c35 133 void testPreviousPass(void)
MACRUM 0:276e7a263c35 134 {
MACRUM 0:276e7a263c35 135 TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
MACRUM 0:276e7a263c35 136 }
MACRUM 0:276e7a263c35 137
MACRUM 0:276e7a263c35 138 void testNotVanilla(void)
MACRUM 0:276e7a263c35 139 {
MACRUM 0:276e7a263c35 140 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 141 TEST_ASSERT(0);
MACRUM 0:276e7a263c35 142 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 143 }
MACRUM 0:276e7a263c35 144
MACRUM 0:276e7a263c35 145 void testNotTrue(void)
MACRUM 0:276e7a263c35 146 {
MACRUM 0:276e7a263c35 147 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 148 TEST_ASSERT_TRUE(0);
MACRUM 0:276e7a263c35 149 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 150 }
MACRUM 0:276e7a263c35 151
MACRUM 0:276e7a263c35 152 void testNotFalse(void)
MACRUM 0:276e7a263c35 153 {
MACRUM 0:276e7a263c35 154 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 155 TEST_ASSERT_FALSE(1);
MACRUM 0:276e7a263c35 156 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 157 }
MACRUM 0:276e7a263c35 158
MACRUM 0:276e7a263c35 159 void testNotUnless(void)
MACRUM 0:276e7a263c35 160 {
MACRUM 0:276e7a263c35 161 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 162 TEST_ASSERT_UNLESS(1);
MACRUM 0:276e7a263c35 163 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 164 }
MACRUM 0:276e7a263c35 165
MACRUM 0:276e7a263c35 166 void testNotNotEqual(void)
MACRUM 0:276e7a263c35 167 {
MACRUM 0:276e7a263c35 168 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 169 TEST_ASSERT_NOT_EQUAL(10, 10);
MACRUM 0:276e7a263c35 170 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 171 }
MACRUM 0:276e7a263c35 172
MACRUM 0:276e7a263c35 173 void testFail(void)
MACRUM 0:276e7a263c35 174 {
MACRUM 0:276e7a263c35 175 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 176 TEST_FAIL_MESSAGE("Expected for testing");
MACRUM 0:276e7a263c35 177 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 178 }
MACRUM 0:276e7a263c35 179
MACRUM 0:276e7a263c35 180 void testIsNull(void)
MACRUM 0:276e7a263c35 181 {
MACRUM 0:276e7a263c35 182 char* ptr1 = NULL;
MACRUM 0:276e7a263c35 183 const char* ptr2 = "hello";
MACRUM 0:276e7a263c35 184
MACRUM 0:276e7a263c35 185 TEST_ASSERT_NULL(ptr1);
MACRUM 0:276e7a263c35 186 TEST_ASSERT_NOT_NULL(ptr2);
MACRUM 0:276e7a263c35 187 }
MACRUM 0:276e7a263c35 188
MACRUM 0:276e7a263c35 189 void testIsNullShouldFailIfNot(void)
MACRUM 0:276e7a263c35 190 {
MACRUM 0:276e7a263c35 191 const char* ptr1 = "hello";
MACRUM 0:276e7a263c35 192
MACRUM 0:276e7a263c35 193 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 194 TEST_ASSERT_NULL(ptr1);
MACRUM 0:276e7a263c35 195 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 196 }
MACRUM 0:276e7a263c35 197
MACRUM 0:276e7a263c35 198 void testNotNullShouldFailIfNULL(void)
MACRUM 0:276e7a263c35 199 {
MACRUM 0:276e7a263c35 200 char* ptr1 = NULL;
MACRUM 0:276e7a263c35 201
MACRUM 0:276e7a263c35 202 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 203 TEST_ASSERT_NOT_NULL(ptr1);
MACRUM 0:276e7a263c35 204 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 205 }
MACRUM 0:276e7a263c35 206
MACRUM 0:276e7a263c35 207 void testIgnore(void)
MACRUM 0:276e7a263c35 208 {
MACRUM 0:276e7a263c35 209 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 210 TEST_IGNORE();
MACRUM 0:276e7a263c35 211 TEST_FAIL_MESSAGE("This should not be reached");
MACRUM 0:276e7a263c35 212 VERIFY_IGNORES_END
MACRUM 0:276e7a263c35 213 }
MACRUM 0:276e7a263c35 214
MACRUM 0:276e7a263c35 215 void testIgnoreMessage(void)
MACRUM 0:276e7a263c35 216 {
MACRUM 0:276e7a263c35 217 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 218 TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!");
MACRUM 0:276e7a263c35 219 TEST_FAIL_MESSAGE("This should not be reached");
MACRUM 0:276e7a263c35 220 VERIFY_IGNORES_END
MACRUM 0:276e7a263c35 221 }
MACRUM 0:276e7a263c35 222
MACRUM 0:276e7a263c35 223 void testNotEqualInts(void)
MACRUM 0:276e7a263c35 224 {
MACRUM 0:276e7a263c35 225 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 226 TEST_ASSERT_EQUAL_INT(3982, 3983);
MACRUM 0:276e7a263c35 227 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 228 }
MACRUM 0:276e7a263c35 229
MACRUM 0:276e7a263c35 230 void testNotEqualInt8s(void)
MACRUM 0:276e7a263c35 231 {
MACRUM 0:276e7a263c35 232 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 233 TEST_ASSERT_EQUAL_INT8(-127, -126);
MACRUM 0:276e7a263c35 234 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 235 }
MACRUM 0:276e7a263c35 236
MACRUM 0:276e7a263c35 237 void testNotEqualInt16s(void)
MACRUM 0:276e7a263c35 238 {
MACRUM 0:276e7a263c35 239 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 240 TEST_ASSERT_EQUAL_INT16(-16383, -16382);
MACRUM 0:276e7a263c35 241 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 242 }
MACRUM 0:276e7a263c35 243
MACRUM 0:276e7a263c35 244 void testNotEqualInt32s(void)
MACRUM 0:276e7a263c35 245 {
MACRUM 0:276e7a263c35 246 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 247 TEST_ASSERT_EQUAL_INT32(-2147483647, -2147483648); //use largest 32 bit negative to test printability
MACRUM 0:276e7a263c35 248 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 249 }
MACRUM 0:276e7a263c35 250
MACRUM 0:276e7a263c35 251 void testNotEqualBits(void)
MACRUM 0:276e7a263c35 252 {
MACRUM 0:276e7a263c35 253 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 254 TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55);
MACRUM 0:276e7a263c35 255 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 256 }
MACRUM 0:276e7a263c35 257
MACRUM 0:276e7a263c35 258 void testNotEqualUInts(void)
MACRUM 0:276e7a263c35 259 {
MACRUM 0:276e7a263c35 260 _UU16 v0, v1;
MACRUM 0:276e7a263c35 261
MACRUM 0:276e7a263c35 262 v0 = 9000;
MACRUM 0:276e7a263c35 263 v1 = 9001;
MACRUM 0:276e7a263c35 264
MACRUM 0:276e7a263c35 265 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 266 TEST_ASSERT_EQUAL_UINT(v0, v1);
MACRUM 0:276e7a263c35 267 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 268 }
MACRUM 0:276e7a263c35 269
MACRUM 0:276e7a263c35 270 void testNotEqualUInt8s(void)
MACRUM 0:276e7a263c35 271 {
MACRUM 0:276e7a263c35 272 _UU8 v0, v1;
MACRUM 0:276e7a263c35 273
MACRUM 0:276e7a263c35 274 v0 = 254;
MACRUM 0:276e7a263c35 275 v1 = 255;
MACRUM 0:276e7a263c35 276
MACRUM 0:276e7a263c35 277 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 278 TEST_ASSERT_EQUAL_UINT8(v0, v1);
MACRUM 0:276e7a263c35 279 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 280 }
MACRUM 0:276e7a263c35 281
MACRUM 0:276e7a263c35 282 void testNotEqualUInt16s(void)
MACRUM 0:276e7a263c35 283 {
MACRUM 0:276e7a263c35 284 _UU16 v0, v1;
MACRUM 0:276e7a263c35 285
MACRUM 0:276e7a263c35 286 v0 = 65535;
MACRUM 0:276e7a263c35 287 v1 = 65534;
MACRUM 0:276e7a263c35 288
MACRUM 0:276e7a263c35 289 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 290 TEST_ASSERT_EQUAL_UINT16(v0, v1);
MACRUM 0:276e7a263c35 291 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 292 }
MACRUM 0:276e7a263c35 293
MACRUM 0:276e7a263c35 294 void testNotEqualUInt32s(void)
MACRUM 0:276e7a263c35 295 {
MACRUM 0:276e7a263c35 296 _UU32 v0, v1;
MACRUM 0:276e7a263c35 297
MACRUM 0:276e7a263c35 298 v0 = 4294967295;
MACRUM 0:276e7a263c35 299 v1 = 4294967294;
MACRUM 0:276e7a263c35 300
MACRUM 0:276e7a263c35 301 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 302 TEST_ASSERT_EQUAL_UINT32(v0, v1);
MACRUM 0:276e7a263c35 303 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 304 }
MACRUM 0:276e7a263c35 305
MACRUM 0:276e7a263c35 306 void testNotEqualHex8s(void)
MACRUM 0:276e7a263c35 307 {
MACRUM 0:276e7a263c35 308 _UU8 v0, v1;
MACRUM 0:276e7a263c35 309
MACRUM 0:276e7a263c35 310 v0 = 0x23;
MACRUM 0:276e7a263c35 311 v1 = 0x22;
MACRUM 0:276e7a263c35 312
MACRUM 0:276e7a263c35 313 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 314 TEST_ASSERT_EQUAL_HEX8(v0, v1);
MACRUM 0:276e7a263c35 315 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 316 }
MACRUM 0:276e7a263c35 317
MACRUM 0:276e7a263c35 318 void testNotEqualHex8sIfSigned(void)
MACRUM 0:276e7a263c35 319 {
MACRUM 0:276e7a263c35 320 _US8 v0, v1;
MACRUM 0:276e7a263c35 321
MACRUM 0:276e7a263c35 322 v0 = -2;
MACRUM 0:276e7a263c35 323 v1 = 2;
MACRUM 0:276e7a263c35 324
MACRUM 0:276e7a263c35 325 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 326 TEST_ASSERT_EQUAL_HEX8(v0, v1);
MACRUM 0:276e7a263c35 327 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 328 }
MACRUM 0:276e7a263c35 329
MACRUM 0:276e7a263c35 330 void testNotEqualHex16s(void)
MACRUM 0:276e7a263c35 331 {
MACRUM 0:276e7a263c35 332 _UU16 v0, v1;
MACRUM 0:276e7a263c35 333
MACRUM 0:276e7a263c35 334 v0 = 0x1234;
MACRUM 0:276e7a263c35 335 v1 = 0x1235;
MACRUM 0:276e7a263c35 336
MACRUM 0:276e7a263c35 337 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 338 TEST_ASSERT_EQUAL_HEX16(v0, v1);
MACRUM 0:276e7a263c35 339 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 340 }
MACRUM 0:276e7a263c35 341
MACRUM 0:276e7a263c35 342 void testNotEqualHex16sIfSigned(void)
MACRUM 0:276e7a263c35 343 {
MACRUM 0:276e7a263c35 344 _US16 v0, v1;
MACRUM 0:276e7a263c35 345
MACRUM 0:276e7a263c35 346 v0 = -1024;
MACRUM 0:276e7a263c35 347 v1 = -1028;
MACRUM 0:276e7a263c35 348
MACRUM 0:276e7a263c35 349 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 350 TEST_ASSERT_EQUAL_HEX16(v0, v1);
MACRUM 0:276e7a263c35 351 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 352 }
MACRUM 0:276e7a263c35 353
MACRUM 0:276e7a263c35 354 void testNotEqualHex32s(void)
MACRUM 0:276e7a263c35 355 {
MACRUM 0:276e7a263c35 356 _UU32 v0, v1;
MACRUM 0:276e7a263c35 357
MACRUM 0:276e7a263c35 358 v0 = 900000;
MACRUM 0:276e7a263c35 359 v1 = 900001;
MACRUM 0:276e7a263c35 360
MACRUM 0:276e7a263c35 361 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 362 TEST_ASSERT_EQUAL_HEX32(v0, v1);
MACRUM 0:276e7a263c35 363 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 364 }
MACRUM 0:276e7a263c35 365
MACRUM 0:276e7a263c35 366 void testNotEqualHex32sIfSigned(void)
MACRUM 0:276e7a263c35 367 {
MACRUM 0:276e7a263c35 368 _US32 v0, v1;
MACRUM 0:276e7a263c35 369
MACRUM 0:276e7a263c35 370 v0 = -900000;
MACRUM 0:276e7a263c35 371 v1 = 900001;
MACRUM 0:276e7a263c35 372
MACRUM 0:276e7a263c35 373 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 374 TEST_ASSERT_EQUAL_HEX32(v0, v1);
MACRUM 0:276e7a263c35 375 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 376 }
MACRUM 0:276e7a263c35 377
MACRUM 0:276e7a263c35 378 void testEqualInts(void)
MACRUM 0:276e7a263c35 379 {
MACRUM 0:276e7a263c35 380 int v0, v1;
MACRUM 0:276e7a263c35 381 int *p0, *p1;
MACRUM 0:276e7a263c35 382
MACRUM 0:276e7a263c35 383 v0 = 19467;
MACRUM 0:276e7a263c35 384 v1 = 19467;
MACRUM 0:276e7a263c35 385 p0 = &v0;
MACRUM 0:276e7a263c35 386 p1 = &v1;
MACRUM 0:276e7a263c35 387
MACRUM 0:276e7a263c35 388 TEST_ASSERT_EQUAL_INT(1837, 1837);
MACRUM 0:276e7a263c35 389 TEST_ASSERT_EQUAL_INT(-27365, -27365);
MACRUM 0:276e7a263c35 390 TEST_ASSERT_EQUAL_INT(v0, v1);
MACRUM 0:276e7a263c35 391 TEST_ASSERT_EQUAL_INT(19467, v1);
MACRUM 0:276e7a263c35 392 TEST_ASSERT_EQUAL_INT(v0, 19467);
MACRUM 0:276e7a263c35 393 TEST_ASSERT_EQUAL_INT(*p0, v1);
MACRUM 0:276e7a263c35 394 TEST_ASSERT_EQUAL_INT(*p0, *p1);
MACRUM 0:276e7a263c35 395 TEST_ASSERT_EQUAL_INT(*p0, 19467);
MACRUM 0:276e7a263c35 396 }
MACRUM 0:276e7a263c35 397
MACRUM 0:276e7a263c35 398 void testEqualInt8s(void)
MACRUM 0:276e7a263c35 399 {
MACRUM 0:276e7a263c35 400 _US8 v0, v1;
MACRUM 0:276e7a263c35 401 _US8 *p0, *p1;
MACRUM 0:276e7a263c35 402
MACRUM 0:276e7a263c35 403 v0 = 0x22;
MACRUM 0:276e7a263c35 404 v1 = 0x22;
MACRUM 0:276e7a263c35 405 p0 = &v0;
MACRUM 0:276e7a263c35 406 p1 = &v1;
MACRUM 0:276e7a263c35 407
MACRUM 0:276e7a263c35 408 TEST_ASSERT_EQUAL_INT8(0x22, 0x22);
MACRUM 0:276e7a263c35 409 TEST_ASSERT_EQUAL_INT8(v0, v1);
MACRUM 0:276e7a263c35 410 TEST_ASSERT_EQUAL_INT8(0x22, v1);
MACRUM 0:276e7a263c35 411 TEST_ASSERT_EQUAL_INT8(v0, 0x22);
MACRUM 0:276e7a263c35 412 TEST_ASSERT_EQUAL_INT8(*p0, v1);
MACRUM 0:276e7a263c35 413 TEST_ASSERT_EQUAL_INT8(*p0, *p1);
MACRUM 0:276e7a263c35 414 TEST_ASSERT_EQUAL_INT8(*p0, 0x22);
MACRUM 0:276e7a263c35 415 }
MACRUM 0:276e7a263c35 416
MACRUM 0:276e7a263c35 417 void testEqualInt8sWhenThereAreDifferencesOutside8Bits(void)
MACRUM 0:276e7a263c35 418 {
MACRUM 0:276e7a263c35 419 TEST_ASSERT_EQUAL_INT8(0x321,0x421);
MACRUM 0:276e7a263c35 420 TEST_ASSERT_EQUAL_INT8(0xFF21,0x0021);
MACRUM 0:276e7a263c35 421 }
MACRUM 0:276e7a263c35 422
MACRUM 0:276e7a263c35 423 void testEqualInt16s(void)
MACRUM 0:276e7a263c35 424 {
MACRUM 0:276e7a263c35 425 _US16 v0, v1;
MACRUM 0:276e7a263c35 426 _US16 *p0, *p1;
MACRUM 0:276e7a263c35 427
MACRUM 0:276e7a263c35 428 v0 = 0x7876;
MACRUM 0:276e7a263c35 429 v1 = 0x7876;
MACRUM 0:276e7a263c35 430 p0 = &v0;
MACRUM 0:276e7a263c35 431 p1 = &v1;
MACRUM 0:276e7a263c35 432
MACRUM 0:276e7a263c35 433 TEST_ASSERT_EQUAL_INT16(0x7876, 0x7876);
MACRUM 0:276e7a263c35 434 TEST_ASSERT_EQUAL_INT16(v0, v1);
MACRUM 0:276e7a263c35 435 TEST_ASSERT_EQUAL_INT16(0x7876, v1);
MACRUM 0:276e7a263c35 436 TEST_ASSERT_EQUAL_INT16(v0, 0x7876);
MACRUM 0:276e7a263c35 437 TEST_ASSERT_EQUAL_INT16(*p0, v1);
MACRUM 0:276e7a263c35 438 TEST_ASSERT_EQUAL_INT16(*p0, *p1);
MACRUM 0:276e7a263c35 439 TEST_ASSERT_EQUAL_INT16(*p0, 0x7876);
MACRUM 0:276e7a263c35 440 }
MACRUM 0:276e7a263c35 441
MACRUM 0:276e7a263c35 442 void testEqualInt16sNegatives(void)
MACRUM 0:276e7a263c35 443 {
MACRUM 0:276e7a263c35 444 _US16 v0, v1;
MACRUM 0:276e7a263c35 445 _US16 *p0, *p1;
MACRUM 0:276e7a263c35 446
MACRUM 0:276e7a263c35 447 v0 = -7876;
MACRUM 0:276e7a263c35 448 v1 = -7876;
MACRUM 0:276e7a263c35 449 p0 = &v0;
MACRUM 0:276e7a263c35 450 p1 = &v1;
MACRUM 0:276e7a263c35 451
MACRUM 0:276e7a263c35 452 TEST_ASSERT_EQUAL_INT16(-7876, -7876);
MACRUM 0:276e7a263c35 453 TEST_ASSERT_EQUAL_INT16(v0, v1);
MACRUM 0:276e7a263c35 454 TEST_ASSERT_EQUAL_INT16(-7876, v1);
MACRUM 0:276e7a263c35 455 TEST_ASSERT_EQUAL_INT16(v0, -7876);
MACRUM 0:276e7a263c35 456 TEST_ASSERT_EQUAL_INT16(*p0, v1);
MACRUM 0:276e7a263c35 457 TEST_ASSERT_EQUAL_INT16(*p0, *p1);
MACRUM 0:276e7a263c35 458 TEST_ASSERT_EQUAL_INT16(*p0, -7876);
MACRUM 0:276e7a263c35 459 }
MACRUM 0:276e7a263c35 460
MACRUM 0:276e7a263c35 461 void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void)
MACRUM 0:276e7a263c35 462 {
MACRUM 0:276e7a263c35 463 TEST_ASSERT_EQUAL_INT16(0x54321,0x64321);
MACRUM 0:276e7a263c35 464 TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321);
MACRUM 0:276e7a263c35 465 }
MACRUM 0:276e7a263c35 466
MACRUM 0:276e7a263c35 467 void testEqualInt32s(void)
MACRUM 0:276e7a263c35 468 {
MACRUM 0:276e7a263c35 469 _US32 v0, v1;
MACRUM 0:276e7a263c35 470 _US32 *p0, *p1;
MACRUM 0:276e7a263c35 471
MACRUM 0:276e7a263c35 472 v0 = 0x78760000;
MACRUM 0:276e7a263c35 473 v1 = 0x78760000;
MACRUM 0:276e7a263c35 474 p0 = &v0;
MACRUM 0:276e7a263c35 475 p1 = &v1;
MACRUM 0:276e7a263c35 476
MACRUM 0:276e7a263c35 477 TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000);
MACRUM 0:276e7a263c35 478 TEST_ASSERT_EQUAL_INT32(v0, v1);
MACRUM 0:276e7a263c35 479 TEST_ASSERT_EQUAL_INT32(0x78760000, v1);
MACRUM 0:276e7a263c35 480 TEST_ASSERT_EQUAL_INT32(v0, 0x78760000);
MACRUM 0:276e7a263c35 481 TEST_ASSERT_EQUAL_INT32(*p0, v1);
MACRUM 0:276e7a263c35 482 TEST_ASSERT_EQUAL_INT32(*p0, *p1);
MACRUM 0:276e7a263c35 483 TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000);
MACRUM 0:276e7a263c35 484 }
MACRUM 0:276e7a263c35 485
MACRUM 0:276e7a263c35 486 void testEqualInt32sNegatives(void)
MACRUM 0:276e7a263c35 487 {
MACRUM 0:276e7a263c35 488 _US32 v0, v1;
MACRUM 0:276e7a263c35 489 _US32 *p0, *p1;
MACRUM 0:276e7a263c35 490
MACRUM 0:276e7a263c35 491 v0 = -123456789;
MACRUM 0:276e7a263c35 492 v1 = -123456789;
MACRUM 0:276e7a263c35 493 p0 = &v0;
MACRUM 0:276e7a263c35 494 p1 = &v1;
MACRUM 0:276e7a263c35 495
MACRUM 0:276e7a263c35 496 TEST_ASSERT_EQUAL_INT32(-123456789, -123456789);
MACRUM 0:276e7a263c35 497 TEST_ASSERT_EQUAL_INT32(v0, v1);
MACRUM 0:276e7a263c35 498 TEST_ASSERT_EQUAL_INT32(-123456789, v1);
MACRUM 0:276e7a263c35 499 TEST_ASSERT_EQUAL_INT32(v0, -123456789);
MACRUM 0:276e7a263c35 500 TEST_ASSERT_EQUAL_INT32(*p0, v1);
MACRUM 0:276e7a263c35 501 TEST_ASSERT_EQUAL_INT32(*p0, *p1);
MACRUM 0:276e7a263c35 502 TEST_ASSERT_EQUAL_INT32(*p0, -123456789);
MACRUM 0:276e7a263c35 503 }
MACRUM 0:276e7a263c35 504
MACRUM 0:276e7a263c35 505
MACRUM 0:276e7a263c35 506 void testEqualUints(void)
MACRUM 0:276e7a263c35 507 {
MACRUM 0:276e7a263c35 508 unsigned int v0, v1;
MACRUM 0:276e7a263c35 509 unsigned int *p0, *p1;
MACRUM 0:276e7a263c35 510
MACRUM 0:276e7a263c35 511 v0 = 19467;
MACRUM 0:276e7a263c35 512 v1 = 19467;
MACRUM 0:276e7a263c35 513 p0 = &v0;
MACRUM 0:276e7a263c35 514 p1 = &v1;
MACRUM 0:276e7a263c35 515
MACRUM 0:276e7a263c35 516 TEST_ASSERT_EQUAL_UINT(1837, 1837);
MACRUM 0:276e7a263c35 517 TEST_ASSERT_EQUAL_UINT(v0, v1);
MACRUM 0:276e7a263c35 518 TEST_ASSERT_EQUAL_UINT(19467, v1);
MACRUM 0:276e7a263c35 519 TEST_ASSERT_EQUAL_UINT(v0, 19467);
MACRUM 0:276e7a263c35 520 TEST_ASSERT_EQUAL_UINT(*p0, v1);
MACRUM 0:276e7a263c35 521 TEST_ASSERT_EQUAL_UINT(*p0, *p1);
MACRUM 0:276e7a263c35 522 TEST_ASSERT_EQUAL_UINT(*p0, 19467);
MACRUM 0:276e7a263c35 523 TEST_ASSERT_EQUAL_UINT(60872u, 60872u);
MACRUM 0:276e7a263c35 524 }
MACRUM 0:276e7a263c35 525
MACRUM 0:276e7a263c35 526
MACRUM 0:276e7a263c35 527 void testEqualUint8s(void)
MACRUM 0:276e7a263c35 528 {
MACRUM 0:276e7a263c35 529 _UU8 v0, v1;
MACRUM 0:276e7a263c35 530 _UU8 *p0, *p1;
MACRUM 0:276e7a263c35 531
MACRUM 0:276e7a263c35 532 v0 = 0x22;
MACRUM 0:276e7a263c35 533 v1 = 0x22;
MACRUM 0:276e7a263c35 534 p0 = &v0;
MACRUM 0:276e7a263c35 535 p1 = &v1;
MACRUM 0:276e7a263c35 536
MACRUM 0:276e7a263c35 537 TEST_ASSERT_EQUAL_UINT8(0x22, 0x22);
MACRUM 0:276e7a263c35 538 TEST_ASSERT_EQUAL_UINT8(v0, v1);
MACRUM 0:276e7a263c35 539 TEST_ASSERT_EQUAL_UINT8(0x22, v1);
MACRUM 0:276e7a263c35 540 TEST_ASSERT_EQUAL_UINT8(v0, 0x22);
MACRUM 0:276e7a263c35 541 TEST_ASSERT_EQUAL_UINT8(*p0, v1);
MACRUM 0:276e7a263c35 542 TEST_ASSERT_EQUAL_UINT8(*p0, *p1);
MACRUM 0:276e7a263c35 543 TEST_ASSERT_EQUAL_UINT8(*p0, 0x22);
MACRUM 0:276e7a263c35 544 }
MACRUM 0:276e7a263c35 545
MACRUM 0:276e7a263c35 546 void testEqualUint8sWhenThereAreDifferencesOutside8Bits(void)
MACRUM 0:276e7a263c35 547 {
MACRUM 0:276e7a263c35 548 TEST_ASSERT_EQUAL_UINT8(0x321,0x421);
MACRUM 0:276e7a263c35 549 TEST_ASSERT_EQUAL_UINT8(0xFF21,0x0021);
MACRUM 0:276e7a263c35 550 }
MACRUM 0:276e7a263c35 551
MACRUM 0:276e7a263c35 552 void testEqualUint16s(void)
MACRUM 0:276e7a263c35 553 {
MACRUM 0:276e7a263c35 554 _UU16 v0, v1;
MACRUM 0:276e7a263c35 555 _UU16 *p0, *p1;
MACRUM 0:276e7a263c35 556
MACRUM 0:276e7a263c35 557 v0 = 0x9876;
MACRUM 0:276e7a263c35 558 v1 = 0x9876;
MACRUM 0:276e7a263c35 559 p0 = &v0;
MACRUM 0:276e7a263c35 560 p1 = &v1;
MACRUM 0:276e7a263c35 561
MACRUM 0:276e7a263c35 562 TEST_ASSERT_EQUAL_UINT16(0x9876, 0x9876);
MACRUM 0:276e7a263c35 563 TEST_ASSERT_EQUAL_UINT16(v0, v1);
MACRUM 0:276e7a263c35 564 TEST_ASSERT_EQUAL_UINT16(0x9876, v1);
MACRUM 0:276e7a263c35 565 TEST_ASSERT_EQUAL_UINT16(v0, 0x9876);
MACRUM 0:276e7a263c35 566 TEST_ASSERT_EQUAL_UINT16(*p0, v1);
MACRUM 0:276e7a263c35 567 TEST_ASSERT_EQUAL_UINT16(*p0, *p1);
MACRUM 0:276e7a263c35 568 TEST_ASSERT_EQUAL_UINT16(*p0, 0x9876);
MACRUM 0:276e7a263c35 569 }
MACRUM 0:276e7a263c35 570
MACRUM 0:276e7a263c35 571 void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void)
MACRUM 0:276e7a263c35 572 {
MACRUM 0:276e7a263c35 573 TEST_ASSERT_EQUAL_UINT16(0x54321,0x64321);
MACRUM 0:276e7a263c35 574 TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321);
MACRUM 0:276e7a263c35 575 }
MACRUM 0:276e7a263c35 576
MACRUM 0:276e7a263c35 577 void testEqualUint32s(void)
MACRUM 0:276e7a263c35 578 {
MACRUM 0:276e7a263c35 579 _UU32 v0, v1;
MACRUM 0:276e7a263c35 580 _UU32 *p0, *p1;
MACRUM 0:276e7a263c35 581
MACRUM 0:276e7a263c35 582 v0 = 0x98760000;
MACRUM 0:276e7a263c35 583 v1 = 0x98760000;
MACRUM 0:276e7a263c35 584 p0 = &v0;
MACRUM 0:276e7a263c35 585 p1 = &v1;
MACRUM 0:276e7a263c35 586
MACRUM 0:276e7a263c35 587 TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000);
MACRUM 0:276e7a263c35 588 TEST_ASSERT_EQUAL_UINT32(v0, v1);
MACRUM 0:276e7a263c35 589 TEST_ASSERT_EQUAL_UINT32(0x98760000, v1);
MACRUM 0:276e7a263c35 590 TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000);
MACRUM 0:276e7a263c35 591 TEST_ASSERT_EQUAL_UINT32(*p0, v1);
MACRUM 0:276e7a263c35 592 TEST_ASSERT_EQUAL_UINT32(*p0, *p1);
MACRUM 0:276e7a263c35 593 TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000);
MACRUM 0:276e7a263c35 594 }
MACRUM 0:276e7a263c35 595
MACRUM 0:276e7a263c35 596 void testNotEqual(void)
MACRUM 0:276e7a263c35 597 {
MACRUM 0:276e7a263c35 598 TEST_ASSERT_NOT_EQUAL(0, 1);
MACRUM 0:276e7a263c35 599 TEST_ASSERT_NOT_EQUAL(1, 0);
MACRUM 0:276e7a263c35 600 TEST_ASSERT_NOT_EQUAL(100, 101);
MACRUM 0:276e7a263c35 601 TEST_ASSERT_NOT_EQUAL(0, -1);
MACRUM 0:276e7a263c35 602 TEST_ASSERT_NOT_EQUAL(65535, -65535);
MACRUM 0:276e7a263c35 603 TEST_ASSERT_NOT_EQUAL(75, 900);
MACRUM 0:276e7a263c35 604 TEST_ASSERT_NOT_EQUAL(-100, -101);
MACRUM 0:276e7a263c35 605 }
MACRUM 0:276e7a263c35 606
MACRUM 0:276e7a263c35 607 void testEqualHex8s(void)
MACRUM 0:276e7a263c35 608 {
MACRUM 0:276e7a263c35 609 _UU8 v0, v1;
MACRUM 0:276e7a263c35 610 _UU8 *p0, *p1;
MACRUM 0:276e7a263c35 611
MACRUM 0:276e7a263c35 612 v0 = 0x22;
MACRUM 0:276e7a263c35 613 v1 = 0x22;
MACRUM 0:276e7a263c35 614 p0 = &v0;
MACRUM 0:276e7a263c35 615 p1 = &v1;
MACRUM 0:276e7a263c35 616
MACRUM 0:276e7a263c35 617 TEST_ASSERT_EQUAL_HEX8(0x22, 0x22);
MACRUM 0:276e7a263c35 618 TEST_ASSERT_EQUAL_HEX8(v0, v1);
MACRUM 0:276e7a263c35 619 TEST_ASSERT_EQUAL_HEX8(0x22, v1);
MACRUM 0:276e7a263c35 620 TEST_ASSERT_EQUAL_HEX8(v0, 0x22);
MACRUM 0:276e7a263c35 621 TEST_ASSERT_EQUAL_HEX8(*p0, v1);
MACRUM 0:276e7a263c35 622 TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
MACRUM 0:276e7a263c35 623 TEST_ASSERT_EQUAL_HEX8(*p0, 0x22);
MACRUM 0:276e7a263c35 624 }
MACRUM 0:276e7a263c35 625
MACRUM 0:276e7a263c35 626 void testEqualHex8sWhenThereAreDifferencesOutside8Bits(void)
MACRUM 0:276e7a263c35 627 {
MACRUM 0:276e7a263c35 628 TEST_ASSERT_EQUAL_HEX8(0x321,0x421);
MACRUM 0:276e7a263c35 629 TEST_ASSERT_EQUAL_HEX8(0xFF21,0x0021);
MACRUM 0:276e7a263c35 630 }
MACRUM 0:276e7a263c35 631
MACRUM 0:276e7a263c35 632 void testEqualHex8sNegatives(void)
MACRUM 0:276e7a263c35 633 {
MACRUM 0:276e7a263c35 634 _UU8 v0, v1;
MACRUM 0:276e7a263c35 635 _UU8 *p0, *p1;
MACRUM 0:276e7a263c35 636
MACRUM 0:276e7a263c35 637 v0 = 0xDD;
MACRUM 0:276e7a263c35 638 v1 = 0xDD;
MACRUM 0:276e7a263c35 639 p0 = &v0;
MACRUM 0:276e7a263c35 640 p1 = &v1;
MACRUM 0:276e7a263c35 641
MACRUM 0:276e7a263c35 642 TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD);
MACRUM 0:276e7a263c35 643 TEST_ASSERT_EQUAL_HEX8(v0, v1);
MACRUM 0:276e7a263c35 644 TEST_ASSERT_EQUAL_HEX8(0xDD, v1);
MACRUM 0:276e7a263c35 645 TEST_ASSERT_EQUAL_HEX8(v0, 0xDD);
MACRUM 0:276e7a263c35 646 TEST_ASSERT_EQUAL_HEX8(*p0, v1);
MACRUM 0:276e7a263c35 647 TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
MACRUM 0:276e7a263c35 648 TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD);
MACRUM 0:276e7a263c35 649 }
MACRUM 0:276e7a263c35 650
MACRUM 0:276e7a263c35 651 void testEqualHex16s(void)
MACRUM 0:276e7a263c35 652 {
MACRUM 0:276e7a263c35 653 _UU16 v0, v1;
MACRUM 0:276e7a263c35 654 _UU16 *p0, *p1;
MACRUM 0:276e7a263c35 655
MACRUM 0:276e7a263c35 656 v0 = 0x9876;
MACRUM 0:276e7a263c35 657 v1 = 0x9876;
MACRUM 0:276e7a263c35 658 p0 = &v0;
MACRUM 0:276e7a263c35 659 p1 = &v1;
MACRUM 0:276e7a263c35 660
MACRUM 0:276e7a263c35 661 TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876);
MACRUM 0:276e7a263c35 662 TEST_ASSERT_EQUAL_HEX16(v0, v1);
MACRUM 0:276e7a263c35 663 TEST_ASSERT_EQUAL_HEX16(0x9876, v1);
MACRUM 0:276e7a263c35 664 TEST_ASSERT_EQUAL_HEX16(v0, 0x9876);
MACRUM 0:276e7a263c35 665 TEST_ASSERT_EQUAL_HEX16(*p0, v1);
MACRUM 0:276e7a263c35 666 TEST_ASSERT_EQUAL_HEX16(*p0, *p1);
MACRUM 0:276e7a263c35 667 TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876);
MACRUM 0:276e7a263c35 668 }
MACRUM 0:276e7a263c35 669
MACRUM 0:276e7a263c35 670 void testEqualHex16sWhenThereAreDifferencesOutside16Bits(void)
MACRUM 0:276e7a263c35 671 {
MACRUM 0:276e7a263c35 672 TEST_ASSERT_EQUAL_HEX16(0x54321,0x64321);
MACRUM 0:276e7a263c35 673 TEST_ASSERT_EQUAL_HEX16(0xFFFF4321,0x00004321);
MACRUM 0:276e7a263c35 674 }
MACRUM 0:276e7a263c35 675
MACRUM 0:276e7a263c35 676 void testEqualHex32s(void)
MACRUM 0:276e7a263c35 677 {
MACRUM 0:276e7a263c35 678 _UU32 v0, v1;
MACRUM 0:276e7a263c35 679 _UU32 *p0, *p1;
MACRUM 0:276e7a263c35 680
MACRUM 0:276e7a263c35 681 v0 = 0x98765432ul;
MACRUM 0:276e7a263c35 682 v1 = 0x98765432ul;
MACRUM 0:276e7a263c35 683 p0 = &v0;
MACRUM 0:276e7a263c35 684 p1 = &v1;
MACRUM 0:276e7a263c35 685
MACRUM 0:276e7a263c35 686 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul);
MACRUM 0:276e7a263c35 687 TEST_ASSERT_EQUAL_HEX32(v0, v1);
MACRUM 0:276e7a263c35 688 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1);
MACRUM 0:276e7a263c35 689 TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul);
MACRUM 0:276e7a263c35 690 TEST_ASSERT_EQUAL_HEX32(*p0, v1);
MACRUM 0:276e7a263c35 691 TEST_ASSERT_EQUAL_HEX32(*p0, *p1);
MACRUM 0:276e7a263c35 692 TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul);
MACRUM 0:276e7a263c35 693 }
MACRUM 0:276e7a263c35 694
MACRUM 0:276e7a263c35 695 void testEqualBits(void)
MACRUM 0:276e7a263c35 696 {
MACRUM 0:276e7a263c35 697 _UU32 v0 = 0xFF55AA00;
MACRUM 0:276e7a263c35 698 _UU32 v1 = 0x55550000;
MACRUM 0:276e7a263c35 699
MACRUM 0:276e7a263c35 700 TEST_ASSERT_BITS(v1, v0, 0x55550000);
MACRUM 0:276e7a263c35 701 TEST_ASSERT_BITS(v1, v0, 0xFF55CC00);
MACRUM 0:276e7a263c35 702 TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00);
MACRUM 0:276e7a263c35 703 TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0);
MACRUM 0:276e7a263c35 704 TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F);
MACRUM 0:276e7a263c35 705 TEST_ASSERT_BITS_HIGH(v1, v0);
MACRUM 0:276e7a263c35 706 TEST_ASSERT_BITS_LOW(0x000055FF, v0);
MACRUM 0:276e7a263c35 707 TEST_ASSERT_BIT_HIGH(30, v0);
MACRUM 0:276e7a263c35 708 TEST_ASSERT_BIT_LOW(5, v0);
MACRUM 0:276e7a263c35 709 }
MACRUM 0:276e7a263c35 710
MACRUM 0:276e7a263c35 711 void testNotEqualBitHigh(void)
MACRUM 0:276e7a263c35 712 {
MACRUM 0:276e7a263c35 713 _UU32 v0 = 0x7F55AA00;
MACRUM 0:276e7a263c35 714
MACRUM 0:276e7a263c35 715 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 716 TEST_ASSERT_BIT_HIGH(31, v0);
MACRUM 0:276e7a263c35 717 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 718 }
MACRUM 0:276e7a263c35 719
MACRUM 0:276e7a263c35 720 void testNotEqualBitLow(void)
MACRUM 0:276e7a263c35 721 {
MACRUM 0:276e7a263c35 722 _UU32 v0 = 0xFF55AA00;
MACRUM 0:276e7a263c35 723
MACRUM 0:276e7a263c35 724 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 725 TEST_ASSERT_BIT_LOW(30, v0);
MACRUM 0:276e7a263c35 726 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 727 }
MACRUM 0:276e7a263c35 728
MACRUM 0:276e7a263c35 729 void testNotEqualBitsHigh(void)
MACRUM 0:276e7a263c35 730 {
MACRUM 0:276e7a263c35 731 _UU32 v0 = 0xFF55AA00;
MACRUM 0:276e7a263c35 732 _UU32 v1 = 0x55550000;
MACRUM 0:276e7a263c35 733
MACRUM 0:276e7a263c35 734 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 735 TEST_ASSERT_BITS_HIGH(v0, v1);
MACRUM 0:276e7a263c35 736 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 737
MACRUM 0:276e7a263c35 738 }
MACRUM 0:276e7a263c35 739
MACRUM 0:276e7a263c35 740 void testNotEqualBitsLow(void)
MACRUM 0:276e7a263c35 741 {
MACRUM 0:276e7a263c35 742 _UU32 v0 = 0xFF55AA00;
MACRUM 0:276e7a263c35 743 _UU32 v1 = 0x55550000;
MACRUM 0:276e7a263c35 744
MACRUM 0:276e7a263c35 745 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 746 TEST_ASSERT_BITS_LOW(v0, v1);
MACRUM 0:276e7a263c35 747 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 748
MACRUM 0:276e7a263c35 749 }
MACRUM 0:276e7a263c35 750 void testEqualShorts(void)
MACRUM 0:276e7a263c35 751 {
MACRUM 0:276e7a263c35 752 short v0, v1;
MACRUM 0:276e7a263c35 753 short *p0, *p1;
MACRUM 0:276e7a263c35 754
MACRUM 0:276e7a263c35 755 v0 = 19467;
MACRUM 0:276e7a263c35 756 v1 = 19467;
MACRUM 0:276e7a263c35 757 p0 = &v0;
MACRUM 0:276e7a263c35 758 p1 = &v1;
MACRUM 0:276e7a263c35 759
MACRUM 0:276e7a263c35 760 TEST_ASSERT_EQUAL_INT(1837, 1837);
MACRUM 0:276e7a263c35 761 TEST_ASSERT_EQUAL_INT(-2987, -2987);
MACRUM 0:276e7a263c35 762 TEST_ASSERT_EQUAL_INT(v0, v1);
MACRUM 0:276e7a263c35 763 TEST_ASSERT_EQUAL_INT(19467, v1);
MACRUM 0:276e7a263c35 764 TEST_ASSERT_EQUAL_INT(v0, 19467);
MACRUM 0:276e7a263c35 765 TEST_ASSERT_EQUAL_INT(*p0, v1);
MACRUM 0:276e7a263c35 766 TEST_ASSERT_EQUAL_INT(*p0, *p1);
MACRUM 0:276e7a263c35 767 TEST_ASSERT_EQUAL_INT(*p0, 19467);
MACRUM 0:276e7a263c35 768 }
MACRUM 0:276e7a263c35 769
MACRUM 0:276e7a263c35 770 void testEqualUShorts(void)
MACRUM 0:276e7a263c35 771 {
MACRUM 0:276e7a263c35 772 unsigned short v0, v1;
MACRUM 0:276e7a263c35 773 unsigned short *p0, *p1;
MACRUM 0:276e7a263c35 774
MACRUM 0:276e7a263c35 775 v0 = 19467;
MACRUM 0:276e7a263c35 776 v1 = 19467;
MACRUM 0:276e7a263c35 777 p0 = &v0;
MACRUM 0:276e7a263c35 778 p1 = &v1;
MACRUM 0:276e7a263c35 779
MACRUM 0:276e7a263c35 780 TEST_ASSERT_EQUAL_UINT(1837, 1837);
MACRUM 0:276e7a263c35 781 TEST_ASSERT_EQUAL_UINT(2987, 2987);
MACRUM 0:276e7a263c35 782 TEST_ASSERT_EQUAL_UINT(v0, v1);
MACRUM 0:276e7a263c35 783 TEST_ASSERT_EQUAL_UINT(19467, v1);
MACRUM 0:276e7a263c35 784 TEST_ASSERT_EQUAL_UINT(v0, 19467);
MACRUM 0:276e7a263c35 785 TEST_ASSERT_EQUAL_UINT(*p0, v1);
MACRUM 0:276e7a263c35 786 TEST_ASSERT_EQUAL_UINT(*p0, *p1);
MACRUM 0:276e7a263c35 787 TEST_ASSERT_EQUAL_UINT(*p0, 19467);
MACRUM 0:276e7a263c35 788 }
MACRUM 0:276e7a263c35 789
MACRUM 0:276e7a263c35 790 void testEqualChars(void)
MACRUM 0:276e7a263c35 791 {
MACRUM 0:276e7a263c35 792 signed char v0, v1;
MACRUM 0:276e7a263c35 793 signed char *p0, *p1;
MACRUM 0:276e7a263c35 794
MACRUM 0:276e7a263c35 795 v0 = 109;
MACRUM 0:276e7a263c35 796 v1 = 109;
MACRUM 0:276e7a263c35 797 p0 = &v0;
MACRUM 0:276e7a263c35 798 p1 = &v1;
MACRUM 0:276e7a263c35 799
MACRUM 0:276e7a263c35 800 TEST_ASSERT_EQUAL_INT(42, 42);
MACRUM 0:276e7a263c35 801 TEST_ASSERT_EQUAL_INT(-116, -116);
MACRUM 0:276e7a263c35 802 TEST_ASSERT_EQUAL_INT(v0, v1);
MACRUM 0:276e7a263c35 803 TEST_ASSERT_EQUAL_INT(109, v1);
MACRUM 0:276e7a263c35 804 TEST_ASSERT_EQUAL_INT(v0, 109);
MACRUM 0:276e7a263c35 805 TEST_ASSERT_EQUAL_INT(*p0, v1);
MACRUM 0:276e7a263c35 806 TEST_ASSERT_EQUAL_INT(*p0, *p1);
MACRUM 0:276e7a263c35 807 TEST_ASSERT_EQUAL_INT(*p0, 109);
MACRUM 0:276e7a263c35 808 }
MACRUM 0:276e7a263c35 809
MACRUM 0:276e7a263c35 810 void testEqualUChars(void)
MACRUM 0:276e7a263c35 811 {
MACRUM 0:276e7a263c35 812 unsigned char v0, v1;
MACRUM 0:276e7a263c35 813 unsigned char *p0, *p1;
MACRUM 0:276e7a263c35 814
MACRUM 0:276e7a263c35 815 v0 = 251;
MACRUM 0:276e7a263c35 816 v1 = 251;
MACRUM 0:276e7a263c35 817 p0 = &v0;
MACRUM 0:276e7a263c35 818 p1 = &v1;
MACRUM 0:276e7a263c35 819
MACRUM 0:276e7a263c35 820 TEST_ASSERT_EQUAL_INT(42, 42);
MACRUM 0:276e7a263c35 821 TEST_ASSERT_EQUAL_INT(v0, v1);
MACRUM 0:276e7a263c35 822 TEST_ASSERT_EQUAL_INT(251, v1);
MACRUM 0:276e7a263c35 823 TEST_ASSERT_EQUAL_INT(v0, 251);
MACRUM 0:276e7a263c35 824 TEST_ASSERT_EQUAL_INT(*p0, v1);
MACRUM 0:276e7a263c35 825 TEST_ASSERT_EQUAL_INT(*p0, *p1);
MACRUM 0:276e7a263c35 826 TEST_ASSERT_EQUAL_INT(*p0, 251);
MACRUM 0:276e7a263c35 827 }
MACRUM 0:276e7a263c35 828
MACRUM 0:276e7a263c35 829 void testEqualPointers(void)
MACRUM 0:276e7a263c35 830 {
MACRUM 0:276e7a263c35 831 int v0, v1;
MACRUM 0:276e7a263c35 832 int *p0, *p1, *p2;
MACRUM 0:276e7a263c35 833
MACRUM 0:276e7a263c35 834 v0 = 19467;
MACRUM 0:276e7a263c35 835 v1 = 18271;
MACRUM 0:276e7a263c35 836 p0 = &v0;
MACRUM 0:276e7a263c35 837 p1 = &v1;
MACRUM 0:276e7a263c35 838 p2 = &v1;
MACRUM 0:276e7a263c35 839
MACRUM 0:276e7a263c35 840 TEST_ASSERT_EQUAL_PTR(p0, &v0);
MACRUM 0:276e7a263c35 841 TEST_ASSERT_EQUAL_PTR(&v1, p1);
MACRUM 0:276e7a263c35 842 TEST_ASSERT_EQUAL_PTR(p2, p1);
MACRUM 0:276e7a263c35 843 TEST_ASSERT_EQUAL_PTR(&v0, &v0);
MACRUM 0:276e7a263c35 844 }
MACRUM 0:276e7a263c35 845
MACRUM 0:276e7a263c35 846 void testNotEqualPointers(void)
MACRUM 0:276e7a263c35 847 {
MACRUM 0:276e7a263c35 848 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 849 TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677);
MACRUM 0:276e7a263c35 850 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 851 }
MACRUM 0:276e7a263c35 852
MACRUM 0:276e7a263c35 853 void testIntsWithinDelta(void)
MACRUM 0:276e7a263c35 854 {
MACRUM 0:276e7a263c35 855 TEST_ASSERT_INT_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 856 TEST_ASSERT_INT_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 857 TEST_ASSERT_INT_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 858 TEST_ASSERT_INT_WITHIN(500, 50, -440);
MACRUM 0:276e7a263c35 859
MACRUM 0:276e7a263c35 860 TEST_ASSERT_INT_WITHIN(2, -1, -1);
MACRUM 0:276e7a263c35 861 TEST_ASSERT_INT_WITHIN(5, 1, -1);
MACRUM 0:276e7a263c35 862 TEST_ASSERT_INT_WITHIN(5, -1, 1);
MACRUM 0:276e7a263c35 863 }
MACRUM 0:276e7a263c35 864
MACRUM 0:276e7a263c35 865 void testIntsWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 866 {
MACRUM 0:276e7a263c35 867 TEST_ASSERT_INT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 868 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
MACRUM 0:276e7a263c35 869 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
MACRUM 0:276e7a263c35 870 TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message.");
MACRUM 0:276e7a263c35 871
MACRUM 0:276e7a263c35 872 TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message.");
MACRUM 0:276e7a263c35 873 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
MACRUM 0:276e7a263c35 874 TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message.");
MACRUM 0:276e7a263c35 875 }
MACRUM 0:276e7a263c35 876
MACRUM 0:276e7a263c35 877 void testIntsNotWithinDelta(void)
MACRUM 0:276e7a263c35 878 {
MACRUM 0:276e7a263c35 879 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 880 TEST_ASSERT_INT_WITHIN(5, 5000, 5006);
MACRUM 0:276e7a263c35 881 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 882 }
MACRUM 0:276e7a263c35 883
MACRUM 0:276e7a263c35 884 void testIntsNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 885 {
MACRUM 0:276e7a263c35 886 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 887 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5006, "Custom Message.");
MACRUM 0:276e7a263c35 888 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 889 }
MACRUM 0:276e7a263c35 890
MACRUM 0:276e7a263c35 891 void testUIntsWithinDelta(void)
MACRUM 0:276e7a263c35 892 {
MACRUM 0:276e7a263c35 893 TEST_ASSERT_UINT_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 894 TEST_ASSERT_UINT_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 895 TEST_ASSERT_UINT_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 896 }
MACRUM 0:276e7a263c35 897
MACRUM 0:276e7a263c35 898 void testUIntsWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 899 {
MACRUM 0:276e7a263c35 900 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 901 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
MACRUM 0:276e7a263c35 902 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
MACRUM 0:276e7a263c35 903 }
MACRUM 0:276e7a263c35 904
MACRUM 0:276e7a263c35 905 void testUIntsNotWithinDelta(void)
MACRUM 0:276e7a263c35 906 {
MACRUM 0:276e7a263c35 907 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 908 TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u);
MACRUM 0:276e7a263c35 909 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 910 }
MACRUM 0:276e7a263c35 911
MACRUM 0:276e7a263c35 912 void testUIntsNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 913 {
MACRUM 0:276e7a263c35 914 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 915 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
MACRUM 0:276e7a263c35 916 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 917 }
MACRUM 0:276e7a263c35 918
MACRUM 0:276e7a263c35 919 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void)
MACRUM 0:276e7a263c35 920 {
MACRUM 0:276e7a263c35 921 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 922 TEST_ASSERT_UINT_WITHIN(5, 1, -1);
MACRUM 0:276e7a263c35 923 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 924 }
MACRUM 0:276e7a263c35 925
MACRUM 0:276e7a263c35 926 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void)
MACRUM 0:276e7a263c35 927 {
MACRUM 0:276e7a263c35 928 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 929 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
MACRUM 0:276e7a263c35 930 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 931 }
MACRUM 0:276e7a263c35 932
MACRUM 0:276e7a263c35 933 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void)
MACRUM 0:276e7a263c35 934 {
MACRUM 0:276e7a263c35 935 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 936 TEST_ASSERT_UINT_WITHIN(5, -1, 1);
MACRUM 0:276e7a263c35 937 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 938 }
MACRUM 0:276e7a263c35 939
MACRUM 0:276e7a263c35 940 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void)
MACRUM 0:276e7a263c35 941 {
MACRUM 0:276e7a263c35 942 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 943 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, -1, 1, "Custom Message.");
MACRUM 0:276e7a263c35 944 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 945 }
MACRUM 0:276e7a263c35 946
MACRUM 0:276e7a263c35 947 void testHEX32sWithinDelta(void)
MACRUM 0:276e7a263c35 948 {
MACRUM 0:276e7a263c35 949 TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 950 TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 951 TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 952 }
MACRUM 0:276e7a263c35 953
MACRUM 0:276e7a263c35 954 void testHEX32sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 955 {
MACRUM 0:276e7a263c35 956 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 957 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
MACRUM 0:276e7a263c35 958 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
MACRUM 0:276e7a263c35 959 }
MACRUM 0:276e7a263c35 960
MACRUM 0:276e7a263c35 961 void testHEX32sNotWithinDelta(void)
MACRUM 0:276e7a263c35 962 {
MACRUM 0:276e7a263c35 963 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 964 TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u);
MACRUM 0:276e7a263c35 965 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 966 }
MACRUM 0:276e7a263c35 967
MACRUM 0:276e7a263c35 968 void testHEX32sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 969 {
MACRUM 0:276e7a263c35 970 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 971 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
MACRUM 0:276e7a263c35 972 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 973 }
MACRUM 0:276e7a263c35 974
MACRUM 0:276e7a263c35 975 void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
MACRUM 0:276e7a263c35 976 {
MACRUM 0:276e7a263c35 977 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 978 TEST_ASSERT_HEX32_WITHIN(5, 1, -1);
MACRUM 0:276e7a263c35 979 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 980 }
MACRUM 0:276e7a263c35 981
MACRUM 0:276e7a263c35 982 void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)
MACRUM 0:276e7a263c35 983 {
MACRUM 0:276e7a263c35 984 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 985 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
MACRUM 0:276e7a263c35 986 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 987 }
MACRUM 0:276e7a263c35 988
MACRUM 0:276e7a263c35 989 void testHEX16sWithinDelta(void)
MACRUM 0:276e7a263c35 990 {
MACRUM 0:276e7a263c35 991 TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 992 TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 993 TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 994 }
MACRUM 0:276e7a263c35 995
MACRUM 0:276e7a263c35 996 void testHEX16sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 997 {
MACRUM 0:276e7a263c35 998 TEST_ASSERT_HEX16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 999 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
MACRUM 0:276e7a263c35 1000 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
MACRUM 0:276e7a263c35 1001 }
MACRUM 0:276e7a263c35 1002
MACRUM 0:276e7a263c35 1003 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
MACRUM 0:276e7a263c35 1004 {
MACRUM 0:276e7a263c35 1005 TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321);
MACRUM 0:276e7a263c35 1006 }
MACRUM 0:276e7a263c35 1007
MACRUM 0:276e7a263c35 1008 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
MACRUM 0:276e7a263c35 1009 {
MACRUM 0:276e7a263c35 1010 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
MACRUM 0:276e7a263c35 1011 }
MACRUM 0:276e7a263c35 1012
MACRUM 0:276e7a263c35 1013 void testHEX16sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1014 {
MACRUM 0:276e7a263c35 1015 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1016 TEST_ASSERT_HEX16_WITHIN(2, 65535, 0);
MACRUM 0:276e7a263c35 1017 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1018 }
MACRUM 0:276e7a263c35 1019
MACRUM 0:276e7a263c35 1020 void testHEX16sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1021 {
MACRUM 0:276e7a263c35 1022 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1023 TEST_ASSERT_HEX16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message.");
MACRUM 0:276e7a263c35 1024 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1025 }
MACRUM 0:276e7a263c35 1026
MACRUM 0:276e7a263c35 1027 void testHEX8sWithinDelta(void)
MACRUM 0:276e7a263c35 1028 {
MACRUM 0:276e7a263c35 1029 TEST_ASSERT_HEX8_WITHIN(1, 254, 255);
MACRUM 0:276e7a263c35 1030 TEST_ASSERT_HEX8_WITHIN(5, 251, 255);
MACRUM 0:276e7a263c35 1031 TEST_ASSERT_HEX8_WITHIN(5, 1, 4);
MACRUM 0:276e7a263c35 1032 }
MACRUM 0:276e7a263c35 1033
MACRUM 0:276e7a263c35 1034 void testHEX8sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1035 {
MACRUM 0:276e7a263c35 1036 TEST_ASSERT_HEX8_WITHIN_MESSAGE(1, 254, 255, "Custom Message.");
MACRUM 0:276e7a263c35 1037 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 251, 255, "Custom Message.");
MACRUM 0:276e7a263c35 1038 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
MACRUM 0:276e7a263c35 1039 }
MACRUM 0:276e7a263c35 1040
MACRUM 0:276e7a263c35 1041 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
MACRUM 0:276e7a263c35 1042 {
MACRUM 0:276e7a263c35 1043 TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23);
MACRUM 0:276e7a263c35 1044 }
MACRUM 0:276e7a263c35 1045
MACRUM 0:276e7a263c35 1046 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
MACRUM 0:276e7a263c35 1047 {
MACRUM 0:276e7a263c35 1048 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
MACRUM 0:276e7a263c35 1049 }
MACRUM 0:276e7a263c35 1050
MACRUM 0:276e7a263c35 1051 void testHEX8sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1052 {
MACRUM 0:276e7a263c35 1053 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1054 TEST_ASSERT_HEX8_WITHIN(2, 255, 0);
MACRUM 0:276e7a263c35 1055 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1056 }
MACRUM 0:276e7a263c35 1057
MACRUM 0:276e7a263c35 1058 void testHEX8sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1059 {
MACRUM 0:276e7a263c35 1060 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1061 TEST_ASSERT_HEX8_WITHIN_MESSAGE(2, 255, 0, "Custom Message.");
MACRUM 0:276e7a263c35 1062 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1063 }
MACRUM 0:276e7a263c35 1064
MACRUM 0:276e7a263c35 1065 //-----------------
MACRUM 0:276e7a263c35 1066
MACRUM 0:276e7a263c35 1067 void testUINT32sWithinDelta(void)
MACRUM 0:276e7a263c35 1068 {
MACRUM 0:276e7a263c35 1069 TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 1070 TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 1071 TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 1072 }
MACRUM 0:276e7a263c35 1073
MACRUM 0:276e7a263c35 1074 void testUINT32sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1075 {
MACRUM 0:276e7a263c35 1076 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 1077 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
MACRUM 0:276e7a263c35 1078 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
MACRUM 0:276e7a263c35 1079 }
MACRUM 0:276e7a263c35 1080
MACRUM 0:276e7a263c35 1081 void testUINT32sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1082 {
MACRUM 0:276e7a263c35 1083 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1084 TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u);
MACRUM 0:276e7a263c35 1085 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1086 }
MACRUM 0:276e7a263c35 1087
MACRUM 0:276e7a263c35 1088 void testUINT32sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1089 {
MACRUM 0:276e7a263c35 1090 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1091 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
MACRUM 0:276e7a263c35 1092 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1093 }
MACRUM 0:276e7a263c35 1094
MACRUM 0:276e7a263c35 1095 void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
MACRUM 0:276e7a263c35 1096 {
MACRUM 0:276e7a263c35 1097 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1098 TEST_ASSERT_UINT32_WITHIN(5, 1, -1);
MACRUM 0:276e7a263c35 1099 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1100 }
MACRUM 0:276e7a263c35 1101
MACRUM 0:276e7a263c35 1102 void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)
MACRUM 0:276e7a263c35 1103 {
MACRUM 0:276e7a263c35 1104 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1105 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
MACRUM 0:276e7a263c35 1106 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1107 }
MACRUM 0:276e7a263c35 1108
MACRUM 0:276e7a263c35 1109 void testUINT16sWithinDelta(void)
MACRUM 0:276e7a263c35 1110 {
MACRUM 0:276e7a263c35 1111 TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 1112 TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 1113 TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 1114 }
MACRUM 0:276e7a263c35 1115
MACRUM 0:276e7a263c35 1116 void testUINT16sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1117 {
MACRUM 0:276e7a263c35 1118 TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 1119 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
MACRUM 0:276e7a263c35 1120 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
MACRUM 0:276e7a263c35 1121 }
MACRUM 0:276e7a263c35 1122
MACRUM 0:276e7a263c35 1123 void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
MACRUM 0:276e7a263c35 1124 {
MACRUM 0:276e7a263c35 1125 TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321);
MACRUM 0:276e7a263c35 1126 }
MACRUM 0:276e7a263c35 1127
MACRUM 0:276e7a263c35 1128 void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
MACRUM 0:276e7a263c35 1129 {
MACRUM 0:276e7a263c35 1130 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
MACRUM 0:276e7a263c35 1131 }
MACRUM 0:276e7a263c35 1132
MACRUM 0:276e7a263c35 1133 void testUINT16sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1134 {
MACRUM 0:276e7a263c35 1135 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1136 TEST_ASSERT_UINT16_WITHIN(2, 65535, 0);
MACRUM 0:276e7a263c35 1137 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1138 }
MACRUM 0:276e7a263c35 1139
MACRUM 0:276e7a263c35 1140 void testUINT16sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1141 {
MACRUM 0:276e7a263c35 1142 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1143 TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message.");
MACRUM 0:276e7a263c35 1144 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1145 }
MACRUM 0:276e7a263c35 1146
MACRUM 0:276e7a263c35 1147 void testUINT8sWithinDelta(void)
MACRUM 0:276e7a263c35 1148 {
MACRUM 0:276e7a263c35 1149 TEST_ASSERT_UINT8_WITHIN(1, 254, 255);
MACRUM 0:276e7a263c35 1150 TEST_ASSERT_UINT8_WITHIN(5, 251, 255);
MACRUM 0:276e7a263c35 1151 TEST_ASSERT_UINT8_WITHIN(5, 1, 4);
MACRUM 0:276e7a263c35 1152 }
MACRUM 0:276e7a263c35 1153
MACRUM 0:276e7a263c35 1154 void testUINT8sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1155 {
MACRUM 0:276e7a263c35 1156 TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message.");
MACRUM 0:276e7a263c35 1157 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message.");
MACRUM 0:276e7a263c35 1158 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
MACRUM 0:276e7a263c35 1159 }
MACRUM 0:276e7a263c35 1160
MACRUM 0:276e7a263c35 1161 void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
MACRUM 0:276e7a263c35 1162 {
MACRUM 0:276e7a263c35 1163 TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23);
MACRUM 0:276e7a263c35 1164 }
MACRUM 0:276e7a263c35 1165
MACRUM 0:276e7a263c35 1166 void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
MACRUM 0:276e7a263c35 1167 {
MACRUM 0:276e7a263c35 1168 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
MACRUM 0:276e7a263c35 1169 }
MACRUM 0:276e7a263c35 1170
MACRUM 0:276e7a263c35 1171 void testUINT8sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1172 {
MACRUM 0:276e7a263c35 1173 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1174 TEST_ASSERT_UINT8_WITHIN(2, 255, 0);
MACRUM 0:276e7a263c35 1175 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1176 }
MACRUM 0:276e7a263c35 1177
MACRUM 0:276e7a263c35 1178 void testUINT8sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1179 {
MACRUM 0:276e7a263c35 1180 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1181 TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message.");
MACRUM 0:276e7a263c35 1182 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1183 }
MACRUM 0:276e7a263c35 1184
MACRUM 0:276e7a263c35 1185 void testINT32sWithinDelta(void)
MACRUM 0:276e7a263c35 1186 {
MACRUM 0:276e7a263c35 1187 TEST_ASSERT_INT32_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 1188 TEST_ASSERT_INT32_WITHIN(5, 1, -2);
MACRUM 0:276e7a263c35 1189 TEST_ASSERT_INT32_WITHIN(5, -2, 1);
MACRUM 0:276e7a263c35 1190 }
MACRUM 0:276e7a263c35 1191
MACRUM 0:276e7a263c35 1192 void testINT32sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1193 {
MACRUM 0:276e7a263c35 1194 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 1195 }
MACRUM 0:276e7a263c35 1196
MACRUM 0:276e7a263c35 1197 void testINT32sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1198 {
MACRUM 0:276e7a263c35 1199 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1200 TEST_ASSERT_INT32_WITHIN(1, -3, 1);
MACRUM 0:276e7a263c35 1201 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1202 }
MACRUM 0:276e7a263c35 1203
MACRUM 0:276e7a263c35 1204 void testINT32sNotWithinDeltaAndDifferenceOverflows(void)
MACRUM 0:276e7a263c35 1205 {
MACRUM 0:276e7a263c35 1206 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1207 TEST_ASSERT_INT32_WITHIN(1, -1, 0x7FFFFFFF);
MACRUM 0:276e7a263c35 1208 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1209 }
MACRUM 0:276e7a263c35 1210 void testINT32sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1211 {
MACRUM 0:276e7a263c35 1212 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1213 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message.");
MACRUM 0:276e7a263c35 1214 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1215 }
MACRUM 0:276e7a263c35 1216
MACRUM 0:276e7a263c35 1217 void testINT16sWithinDelta(void)
MACRUM 0:276e7a263c35 1218 {
MACRUM 0:276e7a263c35 1219 TEST_ASSERT_INT16_WITHIN(1, 5000, 5001);
MACRUM 0:276e7a263c35 1220 TEST_ASSERT_INT16_WITHIN(5, 2, -2);
MACRUM 0:276e7a263c35 1221 TEST_ASSERT_INT16_WITHIN(5, -2, 2);
MACRUM 0:276e7a263c35 1222 }
MACRUM 0:276e7a263c35 1223
MACRUM 0:276e7a263c35 1224 void testINT16sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1225 {
MACRUM 0:276e7a263c35 1226 TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
MACRUM 0:276e7a263c35 1227 }
MACRUM 0:276e7a263c35 1228
MACRUM 0:276e7a263c35 1229 void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
MACRUM 0:276e7a263c35 1230 {
MACRUM 0:276e7a263c35 1231 TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321);
MACRUM 0:276e7a263c35 1232 }
MACRUM 0:276e7a263c35 1233
MACRUM 0:276e7a263c35 1234 void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
MACRUM 0:276e7a263c35 1235 {
MACRUM 0:276e7a263c35 1236 TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
MACRUM 0:276e7a263c35 1237 }
MACRUM 0:276e7a263c35 1238
MACRUM 0:276e7a263c35 1239 void testINT16sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1240 {
MACRUM 0:276e7a263c35 1241 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1242 TEST_ASSERT_INT16_WITHIN(2, 4, -2);
MACRUM 0:276e7a263c35 1243 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1244 }
MACRUM 0:276e7a263c35 1245
MACRUM 0:276e7a263c35 1246 void testINT16sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1247 {
MACRUM 0:276e7a263c35 1248 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1249 TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message.");
MACRUM 0:276e7a263c35 1250 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1251 }
MACRUM 0:276e7a263c35 1252
MACRUM 0:276e7a263c35 1253 void testINT8sWithinDelta(void)
MACRUM 0:276e7a263c35 1254 {
MACRUM 0:276e7a263c35 1255 TEST_ASSERT_INT8_WITHIN(1, 127, 126);
MACRUM 0:276e7a263c35 1256 TEST_ASSERT_INT8_WITHIN(5, -2, 2);
MACRUM 0:276e7a263c35 1257 TEST_ASSERT_INT8_WITHIN(5, 2, -2);
MACRUM 0:276e7a263c35 1258 }
MACRUM 0:276e7a263c35 1259
MACRUM 0:276e7a263c35 1260 void testINT8sWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1261 {
MACRUM 0:276e7a263c35 1262 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
MACRUM 0:276e7a263c35 1263 }
MACRUM 0:276e7a263c35 1264
MACRUM 0:276e7a263c35 1265 void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
MACRUM 0:276e7a263c35 1266 {
MACRUM 0:276e7a263c35 1267 TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23);
MACRUM 0:276e7a263c35 1268 }
MACRUM 0:276e7a263c35 1269
MACRUM 0:276e7a263c35 1270 void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
MACRUM 0:276e7a263c35 1271 {
MACRUM 0:276e7a263c35 1272 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
MACRUM 0:276e7a263c35 1273 }
MACRUM 0:276e7a263c35 1274
MACRUM 0:276e7a263c35 1275 void testINT8sNotWithinDelta(void)
MACRUM 0:276e7a263c35 1276 {
MACRUM 0:276e7a263c35 1277 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1278 TEST_ASSERT_INT8_WITHIN(2, -3, 0);
MACRUM 0:276e7a263c35 1279 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1280 }
MACRUM 0:276e7a263c35 1281
MACRUM 0:276e7a263c35 1282 void testINT8sNotWithinDeltaAndCustomMessage(void)
MACRUM 0:276e7a263c35 1283 {
MACRUM 0:276e7a263c35 1284 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1285 TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message.");
MACRUM 0:276e7a263c35 1286 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1287 }
MACRUM 0:276e7a263c35 1288
MACRUM 0:276e7a263c35 1289 void testEqualStrings(void)
MACRUM 0:276e7a263c35 1290 {
MACRUM 0:276e7a263c35 1291 const char *testString = "foo";
MACRUM 0:276e7a263c35 1292
MACRUM 0:276e7a263c35 1293 TEST_ASSERT_EQUAL_STRING(testString, testString);
MACRUM 0:276e7a263c35 1294 TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo");
MACRUM 0:276e7a263c35 1295 TEST_ASSERT_EQUAL_STRING("foo", testString);
MACRUM 0:276e7a263c35 1296 TEST_ASSERT_EQUAL_STRING(testString, "foo");
MACRUM 0:276e7a263c35 1297 TEST_ASSERT_EQUAL_STRING("", "");
MACRUM 0:276e7a263c35 1298 }
MACRUM 0:276e7a263c35 1299
MACRUM 0:276e7a263c35 1300 void testEqualStringsLen(void)
MACRUM 0:276e7a263c35 1301 {
MACRUM 0:276e7a263c35 1302 const char *testString = "foobar";
MACRUM 0:276e7a263c35 1303 TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString));
MACRUM 0:276e7a263c35 1304 TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba");
MACRUM 0:276e7a263c35 1305 TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3);
MACRUM 0:276e7a263c35 1306 TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3);
MACRUM 0:276e7a263c35 1307 TEST_ASSERT_EQUAL_STRING_LEN("", "", 3);
MACRUM 0:276e7a263c35 1308 }
MACRUM 0:276e7a263c35 1309
MACRUM 0:276e7a263c35 1310 void testEqualStringsWithCarriageReturnsAndLineFeeds(void)
MACRUM 0:276e7a263c35 1311 {
MACRUM 0:276e7a263c35 1312 const char *testString = "foo\r\nbar";
MACRUM 0:276e7a263c35 1313
MACRUM 0:276e7a263c35 1314 TEST_ASSERT_EQUAL_STRING(testString, testString);
MACRUM 0:276e7a263c35 1315 TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar");
MACRUM 0:276e7a263c35 1316 TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString);
MACRUM 0:276e7a263c35 1317 TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar");
MACRUM 0:276e7a263c35 1318 TEST_ASSERT_EQUAL_STRING("", "");
MACRUM 0:276e7a263c35 1319 }
MACRUM 0:276e7a263c35 1320
MACRUM 0:276e7a263c35 1321 void testNotEqualString1(void)
MACRUM 0:276e7a263c35 1322 {
MACRUM 0:276e7a263c35 1323 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1324 TEST_ASSERT_EQUAL_STRING("foo", "bar");
MACRUM 0:276e7a263c35 1325 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1326 }
MACRUM 0:276e7a263c35 1327
MACRUM 0:276e7a263c35 1328 void testNotEqualStringLen1(void)
MACRUM 0:276e7a263c35 1329 {
MACRUM 0:276e7a263c35 1330 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1331 TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6);
MACRUM 0:276e7a263c35 1332 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1333 }
MACRUM 0:276e7a263c35 1334
MACRUM 0:276e7a263c35 1335 void testNotEqualString2(void)
MACRUM 0:276e7a263c35 1336 {
MACRUM 0:276e7a263c35 1337 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1338 TEST_ASSERT_EQUAL_STRING("foo", "");
MACRUM 0:276e7a263c35 1339 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1340 }
MACRUM 0:276e7a263c35 1341
MACRUM 0:276e7a263c35 1342 void testNotEqualStringLen2(void)
MACRUM 0:276e7a263c35 1343 {
MACRUM 0:276e7a263c35 1344 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1345 TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3);
MACRUM 0:276e7a263c35 1346 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1347 }
MACRUM 0:276e7a263c35 1348
MACRUM 0:276e7a263c35 1349 void testNotEqualString3(void)
MACRUM 0:276e7a263c35 1350 {
MACRUM 0:276e7a263c35 1351 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1352 TEST_ASSERT_EQUAL_STRING("", "bar");
MACRUM 0:276e7a263c35 1353 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1354 }
MACRUM 0:276e7a263c35 1355
MACRUM 0:276e7a263c35 1356 void testNotEqualStringLen3(void)
MACRUM 0:276e7a263c35 1357 {
MACRUM 0:276e7a263c35 1358 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1359 TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3);
MACRUM 0:276e7a263c35 1360 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1361 }
MACRUM 0:276e7a263c35 1362
MACRUM 0:276e7a263c35 1363 void testNotEqualString4(void)
MACRUM 0:276e7a263c35 1364 {
MACRUM 0:276e7a263c35 1365 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1366 TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n");
MACRUM 0:276e7a263c35 1367 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1368 }
MACRUM 0:276e7a263c35 1369
MACRUM 0:276e7a263c35 1370 void testNotEqualStringLen4(void)
MACRUM 0:276e7a263c35 1371 {
MACRUM 0:276e7a263c35 1372 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1373 TEST_ASSERT_EQUAL_STRING_LEN("\r\x16", "bar\n", 4);
MACRUM 0:276e7a263c35 1374 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1375 }
MACRUM 0:276e7a263c35 1376
MACRUM 0:276e7a263c35 1377 void testNotEqualString5(void)
MACRUM 0:276e7a263c35 1378 {
MACRUM 0:276e7a263c35 1379 const char str1[] = { 0x41, 0x42, 0x03, 0x00 };
MACRUM 0:276e7a263c35 1380 const char str2[] = { 0x41, 0x42, 0x04, 0x00 };
MACRUM 0:276e7a263c35 1381 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1382 TEST_ASSERT_EQUAL_STRING(str1, str2);
MACRUM 0:276e7a263c35 1383 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1384 }
MACRUM 0:276e7a263c35 1385
MACRUM 0:276e7a263c35 1386 void testNotEqualString_ExpectedStringIsNull(void)
MACRUM 0:276e7a263c35 1387 {
MACRUM 0:276e7a263c35 1388 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1389 TEST_ASSERT_EQUAL_STRING(NULL, "bar");
MACRUM 0:276e7a263c35 1390 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1391 }
MACRUM 0:276e7a263c35 1392
MACRUM 0:276e7a263c35 1393 void testNotEqualStringLen_ExpectedStringIsNull(void)
MACRUM 0:276e7a263c35 1394 {
MACRUM 0:276e7a263c35 1395 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1396 TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1);
MACRUM 0:276e7a263c35 1397 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1398 }
MACRUM 0:276e7a263c35 1399
MACRUM 0:276e7a263c35 1400 void testNotEqualString_ActualStringIsNull(void)
MACRUM 0:276e7a263c35 1401 {
MACRUM 0:276e7a263c35 1402 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1403 TEST_ASSERT_EQUAL_STRING("foo", NULL);
MACRUM 0:276e7a263c35 1404 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1405 }
MACRUM 0:276e7a263c35 1406
MACRUM 0:276e7a263c35 1407 void testNotEqualStringLen_ActualStringIsNull(void)
MACRUM 0:276e7a263c35 1408 {
MACRUM 0:276e7a263c35 1409 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1410 TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1);
MACRUM 0:276e7a263c35 1411 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1412 }
MACRUM 0:276e7a263c35 1413
MACRUM 0:276e7a263c35 1414 void testEqualStringArrays(void)
MACRUM 0:276e7a263c35 1415 {
MACRUM 0:276e7a263c35 1416 const char *testStrings[] = { "foo", "boo", "woo", "moo" };
MACRUM 0:276e7a263c35 1417 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
MACRUM 0:276e7a263c35 1418
MACRUM 0:276e7a263c35 1419 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3);
MACRUM 0:276e7a263c35 1420 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3);
MACRUM 0:276e7a263c35 1421 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2);
MACRUM 0:276e7a263c35 1422 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1);
MACRUM 0:276e7a263c35 1423 }
MACRUM 0:276e7a263c35 1424
MACRUM 0:276e7a263c35 1425 void testNotEqualStringArray1(void)
MACRUM 0:276e7a263c35 1426 {
MACRUM 0:276e7a263c35 1427 const char *testStrings[] = { "foo", "boo", "woo", "moo" };
MACRUM 0:276e7a263c35 1428 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
MACRUM 0:276e7a263c35 1429
MACRUM 0:276e7a263c35 1430 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1431 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1432 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1433 }
MACRUM 0:276e7a263c35 1434
MACRUM 0:276e7a263c35 1435 void testNotEqualStringArray2(void)
MACRUM 0:276e7a263c35 1436 {
MACRUM 0:276e7a263c35 1437 const char *testStrings[] = { "zoo", "boo", "woo", "moo" };
MACRUM 0:276e7a263c35 1438 const char *expStrings[] = { "foo", "boo", "woo", "moo" };
MACRUM 0:276e7a263c35 1439
MACRUM 0:276e7a263c35 1440 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1441 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1442 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1443 }
MACRUM 0:276e7a263c35 1444
MACRUM 0:276e7a263c35 1445 void testNotEqualStringArray3(void)
MACRUM 0:276e7a263c35 1446 {
MACRUM 0:276e7a263c35 1447 const char *testStrings[] = { "foo", "boo", "woo", NULL };
MACRUM 0:276e7a263c35 1448 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
MACRUM 0:276e7a263c35 1449
MACRUM 0:276e7a263c35 1450 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1451 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1452 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1453 }
MACRUM 0:276e7a263c35 1454
MACRUM 0:276e7a263c35 1455 void testNotEqualStringArray4(void)
MACRUM 0:276e7a263c35 1456 {
MACRUM 0:276e7a263c35 1457 const char *testStrings[] = { "foo", "boo", "woo", "moo" };
MACRUM 0:276e7a263c35 1458 const char *expStrings[] = { "foo", NULL, "woo", "moo" };
MACRUM 0:276e7a263c35 1459
MACRUM 0:276e7a263c35 1460 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1461 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1462 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1463 }
MACRUM 0:276e7a263c35 1464
MACRUM 0:276e7a263c35 1465 void testNotEqualStringArray5(void)
MACRUM 0:276e7a263c35 1466 {
MACRUM 0:276e7a263c35 1467 const char **testStrings = NULL;
MACRUM 0:276e7a263c35 1468 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
MACRUM 0:276e7a263c35 1469
MACRUM 0:276e7a263c35 1470 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1471 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1472 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1473 }
MACRUM 0:276e7a263c35 1474
MACRUM 0:276e7a263c35 1475 void testNotEqualStringArray6(void)
MACRUM 0:276e7a263c35 1476 {
MACRUM 0:276e7a263c35 1477 const char *testStrings[] = { "foo", "boo", "woo", "zoo" };
MACRUM 0:276e7a263c35 1478 const char **expStrings = NULL;
MACRUM 0:276e7a263c35 1479
MACRUM 0:276e7a263c35 1480 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1481 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1482 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1483 }
MACRUM 0:276e7a263c35 1484
MACRUM 0:276e7a263c35 1485 void testEqualStringArrayIfBothNulls(void)
MACRUM 0:276e7a263c35 1486 {
MACRUM 0:276e7a263c35 1487 const char **testStrings = NULL;
MACRUM 0:276e7a263c35 1488 const char **expStrings = NULL;
MACRUM 0:276e7a263c35 1489
MACRUM 0:276e7a263c35 1490 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
MACRUM 0:276e7a263c35 1491 }
MACRUM 0:276e7a263c35 1492
MACRUM 0:276e7a263c35 1493 void testNotEqualStringArrayLengthZero(void)
MACRUM 0:276e7a263c35 1494 {
MACRUM 0:276e7a263c35 1495 const char *testStrings[] = {NULL};
MACRUM 0:276e7a263c35 1496 const char **expStrings = NULL;
MACRUM 0:276e7a263c35 1497
MACRUM 0:276e7a263c35 1498 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1499 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0);
MACRUM 0:276e7a263c35 1500 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1501 }
MACRUM 0:276e7a263c35 1502
MACRUM 0:276e7a263c35 1503 void testEqualMemory(void)
MACRUM 0:276e7a263c35 1504 {
MACRUM 0:276e7a263c35 1505 const char *testString = "whatever";
MACRUM 0:276e7a263c35 1506
MACRUM 0:276e7a263c35 1507 TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8);
MACRUM 0:276e7a263c35 1508 TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8);
MACRUM 0:276e7a263c35 1509 TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8);
MACRUM 0:276e7a263c35 1510 TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8);
MACRUM 0:276e7a263c35 1511 TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2);
MACRUM 0:276e7a263c35 1512 TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1);
MACRUM 0:276e7a263c35 1513 }
MACRUM 0:276e7a263c35 1514
MACRUM 0:276e7a263c35 1515 void testNotEqualMemory1(void)
MACRUM 0:276e7a263c35 1516 {
MACRUM 0:276e7a263c35 1517 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1518 TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3);
MACRUM 0:276e7a263c35 1519 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1520 }
MACRUM 0:276e7a263c35 1521
MACRUM 0:276e7a263c35 1522 void testNotEqualMemory2(void)
MACRUM 0:276e7a263c35 1523 {
MACRUM 0:276e7a263c35 1524 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1525 TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4);
MACRUM 0:276e7a263c35 1526 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1527 }
MACRUM 0:276e7a263c35 1528
MACRUM 0:276e7a263c35 1529 void testNotEqualMemory3(void)
MACRUM 0:276e7a263c35 1530 {
MACRUM 0:276e7a263c35 1531 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1532 TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4);
MACRUM 0:276e7a263c35 1533 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1534 }
MACRUM 0:276e7a263c35 1535
MACRUM 0:276e7a263c35 1536 void testNotEqualMemory4(void)
MACRUM 0:276e7a263c35 1537 {
MACRUM 0:276e7a263c35 1538 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1539 TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4);
MACRUM 0:276e7a263c35 1540 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1541 }
MACRUM 0:276e7a263c35 1542
MACRUM 0:276e7a263c35 1543 void testNotEqualMemoryLengthZero(void)
MACRUM 0:276e7a263c35 1544 {
MACRUM 0:276e7a263c35 1545 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1546 TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0);
MACRUM 0:276e7a263c35 1547 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1548 }
MACRUM 0:276e7a263c35 1549
MACRUM 0:276e7a263c35 1550 void testEqualIntArrays(void)
MACRUM 0:276e7a263c35 1551 {
MACRUM 0:276e7a263c35 1552 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 1553 int p1[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 1554 int p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1555 int p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 1556
MACRUM 0:276e7a263c35 1557 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1558 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1559 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1560 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1561 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1562 TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1);
MACRUM 0:276e7a263c35 1563 }
MACRUM 0:276e7a263c35 1564
MACRUM 0:276e7a263c35 1565 void testNotEqualIntArraysNullExpected(void)
MACRUM 0:276e7a263c35 1566 {
MACRUM 0:276e7a263c35 1567 int* p0 = NULL;
MACRUM 0:276e7a263c35 1568 int p1[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1569
MACRUM 0:276e7a263c35 1570 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1571 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1572 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1573 }
MACRUM 0:276e7a263c35 1574
MACRUM 0:276e7a263c35 1575 void testNotEqualIntArraysNullActual(void)
MACRUM 0:276e7a263c35 1576 {
MACRUM 0:276e7a263c35 1577 int* p1 = NULL;
MACRUM 0:276e7a263c35 1578 int p0[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1579
MACRUM 0:276e7a263c35 1580 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1581 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1582 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1583 }
MACRUM 0:276e7a263c35 1584
MACRUM 0:276e7a263c35 1585 void testNotEqualIntArrays1(void)
MACRUM 0:276e7a263c35 1586 {
MACRUM 0:276e7a263c35 1587 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 1588 int p1[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1589
MACRUM 0:276e7a263c35 1590 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1591 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1592 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1593 }
MACRUM 0:276e7a263c35 1594
MACRUM 0:276e7a263c35 1595 void testNotEqualIntArrays2(void)
MACRUM 0:276e7a263c35 1596 {
MACRUM 0:276e7a263c35 1597 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 1598 int p1[] = {2, 8, 987, -2};
MACRUM 0:276e7a263c35 1599
MACRUM 0:276e7a263c35 1600 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1601 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1602 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1603 }
MACRUM 0:276e7a263c35 1604
MACRUM 0:276e7a263c35 1605 void testNotEqualIntArrays3(void)
MACRUM 0:276e7a263c35 1606 {
MACRUM 0:276e7a263c35 1607 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 1608 int p1[] = {1, 8, 986, -2};
MACRUM 0:276e7a263c35 1609
MACRUM 0:276e7a263c35 1610 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1611 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1612 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1613 }
MACRUM 0:276e7a263c35 1614
MACRUM 0:276e7a263c35 1615 void testNotEqualIntArraysLengthZero(void)
MACRUM 0:276e7a263c35 1616 {
MACRUM 0:276e7a263c35 1617 _UU32 p0[1] = {1};
MACRUM 0:276e7a263c35 1618 _UU32 p1[1] = {1};
MACRUM 0:276e7a263c35 1619
MACRUM 0:276e7a263c35 1620 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1621 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0);
MACRUM 0:276e7a263c35 1622 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1623 }
MACRUM 0:276e7a263c35 1624
MACRUM 0:276e7a263c35 1625 void testEqualPtrArrays(void)
MACRUM 0:276e7a263c35 1626 {
MACRUM 0:276e7a263c35 1627 char A = 1;
MACRUM 0:276e7a263c35 1628 char B = 2;
MACRUM 0:276e7a263c35 1629 char C = 3;
MACRUM 0:276e7a263c35 1630 char* p0[] = {&A, &B, &C};
MACRUM 0:276e7a263c35 1631 char* p1[] = {&A, &B, &C, &A};
MACRUM 0:276e7a263c35 1632 char* p2[] = {&A, &B};
MACRUM 0:276e7a263c35 1633 char* p3[] = {&A};
MACRUM 0:276e7a263c35 1634
MACRUM 0:276e7a263c35 1635 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1636 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 3);
MACRUM 0:276e7a263c35 1637 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 3);
MACRUM 0:276e7a263c35 1638 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p2, 2);
MACRUM 0:276e7a263c35 1639 TEST_ASSERT_EQUAL_PTR_ARRAY(p3, p0, 1);
MACRUM 0:276e7a263c35 1640 }
MACRUM 0:276e7a263c35 1641
MACRUM 0:276e7a263c35 1642 void testNotEqualPtrArraysNullExpected(void)
MACRUM 0:276e7a263c35 1643 {
MACRUM 0:276e7a263c35 1644 char A = 1;
MACRUM 0:276e7a263c35 1645 char B = 2;
MACRUM 0:276e7a263c35 1646 char** p0 = NULL;
MACRUM 0:276e7a263c35 1647 char* p1[] = {&A, &B};
MACRUM 0:276e7a263c35 1648
MACRUM 0:276e7a263c35 1649 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1650 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 2);
MACRUM 0:276e7a263c35 1651 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1652 }
MACRUM 0:276e7a263c35 1653
MACRUM 0:276e7a263c35 1654 void testNotEqualPtrArraysNullActual(void)
MACRUM 0:276e7a263c35 1655 {
MACRUM 0:276e7a263c35 1656 char A = 1;
MACRUM 0:276e7a263c35 1657 char B = 2;
MACRUM 0:276e7a263c35 1658 char** p0 = NULL;
MACRUM 0:276e7a263c35 1659 char* p1[] = {&A, &B};
MACRUM 0:276e7a263c35 1660
MACRUM 0:276e7a263c35 1661 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1662 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p0, 2);
MACRUM 0:276e7a263c35 1663 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1664 }
MACRUM 0:276e7a263c35 1665
MACRUM 0:276e7a263c35 1666 void testNotEqualPtrArrays1(void)
MACRUM 0:276e7a263c35 1667 {
MACRUM 0:276e7a263c35 1668 char A = 1;
MACRUM 0:276e7a263c35 1669 char B = 2;
MACRUM 0:276e7a263c35 1670 char C = 3;
MACRUM 0:276e7a263c35 1671 char* p0[] = {&A, &B, &C, &B};
MACRUM 0:276e7a263c35 1672 char* p1[] = {&A, &B, &C, &A};
MACRUM 0:276e7a263c35 1673
MACRUM 0:276e7a263c35 1674 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1675 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1676 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1677 }
MACRUM 0:276e7a263c35 1678
MACRUM 0:276e7a263c35 1679 void testNotEqualPtrArrays2(void)
MACRUM 0:276e7a263c35 1680 {
MACRUM 0:276e7a263c35 1681 char A = 1;
MACRUM 0:276e7a263c35 1682 char B = 2;
MACRUM 0:276e7a263c35 1683 char C = 3;
MACRUM 0:276e7a263c35 1684 char* p0[] = {&B, &B, &C, &A};
MACRUM 0:276e7a263c35 1685 char* p1[] = {&A, &B, &C, &A};
MACRUM 0:276e7a263c35 1686
MACRUM 0:276e7a263c35 1687 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1688 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1689 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1690 }
MACRUM 0:276e7a263c35 1691
MACRUM 0:276e7a263c35 1692 void testNotEqualPtrArrays3(void)
MACRUM 0:276e7a263c35 1693 {
MACRUM 0:276e7a263c35 1694 char A = 1;
MACRUM 0:276e7a263c35 1695 char B = 2;
MACRUM 0:276e7a263c35 1696 char C = 3;
MACRUM 0:276e7a263c35 1697 char* p0[] = {&A, &B, &B, &A};
MACRUM 0:276e7a263c35 1698 char* p1[] = {&A, &B, &C, &A};
MACRUM 0:276e7a263c35 1699
MACRUM 0:276e7a263c35 1700 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1701 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1702 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1703 }
MACRUM 0:276e7a263c35 1704
MACRUM 0:276e7a263c35 1705 void testEqualInt8Arrays(void)
MACRUM 0:276e7a263c35 1706 {
MACRUM 0:276e7a263c35 1707 _US8 p0[] = {1, 8, 117, -2};
MACRUM 0:276e7a263c35 1708 _US8 p1[] = {1, 8, 117, -2};
MACRUM 0:276e7a263c35 1709 _US8 p2[] = {1, 8, 117, 2};
MACRUM 0:276e7a263c35 1710 _US8 p3[] = {1, 50, 60, 70};
MACRUM 0:276e7a263c35 1711
MACRUM 0:276e7a263c35 1712 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1713 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1714 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1715 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1716 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1717 }
MACRUM 0:276e7a263c35 1718
MACRUM 0:276e7a263c35 1719 void testNotEqualInt8Arrays(void)
MACRUM 0:276e7a263c35 1720 {
MACRUM 0:276e7a263c35 1721 _US8 p0[] = {1, 8, 36, -2};
MACRUM 0:276e7a263c35 1722 _US8 p1[] = {1, 8, 36, 2};
MACRUM 0:276e7a263c35 1723
MACRUM 0:276e7a263c35 1724 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1725 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1726 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1727 }
MACRUM 0:276e7a263c35 1728
MACRUM 0:276e7a263c35 1729 void testEqualUIntArrays(void)
MACRUM 0:276e7a263c35 1730 {
MACRUM 0:276e7a263c35 1731 unsigned int p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1732 unsigned int p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1733 unsigned int p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1734 unsigned int p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 1735
MACRUM 0:276e7a263c35 1736 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1737 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1738 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1739 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1740 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1741 }
MACRUM 0:276e7a263c35 1742
MACRUM 0:276e7a263c35 1743 void testNotEqualUIntArrays1(void)
MACRUM 0:276e7a263c35 1744 {
MACRUM 0:276e7a263c35 1745 unsigned int p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1746 unsigned int p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 1747
MACRUM 0:276e7a263c35 1748 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1749 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1750 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1751 }
MACRUM 0:276e7a263c35 1752
MACRUM 0:276e7a263c35 1753 void testNotEqualUIntArrays2(void)
MACRUM 0:276e7a263c35 1754 {
MACRUM 0:276e7a263c35 1755 unsigned int p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1756 unsigned int p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1757
MACRUM 0:276e7a263c35 1758 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1759 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1760 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1761 }
MACRUM 0:276e7a263c35 1762
MACRUM 0:276e7a263c35 1763 void testNotEqualUIntArrays3(void)
MACRUM 0:276e7a263c35 1764 {
MACRUM 0:276e7a263c35 1765 unsigned int p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1766 unsigned int p1[] = {1, 8, 986, 65132u};
MACRUM 0:276e7a263c35 1767
MACRUM 0:276e7a263c35 1768 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1769 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1770 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1771 }
MACRUM 0:276e7a263c35 1772
MACRUM 0:276e7a263c35 1773 void testEqualInt16Arrays(void)
MACRUM 0:276e7a263c35 1774 {
MACRUM 0:276e7a263c35 1775 _US16 p0[] = {1, 8, 117, 3};
MACRUM 0:276e7a263c35 1776 _US16 p1[] = {1, 8, 117, 3};
MACRUM 0:276e7a263c35 1777 _US16 p2[] = {1, 8, 117, 2};
MACRUM 0:276e7a263c35 1778 _US16 p3[] = {1, 50, 60, 70};
MACRUM 0:276e7a263c35 1779
MACRUM 0:276e7a263c35 1780 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1781 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1782 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1783 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1784 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1785 }
MACRUM 0:276e7a263c35 1786
MACRUM 0:276e7a263c35 1787 void testNotEqualInt16Arrays(void)
MACRUM 0:276e7a263c35 1788 {
MACRUM 0:276e7a263c35 1789 _US16 p0[] = {1, 8, 127, 3};
MACRUM 0:276e7a263c35 1790 _US16 p1[] = {1, 8, 127, 2};
MACRUM 0:276e7a263c35 1791
MACRUM 0:276e7a263c35 1792 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1793 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1794 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1795 }
MACRUM 0:276e7a263c35 1796
MACRUM 0:276e7a263c35 1797 void testEqualInt32Arrays(void)
MACRUM 0:276e7a263c35 1798 {
MACRUM 0:276e7a263c35 1799 _US32 p0[] = {1, 8, 117, 3};
MACRUM 0:276e7a263c35 1800 _US32 p1[] = {1, 8, 117, 3};
MACRUM 0:276e7a263c35 1801 _US32 p2[] = {1, 8, 117, 2};
MACRUM 0:276e7a263c35 1802 _US32 p3[] = {1, 50, 60, 70};
MACRUM 0:276e7a263c35 1803
MACRUM 0:276e7a263c35 1804 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1805 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1806 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1807 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1808 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1809 }
MACRUM 0:276e7a263c35 1810
MACRUM 0:276e7a263c35 1811 void testNotEqualInt32Arrays(void)
MACRUM 0:276e7a263c35 1812 {
MACRUM 0:276e7a263c35 1813 _US32 p0[] = {1, 8, 127, 3};
MACRUM 0:276e7a263c35 1814 _US32 p1[] = {1, 8, 127, 2};
MACRUM 0:276e7a263c35 1815
MACRUM 0:276e7a263c35 1816 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1817 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1818 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1819 }
MACRUM 0:276e7a263c35 1820
MACRUM 0:276e7a263c35 1821 void testEqualUINT8Arrays(void)
MACRUM 0:276e7a263c35 1822 {
MACRUM 0:276e7a263c35 1823 _UU8 p0[] = {1, 8, 100, 127};
MACRUM 0:276e7a263c35 1824 _UU8 p1[] = {1, 8, 100, 127};
MACRUM 0:276e7a263c35 1825 _UU8 p2[] = {1, 8, 100, 2};
MACRUM 0:276e7a263c35 1826 _UU8 p3[] = {1, 50, 60, 70};
MACRUM 0:276e7a263c35 1827
MACRUM 0:276e7a263c35 1828 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1829 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1830 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1831 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1832 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1833 }
MACRUM 0:276e7a263c35 1834
MACRUM 0:276e7a263c35 1835 void testNotEqualUINT8Arrays1(void)
MACRUM 0:276e7a263c35 1836 {
MACRUM 0:276e7a263c35 1837 unsigned char p0[] = {1, 8, 100, 127u};
MACRUM 0:276e7a263c35 1838 unsigned char p1[] = {1, 8, 100, 255u};
MACRUM 0:276e7a263c35 1839
MACRUM 0:276e7a263c35 1840 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1841 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1842 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1843 }
MACRUM 0:276e7a263c35 1844
MACRUM 0:276e7a263c35 1845 void testNotEqualUINT8Arrays2(void)
MACRUM 0:276e7a263c35 1846 {
MACRUM 0:276e7a263c35 1847 unsigned char p0[] = {1, 8, 100, 127u};
MACRUM 0:276e7a263c35 1848 unsigned char p1[] = {1, 8, 100, 255u};
MACRUM 0:276e7a263c35 1849
MACRUM 0:276e7a263c35 1850 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1851 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1852 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1853 }
MACRUM 0:276e7a263c35 1854
MACRUM 0:276e7a263c35 1855 void testNotEqualUINT8Arrays3(void)
MACRUM 0:276e7a263c35 1856 {
MACRUM 0:276e7a263c35 1857 unsigned char p0[] = {1, 8, 100, 127u};
MACRUM 0:276e7a263c35 1858 unsigned char p1[] = {1, 8, 100, 255u};
MACRUM 0:276e7a263c35 1859
MACRUM 0:276e7a263c35 1860 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1861 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1862 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1863 }
MACRUM 0:276e7a263c35 1864
MACRUM 0:276e7a263c35 1865
MACRUM 0:276e7a263c35 1866 void testEqualUINT16Arrays(void)
MACRUM 0:276e7a263c35 1867 {
MACRUM 0:276e7a263c35 1868 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1869 unsigned short p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1870 unsigned short p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1871 unsigned short p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 1872
MACRUM 0:276e7a263c35 1873 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1874 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1875 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1876 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1877 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1878 }
MACRUM 0:276e7a263c35 1879
MACRUM 0:276e7a263c35 1880 void testNotEqualUINT16Arrays1(void)
MACRUM 0:276e7a263c35 1881 {
MACRUM 0:276e7a263c35 1882 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1883 unsigned short p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 1884
MACRUM 0:276e7a263c35 1885 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1886 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1887 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1888 }
MACRUM 0:276e7a263c35 1889
MACRUM 0:276e7a263c35 1890 void testNotEqualUINT16Arrays2(void)
MACRUM 0:276e7a263c35 1891 {
MACRUM 0:276e7a263c35 1892 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1893 unsigned short p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1894
MACRUM 0:276e7a263c35 1895 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1896 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1897 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1898 }
MACRUM 0:276e7a263c35 1899
MACRUM 0:276e7a263c35 1900 void testNotEqualUINT16Arrays3(void)
MACRUM 0:276e7a263c35 1901 {
MACRUM 0:276e7a263c35 1902 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1903 unsigned short p1[] = {1, 8, 986, 65132u};
MACRUM 0:276e7a263c35 1904
MACRUM 0:276e7a263c35 1905 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1906 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1907 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1908 }
MACRUM 0:276e7a263c35 1909
MACRUM 0:276e7a263c35 1910 void testEqualUINT32Arrays(void)
MACRUM 0:276e7a263c35 1911 {
MACRUM 0:276e7a263c35 1912 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1913 _UU32 p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1914 _UU32 p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1915 _UU32 p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 1916
MACRUM 0:276e7a263c35 1917 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1918 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1919 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1920 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1921 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1922 }
MACRUM 0:276e7a263c35 1923
MACRUM 0:276e7a263c35 1924 void testNotEqualUINT32Arrays1(void)
MACRUM 0:276e7a263c35 1925 {
MACRUM 0:276e7a263c35 1926 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1927 _UU32 p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 1928
MACRUM 0:276e7a263c35 1929 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1930 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1931 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1932 }
MACRUM 0:276e7a263c35 1933
MACRUM 0:276e7a263c35 1934 void testNotEqualUINT32Arrays2(void)
MACRUM 0:276e7a263c35 1935 {
MACRUM 0:276e7a263c35 1936 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1937 _UU32 p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1938
MACRUM 0:276e7a263c35 1939 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1940 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1941 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1942 }
MACRUM 0:276e7a263c35 1943
MACRUM 0:276e7a263c35 1944 void testNotEqualUINT32Arrays3(void)
MACRUM 0:276e7a263c35 1945 {
MACRUM 0:276e7a263c35 1946 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1947 _UU32 p1[] = {1, 8, 986, 65132u};
MACRUM 0:276e7a263c35 1948
MACRUM 0:276e7a263c35 1949 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1950 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1951 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1952 }
MACRUM 0:276e7a263c35 1953
MACRUM 0:276e7a263c35 1954 void testEqualHEXArrays(void)
MACRUM 0:276e7a263c35 1955 {
MACRUM 0:276e7a263c35 1956 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1957 _UU32 p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1958 _UU32 p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 1959 _UU32 p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 1960
MACRUM 0:276e7a263c35 1961 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 1962 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 1963 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1964 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 1965 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 1966 }
MACRUM 0:276e7a263c35 1967
MACRUM 0:276e7a263c35 1968 void testNotEqualHEXArrays1(void)
MACRUM 0:276e7a263c35 1969 {
MACRUM 0:276e7a263c35 1970 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1971 _UU32 p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 1972
MACRUM 0:276e7a263c35 1973 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1974 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1975 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1976 }
MACRUM 0:276e7a263c35 1977
MACRUM 0:276e7a263c35 1978 void testNotEqualHEXArrays2(void)
MACRUM 0:276e7a263c35 1979 {
MACRUM 0:276e7a263c35 1980 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1981 _UU32 p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1982
MACRUM 0:276e7a263c35 1983 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1984 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1985 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1986 }
MACRUM 0:276e7a263c35 1987
MACRUM 0:276e7a263c35 1988 void testNotEqualHEXArrays3(void)
MACRUM 0:276e7a263c35 1989 {
MACRUM 0:276e7a263c35 1990 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 1991 _UU32 p1[] = {1, 8, 986, 65132u};
MACRUM 0:276e7a263c35 1992
MACRUM 0:276e7a263c35 1993 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 1994 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 1995 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 1996 }
MACRUM 0:276e7a263c35 1997
MACRUM 0:276e7a263c35 1998 void testEqualHEX32Arrays(void)
MACRUM 0:276e7a263c35 1999 {
MACRUM 0:276e7a263c35 2000 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2001 _UU32 p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2002 _UU32 p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2003 _UU32 p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 2004
MACRUM 0:276e7a263c35 2005 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 2006 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 2007 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2008 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 2009 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 2010 }
MACRUM 0:276e7a263c35 2011
MACRUM 0:276e7a263c35 2012 void testNotEqualHEX32Arrays1(void)
MACRUM 0:276e7a263c35 2013 {
MACRUM 0:276e7a263c35 2014 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2015 _UU32 p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 2016
MACRUM 0:276e7a263c35 2017 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2018 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2019 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2020 }
MACRUM 0:276e7a263c35 2021
MACRUM 0:276e7a263c35 2022 void testNotEqualHEX32Arrays2(void)
MACRUM 0:276e7a263c35 2023 {
MACRUM 0:276e7a263c35 2024 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2025 _UU32 p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2026
MACRUM 0:276e7a263c35 2027 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2028 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2029 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2030 }
MACRUM 0:276e7a263c35 2031
MACRUM 0:276e7a263c35 2032 void testNotEqualHEX32Arrays3(void)
MACRUM 0:276e7a263c35 2033 {
MACRUM 0:276e7a263c35 2034 _UU32 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2035 _UU32 p1[] = {1, 8, 986, 65132u};
MACRUM 0:276e7a263c35 2036
MACRUM 0:276e7a263c35 2037 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2038 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2039 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2040 }
MACRUM 0:276e7a263c35 2041
MACRUM 0:276e7a263c35 2042 void testEqualHEX16Arrays(void)
MACRUM 0:276e7a263c35 2043 {
MACRUM 0:276e7a263c35 2044 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2045 unsigned short p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2046 unsigned short p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2047 unsigned short p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 2048
MACRUM 0:276e7a263c35 2049 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 2050 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 2051 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2052 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 2053 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 2054 }
MACRUM 0:276e7a263c35 2055
MACRUM 0:276e7a263c35 2056 void testNotEqualHEX16Arrays1(void)
MACRUM 0:276e7a263c35 2057 {
MACRUM 0:276e7a263c35 2058 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2059 unsigned short p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 2060
MACRUM 0:276e7a263c35 2061 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2062 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2063 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2064 }
MACRUM 0:276e7a263c35 2065
MACRUM 0:276e7a263c35 2066 void testNotEqualHEX16Arrays2(void)
MACRUM 0:276e7a263c35 2067 {
MACRUM 0:276e7a263c35 2068 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2069 unsigned short p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2070
MACRUM 0:276e7a263c35 2071 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2072 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2073 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2074 }
MACRUM 0:276e7a263c35 2075
MACRUM 0:276e7a263c35 2076 void testNotEqualHEX16Arrays3(void)
MACRUM 0:276e7a263c35 2077 {
MACRUM 0:276e7a263c35 2078 unsigned short p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2079 unsigned short p1[] = {1, 8, 986, 65132u};
MACRUM 0:276e7a263c35 2080
MACRUM 0:276e7a263c35 2081 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2082 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2083 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2084 }
MACRUM 0:276e7a263c35 2085
MACRUM 0:276e7a263c35 2086 void testEqualHEX8Arrays(void)
MACRUM 0:276e7a263c35 2087 {
MACRUM 0:276e7a263c35 2088 unsigned short p0[] = {1, 8, 254u, 123};
MACRUM 0:276e7a263c35 2089 unsigned short p1[] = {1, 8, 254u, 123};
MACRUM 0:276e7a263c35 2090 unsigned short p2[] = {1, 8, 254u, 2};
MACRUM 0:276e7a263c35 2091 unsigned short p3[] = {1, 23, 25, 26};
MACRUM 0:276e7a263c35 2092
MACRUM 0:276e7a263c35 2093 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 2094 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 2095 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2096 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 2097 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 2098 }
MACRUM 0:276e7a263c35 2099
MACRUM 0:276e7a263c35 2100 void testNotEqualHEX8Arrays1(void)
MACRUM 0:276e7a263c35 2101 {
MACRUM 0:276e7a263c35 2102 unsigned char p0[] = {1, 8, 254u, 253u};
MACRUM 0:276e7a263c35 2103 unsigned char p1[] = {1, 8, 254u, 252u};
MACRUM 0:276e7a263c35 2104
MACRUM 0:276e7a263c35 2105 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2106 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2107 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2108 }
MACRUM 0:276e7a263c35 2109
MACRUM 0:276e7a263c35 2110 void testNotEqualHEX8Arrays2(void)
MACRUM 0:276e7a263c35 2111 {
MACRUM 0:276e7a263c35 2112 unsigned char p0[] = {1, 8, 254u, 253u};
MACRUM 0:276e7a263c35 2113 unsigned char p1[] = {2, 8, 254u, 253u};
MACRUM 0:276e7a263c35 2114
MACRUM 0:276e7a263c35 2115 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2116 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2117 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2118 }
MACRUM 0:276e7a263c35 2119
MACRUM 0:276e7a263c35 2120 void testNotEqualHEX8Arrays3(void)
MACRUM 0:276e7a263c35 2121 {
MACRUM 0:276e7a263c35 2122 unsigned char p0[] = {1, 8, 254u, 253u};
MACRUM 0:276e7a263c35 2123 unsigned char p1[] = {1, 8, 255u, 253u};
MACRUM 0:276e7a263c35 2124
MACRUM 0:276e7a263c35 2125 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2126 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2127 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2128 }
MACRUM 0:276e7a263c35 2129
MACRUM 0:276e7a263c35 2130 void testEqualMemoryArrays(void)
MACRUM 0:276e7a263c35 2131 {
MACRUM 0:276e7a263c35 2132 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2133 int p1[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2134 int p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2135 int p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 2136
MACRUM 0:276e7a263c35 2137 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 1);
MACRUM 0:276e7a263c35 2138 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 4);
MACRUM 0:276e7a263c35 2139 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
MACRUM 0:276e7a263c35 2140 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, sizeof(int), 3);
MACRUM 0:276e7a263c35 2141 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, sizeof(int), 1);
MACRUM 0:276e7a263c35 2142 }
MACRUM 0:276e7a263c35 2143
MACRUM 0:276e7a263c35 2144 void testNotEqualMemoryArraysExpectedNull(void)
MACRUM 0:276e7a263c35 2145 {
MACRUM 0:276e7a263c35 2146 int* p0 = NULL;
MACRUM 0:276e7a263c35 2147 int p1[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2148
MACRUM 0:276e7a263c35 2149 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2150 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
MACRUM 0:276e7a263c35 2151 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2152 }
MACRUM 0:276e7a263c35 2153
MACRUM 0:276e7a263c35 2154 void testNotEqualMemoryArraysActualNull(void)
MACRUM 0:276e7a263c35 2155 {
MACRUM 0:276e7a263c35 2156 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2157 int* p1 = NULL;
MACRUM 0:276e7a263c35 2158
MACRUM 0:276e7a263c35 2159 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2160 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
MACRUM 0:276e7a263c35 2161 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2162 }
MACRUM 0:276e7a263c35 2163
MACRUM 0:276e7a263c35 2164 void testNotEqualMemoryArrays1(void)
MACRUM 0:276e7a263c35 2165 {
MACRUM 0:276e7a263c35 2166 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2167 int p1[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2168
MACRUM 0:276e7a263c35 2169 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2170 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
MACRUM 0:276e7a263c35 2171 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2172 }
MACRUM 0:276e7a263c35 2173
MACRUM 0:276e7a263c35 2174 void testNotEqualMemoryArrays2(void)
MACRUM 0:276e7a263c35 2175 {
MACRUM 0:276e7a263c35 2176 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2177 int p1[] = {2, 8, 987, -2};
MACRUM 0:276e7a263c35 2178
MACRUM 0:276e7a263c35 2179 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2180 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
MACRUM 0:276e7a263c35 2181 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2182 }
MACRUM 0:276e7a263c35 2183
MACRUM 0:276e7a263c35 2184 void testNotEqualMemoryArrays3(void)
MACRUM 0:276e7a263c35 2185 {
MACRUM 0:276e7a263c35 2186 int p0[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2187 int p1[] = {1, 8, 986, -2};
MACRUM 0:276e7a263c35 2188
MACRUM 0:276e7a263c35 2189 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2190 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
MACRUM 0:276e7a263c35 2191 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2192 }
MACRUM 0:276e7a263c35 2193
MACRUM 0:276e7a263c35 2194 void testProtection(void)
MACRUM 0:276e7a263c35 2195 {
MACRUM 0:276e7a263c35 2196 volatile int mask = 0;
MACRUM 0:276e7a263c35 2197
MACRUM 0:276e7a263c35 2198 if (TEST_PROTECT())
MACRUM 0:276e7a263c35 2199 {
MACRUM 0:276e7a263c35 2200 mask |= 1;
MACRUM 0:276e7a263c35 2201 TEST_ABORT();
MACRUM 0:276e7a263c35 2202 }
MACRUM 0:276e7a263c35 2203 else
MACRUM 0:276e7a263c35 2204 {
MACRUM 0:276e7a263c35 2205 Unity.CurrentTestFailed = 0;
MACRUM 0:276e7a263c35 2206 mask |= 2;
MACRUM 0:276e7a263c35 2207 }
MACRUM 0:276e7a263c35 2208
MACRUM 0:276e7a263c35 2209 TEST_ASSERT_EQUAL(3, mask);
MACRUM 0:276e7a263c35 2210 }
MACRUM 0:276e7a263c35 2211
MACRUM 0:276e7a263c35 2212 void testIgnoredAndThenFailInTearDown(void)
MACRUM 0:276e7a263c35 2213 {
MACRUM 0:276e7a263c35 2214 SetToOneToFailInTearDown = 1;
MACRUM 0:276e7a263c35 2215 TEST_IGNORE();
MACRUM 0:276e7a263c35 2216 }
MACRUM 0:276e7a263c35 2217
MACRUM 0:276e7a263c35 2218 // Tricky series of macros to set USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2219 #define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
MACRUM 0:276e7a263c35 2220 #define ASSIGN_VALUE(a) VAL_##a
MACRUM 0:276e7a263c35 2221 #define VAL_putcharSpy 0, 1
MACRUM 0:276e7a263c35 2222 #define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway)
MACRUM 0:276e7a263c35 2223 #define SECOND_PARAM(a, b, ...) b
MACRUM 0:276e7a263c35 2224 #if USING_SPY_AS(UNITY_OUTPUT_CHAR)
MACRUM 0:276e7a263c35 2225 #define USING_OUTPUT_SPY // true only if UNITY_OUTPUT_CHAR = putcharSpy
MACRUM 0:276e7a263c35 2226 #endif
MACRUM 0:276e7a263c35 2227
MACRUM 0:276e7a263c35 2228 #ifdef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2229 #include <stdio.h>
MACRUM 0:276e7a263c35 2230 #define SPY_BUFFER_MAX 40
MACRUM 0:276e7a263c35 2231 static char putcharSpyBuffer[SPY_BUFFER_MAX];
MACRUM 0:276e7a263c35 2232 #endif
MACRUM 0:276e7a263c35 2233 static int indexSpyBuffer;
MACRUM 0:276e7a263c35 2234 static int putcharSpyEnabled;
MACRUM 0:276e7a263c35 2235
MACRUM 0:276e7a263c35 2236 void startPutcharSpy(void) {indexSpyBuffer = 0; putcharSpyEnabled = 1;}
MACRUM 0:276e7a263c35 2237
MACRUM 0:276e7a263c35 2238 void endPutcharSpy(void) {putcharSpyEnabled = 0;}
MACRUM 0:276e7a263c35 2239
MACRUM 0:276e7a263c35 2240 char* getBufferPutcharSpy(void)
MACRUM 0:276e7a263c35 2241 {
MACRUM 0:276e7a263c35 2242 #ifdef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2243 putcharSpyBuffer[indexSpyBuffer] = '\0';
MACRUM 0:276e7a263c35 2244 return putcharSpyBuffer;
MACRUM 0:276e7a263c35 2245 #else
MACRUM 0:276e7a263c35 2246 return NULL;
MACRUM 0:276e7a263c35 2247 #endif
MACRUM 0:276e7a263c35 2248 }
MACRUM 0:276e7a263c35 2249
MACRUM 0:276e7a263c35 2250 void putcharSpy(int c)
MACRUM 0:276e7a263c35 2251 {
MACRUM 0:276e7a263c35 2252 #ifdef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2253 if (putcharSpyEnabled)
MACRUM 0:276e7a263c35 2254 {
MACRUM 0:276e7a263c35 2255 if (indexSpyBuffer < SPY_BUFFER_MAX - 1)
MACRUM 0:276e7a263c35 2256 putcharSpyBuffer[indexSpyBuffer++] = (char)c;
MACRUM 0:276e7a263c35 2257 } else
MACRUM 0:276e7a263c35 2258 c = putchar(c);
MACRUM 0:276e7a263c35 2259 #endif
MACRUM 0:276e7a263c35 2260 }
MACRUM 0:276e7a263c35 2261
MACRUM 0:276e7a263c35 2262 void testFailureCountIncrementsAndIsReturnedAtEnd(void)
MACRUM 0:276e7a263c35 2263 {
MACRUM 0:276e7a263c35 2264 Unity.CurrentTestFailed = 1;
MACRUM 0:276e7a263c35 2265 startPutcharSpy(); // Suppress output
MACRUM 0:276e7a263c35 2266 UnityConcludeTest();
MACRUM 0:276e7a263c35 2267 TEST_ASSERT_EQUAL(1, Unity.TestFailures);
MACRUM 0:276e7a263c35 2268
MACRUM 0:276e7a263c35 2269 int failures = UnityEnd();
MACRUM 0:276e7a263c35 2270 Unity.TestFailures--;
MACRUM 0:276e7a263c35 2271 endPutcharSpy();
MACRUM 0:276e7a263c35 2272 TEST_ASSERT_EQUAL(1, failures);
MACRUM 0:276e7a263c35 2273 }
MACRUM 0:276e7a263c35 2274
MACRUM 0:276e7a263c35 2275 #define TEST_ASSERT_EQUAL_PRINT_NUMBERS(expected, actual) { \
MACRUM 0:276e7a263c35 2276 startPutcharSpy(); UnityPrintNumber((actual)); endPutcharSpy(); \
MACRUM 0:276e7a263c35 2277 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \
MACRUM 0:276e7a263c35 2278 }
MACRUM 0:276e7a263c35 2279
MACRUM 0:276e7a263c35 2280 #define TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS(expected, actual) { \
MACRUM 0:276e7a263c35 2281 startPutcharSpy(); UnityPrintNumberUnsigned((actual)); endPutcharSpy(); \
MACRUM 0:276e7a263c35 2282 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \
MACRUM 0:276e7a263c35 2283 }
MACRUM 0:276e7a263c35 2284
MACRUM 0:276e7a263c35 2285 void testPrintNumbers32(void)
MACRUM 0:276e7a263c35 2286 {
MACRUM 0:276e7a263c35 2287 #ifndef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2288 TEST_IGNORE_MESSAGE("Compile with '-D UNITY_OUTPUT_CHAR=putcharSpy' to enable print testing");
MACRUM 0:276e7a263c35 2289 #else
MACRUM 0:276e7a263c35 2290 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0);
MACRUM 0:276e7a263c35 2291 TEST_ASSERT_EQUAL_PRINT_NUMBERS("1", 1);
MACRUM 0:276e7a263c35 2292 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", -1);
MACRUM 0:276e7a263c35 2293 TEST_ASSERT_EQUAL_PRINT_NUMBERS("2000000000", 2000000000);
MACRUM 0:276e7a263c35 2294 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-2147483648", (_US32)0x80000000);
MACRUM 0:276e7a263c35 2295 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (_US32)0xFFFFFFFF);
MACRUM 0:276e7a263c35 2296 #endif
MACRUM 0:276e7a263c35 2297 }
MACRUM 0:276e7a263c35 2298
MACRUM 0:276e7a263c35 2299 void testPrintNumbersUnsigned32(void)
MACRUM 0:276e7a263c35 2300 {
MACRUM 0:276e7a263c35 2301 #ifndef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2302 TEST_IGNORE();
MACRUM 0:276e7a263c35 2303 #else
MACRUM 0:276e7a263c35 2304 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0);
MACRUM 0:276e7a263c35 2305 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1", 1);
MACRUM 0:276e7a263c35 2306 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1500000000", 1500000000);
MACRUM 0:276e7a263c35 2307 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("2147483648", (_UU32)0x80000000);
MACRUM 0:276e7a263c35 2308 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("4294967295", (_UU32)0xFFFFFFFF);
MACRUM 0:276e7a263c35 2309 #endif
MACRUM 0:276e7a263c35 2310 }
MACRUM 0:276e7a263c35 2311
MACRUM 0:276e7a263c35 2312 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES 64 BIT SUPPORT ==================
MACRUM 0:276e7a263c35 2313
MACRUM 0:276e7a263c35 2314 void testPrintNumbersInt64(void)
MACRUM 0:276e7a263c35 2315 {
MACRUM 0:276e7a263c35 2316 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2317 TEST_IGNORE();
MACRUM 0:276e7a263c35 2318 #else
MACRUM 0:276e7a263c35 2319 #ifndef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2320 TEST_IGNORE();
MACRUM 0:276e7a263c35 2321 #else
MACRUM 0:276e7a263c35 2322 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0);
MACRUM 0:276e7a263c35 2323 TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000);
MACRUM 0:276e7a263c35 2324 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (_U_SINT)0x8000000000000000);
MACRUM 0:276e7a263c35 2325 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (_U_SINT)0xFFFFFFFFFFFFFFFF);
MACRUM 0:276e7a263c35 2326 #endif
MACRUM 0:276e7a263c35 2327 #endif
MACRUM 0:276e7a263c35 2328 }
MACRUM 0:276e7a263c35 2329
MACRUM 0:276e7a263c35 2330 void testPrintNumbersUInt64(void)
MACRUM 0:276e7a263c35 2331 {
MACRUM 0:276e7a263c35 2332 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2333 TEST_IGNORE();
MACRUM 0:276e7a263c35 2334 #else
MACRUM 0:276e7a263c35 2335 #ifndef USING_OUTPUT_SPY
MACRUM 0:276e7a263c35 2336 TEST_IGNORE();
MACRUM 0:276e7a263c35 2337 #else
MACRUM 0:276e7a263c35 2338 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0);
MACRUM 0:276e7a263c35 2339 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000);
MACRUM 0:276e7a263c35 2340 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808", (_U_UINT)0x8000000000000000);
MACRUM 0:276e7a263c35 2341 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (_U_UINT)0xFFFFFFFFFFFFFFFF);
MACRUM 0:276e7a263c35 2342 #endif
MACRUM 0:276e7a263c35 2343 #endif
MACRUM 0:276e7a263c35 2344 }
MACRUM 0:276e7a263c35 2345
MACRUM 0:276e7a263c35 2346 void testEqualHex64s(void)
MACRUM 0:276e7a263c35 2347 {
MACRUM 0:276e7a263c35 2348 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2349 TEST_IGNORE();
MACRUM 0:276e7a263c35 2350 #else
MACRUM 0:276e7a263c35 2351 _UU64 v0, v1;
MACRUM 0:276e7a263c35 2352 _UU64 *p0, *p1;
MACRUM 0:276e7a263c35 2353
MACRUM 0:276e7a263c35 2354 v0 = 0x9876543201234567;
MACRUM 0:276e7a263c35 2355 v1 = 0x9876543201234567;
MACRUM 0:276e7a263c35 2356 p0 = &v0;
MACRUM 0:276e7a263c35 2357 p1 = &v1;
MACRUM 0:276e7a263c35 2358
MACRUM 0:276e7a263c35 2359 TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567);
MACRUM 0:276e7a263c35 2360 TEST_ASSERT_EQUAL_HEX64(v0, v1);
MACRUM 0:276e7a263c35 2361 TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1);
MACRUM 0:276e7a263c35 2362 TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567);
MACRUM 0:276e7a263c35 2363 TEST_ASSERT_EQUAL_HEX64(*p0, v1);
MACRUM 0:276e7a263c35 2364 TEST_ASSERT_EQUAL_HEX64(*p0, *p1);
MACRUM 0:276e7a263c35 2365 TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567);
MACRUM 0:276e7a263c35 2366 #endif
MACRUM 0:276e7a263c35 2367 }
MACRUM 0:276e7a263c35 2368
MACRUM 0:276e7a263c35 2369 void testEqualUint64s(void)
MACRUM 0:276e7a263c35 2370 {
MACRUM 0:276e7a263c35 2371 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2372 TEST_IGNORE();
MACRUM 0:276e7a263c35 2373 #else
MACRUM 0:276e7a263c35 2374 _UU64 v0, v1;
MACRUM 0:276e7a263c35 2375 _UU64 *p0, *p1;
MACRUM 0:276e7a263c35 2376
MACRUM 0:276e7a263c35 2377 v0 = 0x9876543201234567;
MACRUM 0:276e7a263c35 2378 v1 = 0x9876543201234567;
MACRUM 0:276e7a263c35 2379 p0 = &v0;
MACRUM 0:276e7a263c35 2380 p1 = &v1;
MACRUM 0:276e7a263c35 2381
MACRUM 0:276e7a263c35 2382 TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567);
MACRUM 0:276e7a263c35 2383 TEST_ASSERT_EQUAL_UINT64(v0, v1);
MACRUM 0:276e7a263c35 2384 TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1);
MACRUM 0:276e7a263c35 2385 TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567);
MACRUM 0:276e7a263c35 2386 TEST_ASSERT_EQUAL_UINT64(*p0, v1);
MACRUM 0:276e7a263c35 2387 TEST_ASSERT_EQUAL_UINT64(*p0, *p1);
MACRUM 0:276e7a263c35 2388 TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567);
MACRUM 0:276e7a263c35 2389 #endif
MACRUM 0:276e7a263c35 2390 }
MACRUM 0:276e7a263c35 2391
MACRUM 0:276e7a263c35 2392 void testEqualInt64s(void)
MACRUM 0:276e7a263c35 2393 {
MACRUM 0:276e7a263c35 2394 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2395 TEST_IGNORE();
MACRUM 0:276e7a263c35 2396 #else
MACRUM 0:276e7a263c35 2397 _US64 v0, v1;
MACRUM 0:276e7a263c35 2398 _US64 *p0, *p1;
MACRUM 0:276e7a263c35 2399
MACRUM 0:276e7a263c35 2400 v0 = (_US64)0x9876543201234567;
MACRUM 0:276e7a263c35 2401 v1 = (_US64)0x9876543201234567;
MACRUM 0:276e7a263c35 2402 p0 = &v0;
MACRUM 0:276e7a263c35 2403 p1 = &v1;
MACRUM 0:276e7a263c35 2404
MACRUM 0:276e7a263c35 2405 TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567);
MACRUM 0:276e7a263c35 2406 TEST_ASSERT_EQUAL_INT64(v0, v1);
MACRUM 0:276e7a263c35 2407 TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1);
MACRUM 0:276e7a263c35 2408 TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567);
MACRUM 0:276e7a263c35 2409 TEST_ASSERT_EQUAL_INT64(*p0, v1);
MACRUM 0:276e7a263c35 2410 TEST_ASSERT_EQUAL_INT64(*p0, *p1);
MACRUM 0:276e7a263c35 2411 TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567);
MACRUM 0:276e7a263c35 2412 #endif
MACRUM 0:276e7a263c35 2413 }
MACRUM 0:276e7a263c35 2414
MACRUM 0:276e7a263c35 2415
MACRUM 0:276e7a263c35 2416 void testNotEqualHex64s(void)
MACRUM 0:276e7a263c35 2417 {
MACRUM 0:276e7a263c35 2418 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2419 TEST_IGNORE();
MACRUM 0:276e7a263c35 2420 #else
MACRUM 0:276e7a263c35 2421 _UU64 v0, v1;
MACRUM 0:276e7a263c35 2422
MACRUM 0:276e7a263c35 2423 v0 = 9000000000;
MACRUM 0:276e7a263c35 2424 v1 = 9100000000;
MACRUM 0:276e7a263c35 2425
MACRUM 0:276e7a263c35 2426 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2427 TEST_ASSERT_EQUAL_HEX64(v0, v1);
MACRUM 0:276e7a263c35 2428 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2429 #endif
MACRUM 0:276e7a263c35 2430 }
MACRUM 0:276e7a263c35 2431
MACRUM 0:276e7a263c35 2432 void testNotEqualUint64s(void)
MACRUM 0:276e7a263c35 2433 {
MACRUM 0:276e7a263c35 2434 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2435 TEST_IGNORE();
MACRUM 0:276e7a263c35 2436 #else
MACRUM 0:276e7a263c35 2437 _UU64 v0, v1;
MACRUM 0:276e7a263c35 2438
MACRUM 0:276e7a263c35 2439 v0 = 9000000000;
MACRUM 0:276e7a263c35 2440 v1 = 9100000000;
MACRUM 0:276e7a263c35 2441
MACRUM 0:276e7a263c35 2442 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2443 TEST_ASSERT_EQUAL_UINT64(v0, v1);
MACRUM 0:276e7a263c35 2444 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2445 #endif
MACRUM 0:276e7a263c35 2446 }
MACRUM 0:276e7a263c35 2447
MACRUM 0:276e7a263c35 2448 void testNotEqualInt64s(void)
MACRUM 0:276e7a263c35 2449 {
MACRUM 0:276e7a263c35 2450 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2451 TEST_IGNORE();
MACRUM 0:276e7a263c35 2452 #else
MACRUM 0:276e7a263c35 2453 _US64 v0, v1;
MACRUM 0:276e7a263c35 2454
MACRUM 0:276e7a263c35 2455 v0 = -9000000000;
MACRUM 0:276e7a263c35 2456 v1 = 9100000000;
MACRUM 0:276e7a263c35 2457
MACRUM 0:276e7a263c35 2458 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2459 TEST_ASSERT_EQUAL_INT64(v0, v1);
MACRUM 0:276e7a263c35 2460 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2461 #endif
MACRUM 0:276e7a263c35 2462 }
MACRUM 0:276e7a263c35 2463
MACRUM 0:276e7a263c35 2464 void testNotEqualHex64sIfSigned(void)
MACRUM 0:276e7a263c35 2465 {
MACRUM 0:276e7a263c35 2466 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2467 TEST_IGNORE();
MACRUM 0:276e7a263c35 2468 #else
MACRUM 0:276e7a263c35 2469 _US64 v0, v1;
MACRUM 0:276e7a263c35 2470
MACRUM 0:276e7a263c35 2471 v0 = -9000000000;
MACRUM 0:276e7a263c35 2472 v1 = 9000000000;
MACRUM 0:276e7a263c35 2473
MACRUM 0:276e7a263c35 2474 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2475 TEST_ASSERT_EQUAL_HEX64(v0, v1);
MACRUM 0:276e7a263c35 2476 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2477 #endif
MACRUM 0:276e7a263c35 2478 }
MACRUM 0:276e7a263c35 2479
MACRUM 0:276e7a263c35 2480 void testHEX64sWithinDelta(void)
MACRUM 0:276e7a263c35 2481 {
MACRUM 0:276e7a263c35 2482 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2483 TEST_IGNORE();
MACRUM 0:276e7a263c35 2484 #else
MACRUM 0:276e7a263c35 2485 TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
MACRUM 0:276e7a263c35 2486 TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 2487 TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 2488 #endif
MACRUM 0:276e7a263c35 2489 }
MACRUM 0:276e7a263c35 2490
MACRUM 0:276e7a263c35 2491 void testHEX64sNotWithinDelta(void)
MACRUM 0:276e7a263c35 2492 {
MACRUM 0:276e7a263c35 2493 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2494 TEST_IGNORE();
MACRUM 0:276e7a263c35 2495 #else
MACRUM 0:276e7a263c35 2496 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2497 TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
MACRUM 0:276e7a263c35 2498 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2499 #endif
MACRUM 0:276e7a263c35 2500 }
MACRUM 0:276e7a263c35 2501
MACRUM 0:276e7a263c35 2502 void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
MACRUM 0:276e7a263c35 2503 {
MACRUM 0:276e7a263c35 2504 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2505 TEST_IGNORE();
MACRUM 0:276e7a263c35 2506 #else
MACRUM 0:276e7a263c35 2507 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2508 TEST_ASSERT_HEX64_WITHIN(5, 1, -1);
MACRUM 0:276e7a263c35 2509 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2510 #endif
MACRUM 0:276e7a263c35 2511 }
MACRUM 0:276e7a263c35 2512
MACRUM 0:276e7a263c35 2513 void testUINT64sWithinDelta(void)
MACRUM 0:276e7a263c35 2514 {
MACRUM 0:276e7a263c35 2515 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2516 TEST_IGNORE();
MACRUM 0:276e7a263c35 2517 #else
MACRUM 0:276e7a263c35 2518 TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
MACRUM 0:276e7a263c35 2519 TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 2520 TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 2521 #endif
MACRUM 0:276e7a263c35 2522 }
MACRUM 0:276e7a263c35 2523
MACRUM 0:276e7a263c35 2524 void testUINT64sNotWithinDelta(void)
MACRUM 0:276e7a263c35 2525 {
MACRUM 0:276e7a263c35 2526 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2527 TEST_IGNORE();
MACRUM 0:276e7a263c35 2528 #else
MACRUM 0:276e7a263c35 2529 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2530 TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
MACRUM 0:276e7a263c35 2531 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2532 #endif
MACRUM 0:276e7a263c35 2533 }
MACRUM 0:276e7a263c35 2534
MACRUM 0:276e7a263c35 2535 void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
MACRUM 0:276e7a263c35 2536 {
MACRUM 0:276e7a263c35 2537 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2538 TEST_IGNORE();
MACRUM 0:276e7a263c35 2539 #else
MACRUM 0:276e7a263c35 2540 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2541 TEST_ASSERT_UINT64_WITHIN(5, 1, -1);
MACRUM 0:276e7a263c35 2542 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2543 #endif
MACRUM 0:276e7a263c35 2544 }
MACRUM 0:276e7a263c35 2545
MACRUM 0:276e7a263c35 2546 void testINT64sWithinDelta(void)
MACRUM 0:276e7a263c35 2547 {
MACRUM 0:276e7a263c35 2548 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2549 TEST_IGNORE();
MACRUM 0:276e7a263c35 2550 #else
MACRUM 0:276e7a263c35 2551 TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
MACRUM 0:276e7a263c35 2552 TEST_ASSERT_INT64_WITHIN(5, 5000, 4996);
MACRUM 0:276e7a263c35 2553 TEST_ASSERT_INT64_WITHIN(5, 5000, 5005);
MACRUM 0:276e7a263c35 2554 #endif
MACRUM 0:276e7a263c35 2555 }
MACRUM 0:276e7a263c35 2556
MACRUM 0:276e7a263c35 2557 void testINT64sNotWithinDelta(void)
MACRUM 0:276e7a263c35 2558 {
MACRUM 0:276e7a263c35 2559 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2560 TEST_IGNORE();
MACRUM 0:276e7a263c35 2561 #else
MACRUM 0:276e7a263c35 2562 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2563 TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
MACRUM 0:276e7a263c35 2564 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2565 #endif
MACRUM 0:276e7a263c35 2566 }
MACRUM 0:276e7a263c35 2567
MACRUM 0:276e7a263c35 2568 void testINT64sNotWithinDeltaAndDifferenceOverflows(void)
MACRUM 0:276e7a263c35 2569 {
MACRUM 0:276e7a263c35 2570 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2571 TEST_IGNORE();
MACRUM 0:276e7a263c35 2572 #else
MACRUM 0:276e7a263c35 2573 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2574 TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF);
MACRUM 0:276e7a263c35 2575 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2576 #endif
MACRUM 0:276e7a263c35 2577 }
MACRUM 0:276e7a263c35 2578
MACRUM 0:276e7a263c35 2579 void testEqualHEX64Arrays(void)
MACRUM 0:276e7a263c35 2580 {
MACRUM 0:276e7a263c35 2581 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2582 TEST_IGNORE();
MACRUM 0:276e7a263c35 2583 #else
MACRUM 0:276e7a263c35 2584 _UU64 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2585 _UU64 p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2586 _UU64 p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2587 _UU64 p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 2588
MACRUM 0:276e7a263c35 2589 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 2590 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 2591 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2592 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 2593 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 2594 #endif
MACRUM 0:276e7a263c35 2595 }
MACRUM 0:276e7a263c35 2596
MACRUM 0:276e7a263c35 2597 void testEqualUint64Arrays(void)
MACRUM 0:276e7a263c35 2598 {
MACRUM 0:276e7a263c35 2599 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2600 TEST_IGNORE();
MACRUM 0:276e7a263c35 2601 #else
MACRUM 0:276e7a263c35 2602 _UU64 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2603 _UU64 p1[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2604 _UU64 p2[] = {1, 8, 987, 2};
MACRUM 0:276e7a263c35 2605 _UU64 p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 2606
MACRUM 0:276e7a263c35 2607 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 2608 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 2609 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2610 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 2611 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 2612 #endif
MACRUM 0:276e7a263c35 2613 }
MACRUM 0:276e7a263c35 2614
MACRUM 0:276e7a263c35 2615 void testEqualInt64Arrays(void)
MACRUM 0:276e7a263c35 2616 {
MACRUM 0:276e7a263c35 2617 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2618 TEST_IGNORE();
MACRUM 0:276e7a263c35 2619 #else
MACRUM 0:276e7a263c35 2620 _US64 p0[] = {1, 8, 987, -65132};
MACRUM 0:276e7a263c35 2621 _US64 p1[] = {1, 8, 987, -65132};
MACRUM 0:276e7a263c35 2622 _US64 p2[] = {1, 8, 987, -2};
MACRUM 0:276e7a263c35 2623 _US64 p3[] = {1, 500, 600, 700};
MACRUM 0:276e7a263c35 2624
MACRUM 0:276e7a263c35 2625 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 2626 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 2627 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2628 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 2629 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 2630 #endif
MACRUM 0:276e7a263c35 2631 }
MACRUM 0:276e7a263c35 2632
MACRUM 0:276e7a263c35 2633
MACRUM 0:276e7a263c35 2634 void testNotEqualHEX64Arrays1(void)
MACRUM 0:276e7a263c35 2635 {
MACRUM 0:276e7a263c35 2636 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2637 TEST_IGNORE();
MACRUM 0:276e7a263c35 2638 #else
MACRUM 0:276e7a263c35 2639 _UU64 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2640 _UU64 p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 2641
MACRUM 0:276e7a263c35 2642 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2643 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2644 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2645 #endif
MACRUM 0:276e7a263c35 2646 }
MACRUM 0:276e7a263c35 2647
MACRUM 0:276e7a263c35 2648 void testNotEqualHEX64Arrays2(void)
MACRUM 0:276e7a263c35 2649 {
MACRUM 0:276e7a263c35 2650 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2651 TEST_IGNORE();
MACRUM 0:276e7a263c35 2652 #else
MACRUM 0:276e7a263c35 2653 _UU64 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2654 _UU64 p1[] = {2, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2655
MACRUM 0:276e7a263c35 2656 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2657 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2658 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2659 #endif
MACRUM 0:276e7a263c35 2660 }
MACRUM 0:276e7a263c35 2661
MACRUM 0:276e7a263c35 2662 void testNotEqualUint64Arrays(void)
MACRUM 0:276e7a263c35 2663 {
MACRUM 0:276e7a263c35 2664 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2665 TEST_IGNORE();
MACRUM 0:276e7a263c35 2666 #else
MACRUM 0:276e7a263c35 2667 _UU64 p0[] = {1, 8, 987, 65132u};
MACRUM 0:276e7a263c35 2668 _UU64 p1[] = {1, 8, 987, 65131u};
MACRUM 0:276e7a263c35 2669
MACRUM 0:276e7a263c35 2670 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2671 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2672 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2673 #endif
MACRUM 0:276e7a263c35 2674 }
MACRUM 0:276e7a263c35 2675
MACRUM 0:276e7a263c35 2676 void testNotEqualInt64Arrays(void)
MACRUM 0:276e7a263c35 2677 {
MACRUM 0:276e7a263c35 2678 #ifndef UNITY_SUPPORT_64
MACRUM 0:276e7a263c35 2679 TEST_IGNORE();
MACRUM 0:276e7a263c35 2680 #else
MACRUM 0:276e7a263c35 2681 _US64 p0[] = {1, 8, 987, -65132};
MACRUM 0:276e7a263c35 2682 _US64 p1[] = {1, 8, 987, -65131};
MACRUM 0:276e7a263c35 2683
MACRUM 0:276e7a263c35 2684 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2685 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 2686 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2687 #endif
MACRUM 0:276e7a263c35 2688 }
MACRUM 0:276e7a263c35 2689 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ==================
MACRUM 0:276e7a263c35 2690
MACRUM 0:276e7a263c35 2691 void testFloatsWithinDelta(void)
MACRUM 0:276e7a263c35 2692 {
MACRUM 0:276e7a263c35 2693 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2694 TEST_IGNORE();
MACRUM 0:276e7a263c35 2695 #else
MACRUM 0:276e7a263c35 2696 TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
MACRUM 0:276e7a263c35 2697 TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
MACRUM 0:276e7a263c35 2698 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
MACRUM 0:276e7a263c35 2699 TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
MACRUM 0:276e7a263c35 2700 #endif
MACRUM 0:276e7a263c35 2701 }
MACRUM 0:276e7a263c35 2702
MACRUM 0:276e7a263c35 2703 void testFloatsNotWithinDelta(void)
MACRUM 0:276e7a263c35 2704 {
MACRUM 0:276e7a263c35 2705 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2706 TEST_IGNORE();
MACRUM 0:276e7a263c35 2707 #else
MACRUM 0:276e7a263c35 2708 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2709 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
MACRUM 0:276e7a263c35 2710 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2711 #endif
MACRUM 0:276e7a263c35 2712 }
MACRUM 0:276e7a263c35 2713
MACRUM 0:276e7a263c35 2714 void testFloatsEqual(void)
MACRUM 0:276e7a263c35 2715 {
MACRUM 0:276e7a263c35 2716 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2717 TEST_IGNORE();
MACRUM 0:276e7a263c35 2718 #else
MACRUM 0:276e7a263c35 2719 TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
MACRUM 0:276e7a263c35 2720 TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
MACRUM 0:276e7a263c35 2721 TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
MACRUM 0:276e7a263c35 2722 TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
MACRUM 0:276e7a263c35 2723 #endif
MACRUM 0:276e7a263c35 2724 }
MACRUM 0:276e7a263c35 2725
MACRUM 0:276e7a263c35 2726 void testFloatsNotEqual(void)
MACRUM 0:276e7a263c35 2727 {
MACRUM 0:276e7a263c35 2728 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2729 TEST_IGNORE();
MACRUM 0:276e7a263c35 2730 #else
MACRUM 0:276e7a263c35 2731 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2732 TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
MACRUM 0:276e7a263c35 2733 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2734 #endif
MACRUM 0:276e7a263c35 2735 }
MACRUM 0:276e7a263c35 2736
MACRUM 0:276e7a263c35 2737 void testFloatsNotEqualNegative1(void)
MACRUM 0:276e7a263c35 2738 {
MACRUM 0:276e7a263c35 2739 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2740 TEST_IGNORE();
MACRUM 0:276e7a263c35 2741 #else
MACRUM 0:276e7a263c35 2742 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2743 TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
MACRUM 0:276e7a263c35 2744 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2745 #endif
MACRUM 0:276e7a263c35 2746 }
MACRUM 0:276e7a263c35 2747
MACRUM 0:276e7a263c35 2748 void testFloatsNotEqualNegative2(void)
MACRUM 0:276e7a263c35 2749 {
MACRUM 0:276e7a263c35 2750 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2751 TEST_IGNORE();
MACRUM 0:276e7a263c35 2752 #else
MACRUM 0:276e7a263c35 2753 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2754 TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
MACRUM 0:276e7a263c35 2755 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2756 #endif
MACRUM 0:276e7a263c35 2757 }
MACRUM 0:276e7a263c35 2758
MACRUM 0:276e7a263c35 2759 void testFloatsNotEqualActualNaN(void)
MACRUM 0:276e7a263c35 2760 {
MACRUM 0:276e7a263c35 2761 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2762 TEST_IGNORE();
MACRUM 0:276e7a263c35 2763 #else
MACRUM 0:276e7a263c35 2764 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2765 TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero);
MACRUM 0:276e7a263c35 2766 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2767 #endif
MACRUM 0:276e7a263c35 2768 }
MACRUM 0:276e7a263c35 2769
MACRUM 0:276e7a263c35 2770 void testFloatsNotEqualExpectedNaN(void)
MACRUM 0:276e7a263c35 2771 {
MACRUM 0:276e7a263c35 2772 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2773 TEST_IGNORE();
MACRUM 0:276e7a263c35 2774 #else
MACRUM 0:276e7a263c35 2775 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2776 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f);
MACRUM 0:276e7a263c35 2777 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2778 #endif
MACRUM 0:276e7a263c35 2779 }
MACRUM 0:276e7a263c35 2780
MACRUM 0:276e7a263c35 2781 void testFloatsNotEqualBothNaN(void)
MACRUM 0:276e7a263c35 2782 {
MACRUM 0:276e7a263c35 2783 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2784 TEST_IGNORE();
MACRUM 0:276e7a263c35 2785 #else
MACRUM 0:276e7a263c35 2786 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2787 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
MACRUM 0:276e7a263c35 2788 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2789 #endif
MACRUM 0:276e7a263c35 2790 }
MACRUM 0:276e7a263c35 2791
MACRUM 0:276e7a263c35 2792 void testFloatsNotEqualInfNaN(void)
MACRUM 0:276e7a263c35 2793 {
MACRUM 0:276e7a263c35 2794 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2795 TEST_IGNORE();
MACRUM 0:276e7a263c35 2796 #else
MACRUM 0:276e7a263c35 2797 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2798 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero);
MACRUM 0:276e7a263c35 2799 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2800 #endif
MACRUM 0:276e7a263c35 2801 }
MACRUM 0:276e7a263c35 2802
MACRUM 0:276e7a263c35 2803 void testFloatsNotEqualNaNInf(void)
MACRUM 0:276e7a263c35 2804 {
MACRUM 0:276e7a263c35 2805 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2806 TEST_IGNORE();
MACRUM 0:276e7a263c35 2807 #else
MACRUM 0:276e7a263c35 2808 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2809 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero);
MACRUM 0:276e7a263c35 2810 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2811 #endif
MACRUM 0:276e7a263c35 2812 }
MACRUM 0:276e7a263c35 2813
MACRUM 0:276e7a263c35 2814 void testFloatsNotEqualActualInf(void)
MACRUM 0:276e7a263c35 2815 {
MACRUM 0:276e7a263c35 2816 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2817 TEST_IGNORE();
MACRUM 0:276e7a263c35 2818 #else
MACRUM 0:276e7a263c35 2819 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2820 TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero);
MACRUM 0:276e7a263c35 2821 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2822 #endif
MACRUM 0:276e7a263c35 2823 }
MACRUM 0:276e7a263c35 2824
MACRUM 0:276e7a263c35 2825 void testFloatsNotEqualExpectedInf(void)
MACRUM 0:276e7a263c35 2826 {
MACRUM 0:276e7a263c35 2827 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2828 TEST_IGNORE();
MACRUM 0:276e7a263c35 2829 #else
MACRUM 0:276e7a263c35 2830 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2831 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f);
MACRUM 0:276e7a263c35 2832 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2833 #endif
MACRUM 0:276e7a263c35 2834 }
MACRUM 0:276e7a263c35 2835
MACRUM 0:276e7a263c35 2836 void testFloatsNotEqualBothInf(void)
MACRUM 0:276e7a263c35 2837 {
MACRUM 0:276e7a263c35 2838 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2839 TEST_IGNORE();
MACRUM 0:276e7a263c35 2840 #else
MACRUM 0:276e7a263c35 2841 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2842 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
MACRUM 0:276e7a263c35 2843 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2844 #endif
MACRUM 0:276e7a263c35 2845 }
MACRUM 0:276e7a263c35 2846
MACRUM 0:276e7a263c35 2847 void testFloatsNotEqualPlusMinusInf(void)
MACRUM 0:276e7a263c35 2848 {
MACRUM 0:276e7a263c35 2849 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2850 TEST_IGNORE();
MACRUM 0:276e7a263c35 2851 #else
MACRUM 0:276e7a263c35 2852 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2853 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero);
MACRUM 0:276e7a263c35 2854 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2855 #endif
MACRUM 0:276e7a263c35 2856 }
MACRUM 0:276e7a263c35 2857
MACRUM 0:276e7a263c35 2858 void testFloatIsPosInf1(void)
MACRUM 0:276e7a263c35 2859 {
MACRUM 0:276e7a263c35 2860 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2861 TEST_IGNORE();
MACRUM 0:276e7a263c35 2862 #else
MACRUM 0:276e7a263c35 2863 TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero);
MACRUM 0:276e7a263c35 2864 #endif
MACRUM 0:276e7a263c35 2865 }
MACRUM 0:276e7a263c35 2866
MACRUM 0:276e7a263c35 2867 void testFloatIsPosInf2(void)
MACRUM 0:276e7a263c35 2868 {
MACRUM 0:276e7a263c35 2869 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2870 TEST_IGNORE();
MACRUM 0:276e7a263c35 2871 #else
MACRUM 0:276e7a263c35 2872 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2873 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero);
MACRUM 0:276e7a263c35 2874 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2875 #endif
MACRUM 0:276e7a263c35 2876 }
MACRUM 0:276e7a263c35 2877
MACRUM 0:276e7a263c35 2878 void testFloatIsNegInf1(void)
MACRUM 0:276e7a263c35 2879 {
MACRUM 0:276e7a263c35 2880 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2881 TEST_IGNORE();
MACRUM 0:276e7a263c35 2882 #else
MACRUM 0:276e7a263c35 2883 TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero);
MACRUM 0:276e7a263c35 2884 #endif
MACRUM 0:276e7a263c35 2885 }
MACRUM 0:276e7a263c35 2886
MACRUM 0:276e7a263c35 2887 void testFloatIsNegInf2(void)
MACRUM 0:276e7a263c35 2888 {
MACRUM 0:276e7a263c35 2889 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2890 TEST_IGNORE();
MACRUM 0:276e7a263c35 2891 #else
MACRUM 0:276e7a263c35 2892 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2893 TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero);
MACRUM 0:276e7a263c35 2894 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2895 #endif
MACRUM 0:276e7a263c35 2896 }
MACRUM 0:276e7a263c35 2897
MACRUM 0:276e7a263c35 2898 void testFloatIsNotPosInf1(void)
MACRUM 0:276e7a263c35 2899 {
MACRUM 0:276e7a263c35 2900 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2901 TEST_IGNORE();
MACRUM 0:276e7a263c35 2902 #else
MACRUM 0:276e7a263c35 2903 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2904 TEST_ASSERT_FLOAT_IS_INF(2.0f);
MACRUM 0:276e7a263c35 2905 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2906 #endif
MACRUM 0:276e7a263c35 2907 }
MACRUM 0:276e7a263c35 2908
MACRUM 0:276e7a263c35 2909 void testFloatIsNotPosInf2(void)
MACRUM 0:276e7a263c35 2910 {
MACRUM 0:276e7a263c35 2911 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2912 TEST_IGNORE();
MACRUM 0:276e7a263c35 2913 #else
MACRUM 0:276e7a263c35 2914 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f);
MACRUM 0:276e7a263c35 2915 #endif
MACRUM 0:276e7a263c35 2916 }
MACRUM 0:276e7a263c35 2917
MACRUM 0:276e7a263c35 2918 void testFloatIsNotNegInf(void)
MACRUM 0:276e7a263c35 2919 {
MACRUM 0:276e7a263c35 2920 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2921 TEST_IGNORE();
MACRUM 0:276e7a263c35 2922 #else
MACRUM 0:276e7a263c35 2923 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2924 TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f);
MACRUM 0:276e7a263c35 2925 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2926 #endif
MACRUM 0:276e7a263c35 2927 }
MACRUM 0:276e7a263c35 2928
MACRUM 0:276e7a263c35 2929 void testFloatIsNan1(void)
MACRUM 0:276e7a263c35 2930 {
MACRUM 0:276e7a263c35 2931 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2932 TEST_IGNORE();
MACRUM 0:276e7a263c35 2933 #else
MACRUM 0:276e7a263c35 2934 TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero);
MACRUM 0:276e7a263c35 2935 #endif
MACRUM 0:276e7a263c35 2936 }
MACRUM 0:276e7a263c35 2937
MACRUM 0:276e7a263c35 2938 void testFloatIsNan2(void)
MACRUM 0:276e7a263c35 2939 {
MACRUM 0:276e7a263c35 2940 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2941 TEST_IGNORE();
MACRUM 0:276e7a263c35 2942 #else
MACRUM 0:276e7a263c35 2943 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2944 TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero);
MACRUM 0:276e7a263c35 2945 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2946 #endif
MACRUM 0:276e7a263c35 2947 }
MACRUM 0:276e7a263c35 2948
MACRUM 0:276e7a263c35 2949 void testFloatIsNotNan1(void)
MACRUM 0:276e7a263c35 2950 {
MACRUM 0:276e7a263c35 2951 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2952 TEST_IGNORE();
MACRUM 0:276e7a263c35 2953 #else
MACRUM 0:276e7a263c35 2954 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2955 TEST_ASSERT_FLOAT_IS_NAN(234.9f);
MACRUM 0:276e7a263c35 2956 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2957 #endif
MACRUM 0:276e7a263c35 2958 }
MACRUM 0:276e7a263c35 2959
MACRUM 0:276e7a263c35 2960 void testFloatIsNotNan2(void)
MACRUM 0:276e7a263c35 2961 {
MACRUM 0:276e7a263c35 2962 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2963 TEST_IGNORE();
MACRUM 0:276e7a263c35 2964 #else
MACRUM 0:276e7a263c35 2965 TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f);
MACRUM 0:276e7a263c35 2966 #endif
MACRUM 0:276e7a263c35 2967 }
MACRUM 0:276e7a263c35 2968
MACRUM 0:276e7a263c35 2969 void testFloatInfIsNotNan(void)
MACRUM 0:276e7a263c35 2970 {
MACRUM 0:276e7a263c35 2971 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2972 TEST_IGNORE();
MACRUM 0:276e7a263c35 2973 #else
MACRUM 0:276e7a263c35 2974 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2975 TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero);
MACRUM 0:276e7a263c35 2976 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2977 #endif
MACRUM 0:276e7a263c35 2978 }
MACRUM 0:276e7a263c35 2979
MACRUM 0:276e7a263c35 2980 void testFloatNanIsNotInf(void)
MACRUM 0:276e7a263c35 2981 {
MACRUM 0:276e7a263c35 2982 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2983 TEST_IGNORE();
MACRUM 0:276e7a263c35 2984 #else
MACRUM 0:276e7a263c35 2985 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 2986 TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero);
MACRUM 0:276e7a263c35 2987 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 2988 #endif
MACRUM 0:276e7a263c35 2989 }
MACRUM 0:276e7a263c35 2990
MACRUM 0:276e7a263c35 2991 void testFloatIsDeterminate1(void)
MACRUM 0:276e7a263c35 2992 {
MACRUM 0:276e7a263c35 2993 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 2994 TEST_IGNORE();
MACRUM 0:276e7a263c35 2995 #else
MACRUM 0:276e7a263c35 2996 TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f);
MACRUM 0:276e7a263c35 2997 TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f);
MACRUM 0:276e7a263c35 2998 TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f);
MACRUM 0:276e7a263c35 2999 #endif
MACRUM 0:276e7a263c35 3000 }
MACRUM 0:276e7a263c35 3001
MACRUM 0:276e7a263c35 3002 void testFloatIsDeterminate2(void)
MACRUM 0:276e7a263c35 3003 {
MACRUM 0:276e7a263c35 3004 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3005 TEST_IGNORE();
MACRUM 0:276e7a263c35 3006 #else
MACRUM 0:276e7a263c35 3007 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3008 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f);
MACRUM 0:276e7a263c35 3009 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3010 #endif
MACRUM 0:276e7a263c35 3011 }
MACRUM 0:276e7a263c35 3012
MACRUM 0:276e7a263c35 3013 void testFloatIsNotDeterminate1(void)
MACRUM 0:276e7a263c35 3014 {
MACRUM 0:276e7a263c35 3015 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3016 TEST_IGNORE();
MACRUM 0:276e7a263c35 3017 #else
MACRUM 0:276e7a263c35 3018 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero);
MACRUM 0:276e7a263c35 3019 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero);
MACRUM 0:276e7a263c35 3020 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero);
MACRUM 0:276e7a263c35 3021 #endif
MACRUM 0:276e7a263c35 3022 }
MACRUM 0:276e7a263c35 3023
MACRUM 0:276e7a263c35 3024 void testFloatIsNotDeterminate2(void)
MACRUM 0:276e7a263c35 3025 {
MACRUM 0:276e7a263c35 3026 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3027 TEST_IGNORE();
MACRUM 0:276e7a263c35 3028 #else
MACRUM 0:276e7a263c35 3029 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3030 TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero);
MACRUM 0:276e7a263c35 3031 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3032 #endif
MACRUM 0:276e7a263c35 3033 }
MACRUM 0:276e7a263c35 3034
MACRUM 0:276e7a263c35 3035 void testFloatTraitFailsOnInvalidTrait(void)
MACRUM 0:276e7a263c35 3036 {
MACRUM 0:276e7a263c35 3037 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3038 TEST_IGNORE();
MACRUM 0:276e7a263c35 3039 #else
MACRUM 0:276e7a263c35 3040 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3041 UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
MACRUM 0:276e7a263c35 3042 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3043 #endif
MACRUM 0:276e7a263c35 3044 }
MACRUM 0:276e7a263c35 3045
MACRUM 0:276e7a263c35 3046
MACRUM 0:276e7a263c35 3047 void testEqualFloatArrays(void)
MACRUM 0:276e7a263c35 3048 {
MACRUM 0:276e7a263c35 3049 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3050 TEST_IGNORE();
MACRUM 0:276e7a263c35 3051 #else
MACRUM 0:276e7a263c35 3052 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f};
MACRUM 0:276e7a263c35 3053 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f};
MACRUM 0:276e7a263c35 3054 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f};
MACRUM 0:276e7a263c35 3055 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
MACRUM 0:276e7a263c35 3056
MACRUM 0:276e7a263c35 3057 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 3058 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 3059 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3060 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 3061 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 3062 TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1);
MACRUM 0:276e7a263c35 3063 #endif
MACRUM 0:276e7a263c35 3064 }
MACRUM 0:276e7a263c35 3065
MACRUM 0:276e7a263c35 3066 void testNotEqualFloatArraysExpectedNull(void)
MACRUM 0:276e7a263c35 3067 {
MACRUM 0:276e7a263c35 3068 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3069 TEST_IGNORE();
MACRUM 0:276e7a263c35 3070 #else
MACRUM 0:276e7a263c35 3071 float* p0 = NULL;
MACRUM 0:276e7a263c35 3072 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
MACRUM 0:276e7a263c35 3073
MACRUM 0:276e7a263c35 3074 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3075 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3076 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3077 #endif
MACRUM 0:276e7a263c35 3078 }
MACRUM 0:276e7a263c35 3079
MACRUM 0:276e7a263c35 3080 void testNotEqualFloatArraysActualNull(void)
MACRUM 0:276e7a263c35 3081 {
MACRUM 0:276e7a263c35 3082 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3083 TEST_IGNORE();
MACRUM 0:276e7a263c35 3084 #else
MACRUM 0:276e7a263c35 3085 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3086 float* p1 = NULL;
MACRUM 0:276e7a263c35 3087
MACRUM 0:276e7a263c35 3088 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3089 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3090 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3091 #endif
MACRUM 0:276e7a263c35 3092 }
MACRUM 0:276e7a263c35 3093
MACRUM 0:276e7a263c35 3094 void testNotEqualFloatArrays1(void)
MACRUM 0:276e7a263c35 3095 {
MACRUM 0:276e7a263c35 3096 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3097 TEST_IGNORE();
MACRUM 0:276e7a263c35 3098 #else
MACRUM 0:276e7a263c35 3099 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3100 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
MACRUM 0:276e7a263c35 3101
MACRUM 0:276e7a263c35 3102 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3103 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3104 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3105 #endif
MACRUM 0:276e7a263c35 3106 }
MACRUM 0:276e7a263c35 3107
MACRUM 0:276e7a263c35 3108 void testNotEqualFloatArrays2(void)
MACRUM 0:276e7a263c35 3109 {
MACRUM 0:276e7a263c35 3110 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3111 TEST_IGNORE();
MACRUM 0:276e7a263c35 3112 #else
MACRUM 0:276e7a263c35 3113 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3114 float p1[] = {2.0f, 8.0f, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3115
MACRUM 0:276e7a263c35 3116 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3117 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3118 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3119 #endif
MACRUM 0:276e7a263c35 3120 }
MACRUM 0:276e7a263c35 3121
MACRUM 0:276e7a263c35 3122 void testNotEqualFloatArrays3(void)
MACRUM 0:276e7a263c35 3123 {
MACRUM 0:276e7a263c35 3124 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3125 TEST_IGNORE();
MACRUM 0:276e7a263c35 3126 #else
MACRUM 0:276e7a263c35 3127 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3128 float p1[] = {1.0f, 8.0f, 25.5f, 0.253f};
MACRUM 0:276e7a263c35 3129
MACRUM 0:276e7a263c35 3130 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3131 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3132 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3133 #endif
MACRUM 0:276e7a263c35 3134 }
MACRUM 0:276e7a263c35 3135
MACRUM 0:276e7a263c35 3136 void testNotEqualFloatArraysNegative1(void)
MACRUM 0:276e7a263c35 3137 {
MACRUM 0:276e7a263c35 3138 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3139 TEST_IGNORE();
MACRUM 0:276e7a263c35 3140 #else
MACRUM 0:276e7a263c35 3141 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
MACRUM 0:276e7a263c35 3142 float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f};
MACRUM 0:276e7a263c35 3143
MACRUM 0:276e7a263c35 3144 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3145 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3146 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3147 #endif
MACRUM 0:276e7a263c35 3148 }
MACRUM 0:276e7a263c35 3149
MACRUM 0:276e7a263c35 3150 void testNotEqualFloatArraysNegative2(void)
MACRUM 0:276e7a263c35 3151 {
MACRUM 0:276e7a263c35 3152 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3153 TEST_IGNORE();
MACRUM 0:276e7a263c35 3154 #else
MACRUM 0:276e7a263c35 3155 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
MACRUM 0:276e7a263c35 3156 float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f};
MACRUM 0:276e7a263c35 3157
MACRUM 0:276e7a263c35 3158 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3159 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3160 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3161 #endif
MACRUM 0:276e7a263c35 3162 }
MACRUM 0:276e7a263c35 3163
MACRUM 0:276e7a263c35 3164 void testNotEqualFloatArraysNegative3(void)
MACRUM 0:276e7a263c35 3165 {
MACRUM 0:276e7a263c35 3166 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3167 TEST_IGNORE();
MACRUM 0:276e7a263c35 3168 #else
MACRUM 0:276e7a263c35 3169 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
MACRUM 0:276e7a263c35 3170 float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f};
MACRUM 0:276e7a263c35 3171
MACRUM 0:276e7a263c35 3172 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3173 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3174 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3175 #endif
MACRUM 0:276e7a263c35 3176 }
MACRUM 0:276e7a263c35 3177
MACRUM 0:276e7a263c35 3178 void testNotEqualFloatArraysNaN(void)
MACRUM 0:276e7a263c35 3179 {
MACRUM 0:276e7a263c35 3180 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3181 TEST_IGNORE();
MACRUM 0:276e7a263c35 3182 #else
MACRUM 0:276e7a263c35 3183 float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3184 float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3185
MACRUM 0:276e7a263c35 3186 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3187 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3188 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3189 #endif
MACRUM 0:276e7a263c35 3190 }
MACRUM 0:276e7a263c35 3191
MACRUM 0:276e7a263c35 3192 void testNotEqualFloatArraysInf(void)
MACRUM 0:276e7a263c35 3193 {
MACRUM 0:276e7a263c35 3194 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3195 TEST_IGNORE();
MACRUM 0:276e7a263c35 3196 #else
MACRUM 0:276e7a263c35 3197 float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3198 float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
MACRUM 0:276e7a263c35 3199
MACRUM 0:276e7a263c35 3200 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3201 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3202 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3203 #endif
MACRUM 0:276e7a263c35 3204 }
MACRUM 0:276e7a263c35 3205
MACRUM 0:276e7a263c35 3206 void testNotEqualFloatArraysLengthZero(void)
MACRUM 0:276e7a263c35 3207 {
MACRUM 0:276e7a263c35 3208 #ifdef UNITY_EXCLUDE_FLOAT
MACRUM 0:276e7a263c35 3209 TEST_IGNORE();
MACRUM 0:276e7a263c35 3210 #else
MACRUM 0:276e7a263c35 3211 float p0[1] = {0.0f};
MACRUM 0:276e7a263c35 3212 float p1[1] = {0.0f};
MACRUM 0:276e7a263c35 3213
MACRUM 0:276e7a263c35 3214 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3215 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0);
MACRUM 0:276e7a263c35 3216 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3217 #endif
MACRUM 0:276e7a263c35 3218 }
MACRUM 0:276e7a263c35 3219
MACRUM 0:276e7a263c35 3220 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DOUBLE SUPPORT ==================
MACRUM 0:276e7a263c35 3221
MACRUM 0:276e7a263c35 3222 void testDoublesWithinDelta(void)
MACRUM 0:276e7a263c35 3223 {
MACRUM 0:276e7a263c35 3224 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3225 TEST_IGNORE();
MACRUM 0:276e7a263c35 3226 #else
MACRUM 0:276e7a263c35 3227 TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488);
MACRUM 0:276e7a263c35 3228 TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0);
MACRUM 0:276e7a263c35 3229 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049);
MACRUM 0:276e7a263c35 3230 TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424);
MACRUM 0:276e7a263c35 3231 #endif
MACRUM 0:276e7a263c35 3232 }
MACRUM 0:276e7a263c35 3233
MACRUM 0:276e7a263c35 3234 void testDoublesNotWithinDelta(void)
MACRUM 0:276e7a263c35 3235 {
MACRUM 0:276e7a263c35 3236 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3237 TEST_IGNORE();
MACRUM 0:276e7a263c35 3238 #else
MACRUM 0:276e7a263c35 3239 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3240 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049);
MACRUM 0:276e7a263c35 3241 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3242 #endif
MACRUM 0:276e7a263c35 3243 }
MACRUM 0:276e7a263c35 3244
MACRUM 0:276e7a263c35 3245
MACRUM 0:276e7a263c35 3246 void testDoublesEqual(void)
MACRUM 0:276e7a263c35 3247 {
MACRUM 0:276e7a263c35 3248 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3249 TEST_IGNORE();
MACRUM 0:276e7a263c35 3250 #else
MACRUM 0:276e7a263c35 3251 TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0);
MACRUM 0:276e7a263c35 3252 TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6);
MACRUM 0:276e7a263c35 3253 TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699);
MACRUM 0:276e7a263c35 3254 TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
MACRUM 0:276e7a263c35 3255 #endif
MACRUM 0:276e7a263c35 3256 }
MACRUM 0:276e7a263c35 3257
MACRUM 0:276e7a263c35 3258 void testDoublesNotEqual(void)
MACRUM 0:276e7a263c35 3259 {
MACRUM 0:276e7a263c35 3260 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3261 TEST_IGNORE();
MACRUM 0:276e7a263c35 3262 #else
MACRUM 0:276e7a263c35 3263 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3264 TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049);
MACRUM 0:276e7a263c35 3265 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3266 #endif
MACRUM 0:276e7a263c35 3267 }
MACRUM 0:276e7a263c35 3268
MACRUM 0:276e7a263c35 3269 void testDoublesNotEqualNegative1(void)
MACRUM 0:276e7a263c35 3270 {
MACRUM 0:276e7a263c35 3271 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3272 TEST_IGNORE();
MACRUM 0:276e7a263c35 3273 #else
MACRUM 0:276e7a263c35 3274 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3275 TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
MACRUM 0:276e7a263c35 3276 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3277 #endif
MACRUM 0:276e7a263c35 3278 }
MACRUM 0:276e7a263c35 3279
MACRUM 0:276e7a263c35 3280 void testDoublesNotEqualNegative2(void)
MACRUM 0:276e7a263c35 3281 {
MACRUM 0:276e7a263c35 3282 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3283 TEST_IGNORE();
MACRUM 0:276e7a263c35 3284 #else
MACRUM 0:276e7a263c35 3285 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3286 TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
MACRUM 0:276e7a263c35 3287 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3288 #endif
MACRUM 0:276e7a263c35 3289 }
MACRUM 0:276e7a263c35 3290
MACRUM 0:276e7a263c35 3291 void testDoublesNotEqualActualNaN(void)
MACRUM 0:276e7a263c35 3292 {
MACRUM 0:276e7a263c35 3293 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3294 TEST_IGNORE();
MACRUM 0:276e7a263c35 3295 #else
MACRUM 0:276e7a263c35 3296 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3297 TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
MACRUM 0:276e7a263c35 3298 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3299 #endif
MACRUM 0:276e7a263c35 3300 }
MACRUM 0:276e7a263c35 3301
MACRUM 0:276e7a263c35 3302 void testDoublesNotEqualExpectedNaN(void)
MACRUM 0:276e7a263c35 3303 {
MACRUM 0:276e7a263c35 3304 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3305 TEST_IGNORE();
MACRUM 0:276e7a263c35 3306 #else
MACRUM 0:276e7a263c35 3307 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3308 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
MACRUM 0:276e7a263c35 3309 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3310 #endif
MACRUM 0:276e7a263c35 3311 }
MACRUM 0:276e7a263c35 3312
MACRUM 0:276e7a263c35 3313 void testDoublesNotEqualBothNaN(void)
MACRUM 0:276e7a263c35 3314 {
MACRUM 0:276e7a263c35 3315 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3316 TEST_IGNORE();
MACRUM 0:276e7a263c35 3317 #else
MACRUM 0:276e7a263c35 3318 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3319 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
MACRUM 0:276e7a263c35 3320 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3321 #endif
MACRUM 0:276e7a263c35 3322 }
MACRUM 0:276e7a263c35 3323
MACRUM 0:276e7a263c35 3324 void testDoublesNotEqualInfNaN(void)
MACRUM 0:276e7a263c35 3325 {
MACRUM 0:276e7a263c35 3326 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3327 TEST_IGNORE();
MACRUM 0:276e7a263c35 3328 #else
MACRUM 0:276e7a263c35 3329 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3330 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
MACRUM 0:276e7a263c35 3331 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3332 #endif
MACRUM 0:276e7a263c35 3333 }
MACRUM 0:276e7a263c35 3334
MACRUM 0:276e7a263c35 3335 void testDoublesNotEqualNaNInf(void)
MACRUM 0:276e7a263c35 3336 {
MACRUM 0:276e7a263c35 3337 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3338 TEST_IGNORE();
MACRUM 0:276e7a263c35 3339 #else
MACRUM 0:276e7a263c35 3340 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3341 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
MACRUM 0:276e7a263c35 3342 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3343 #endif
MACRUM 0:276e7a263c35 3344 }
MACRUM 0:276e7a263c35 3345
MACRUM 0:276e7a263c35 3346 void testDoublesNotEqualActualInf(void)
MACRUM 0:276e7a263c35 3347 {
MACRUM 0:276e7a263c35 3348 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3349 TEST_IGNORE();
MACRUM 0:276e7a263c35 3350 #else
MACRUM 0:276e7a263c35 3351 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3352 TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
MACRUM 0:276e7a263c35 3353 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3354 #endif
MACRUM 0:276e7a263c35 3355 }
MACRUM 0:276e7a263c35 3356
MACRUM 0:276e7a263c35 3357 void testDoublesNotEqualExpectedInf(void)
MACRUM 0:276e7a263c35 3358 {
MACRUM 0:276e7a263c35 3359 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3360 TEST_IGNORE();
MACRUM 0:276e7a263c35 3361 #else
MACRUM 0:276e7a263c35 3362 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3363 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
MACRUM 0:276e7a263c35 3364 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3365 #endif
MACRUM 0:276e7a263c35 3366 }
MACRUM 0:276e7a263c35 3367
MACRUM 0:276e7a263c35 3368 void testDoublesNotEqualBothInf(void)
MACRUM 0:276e7a263c35 3369 {
MACRUM 0:276e7a263c35 3370 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3371 TEST_IGNORE();
MACRUM 0:276e7a263c35 3372 #else
MACRUM 0:276e7a263c35 3373 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3374 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
MACRUM 0:276e7a263c35 3375 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3376 #endif
MACRUM 0:276e7a263c35 3377 }
MACRUM 0:276e7a263c35 3378
MACRUM 0:276e7a263c35 3379 void testDoublesNotEqualPlusMinusInf(void)
MACRUM 0:276e7a263c35 3380 {
MACRUM 0:276e7a263c35 3381 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3382 TEST_IGNORE();
MACRUM 0:276e7a263c35 3383 #else
MACRUM 0:276e7a263c35 3384 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3385 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
MACRUM 0:276e7a263c35 3386 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3387 #endif
MACRUM 0:276e7a263c35 3388 }
MACRUM 0:276e7a263c35 3389
MACRUM 0:276e7a263c35 3390 void testDoubleIsPosInf1(void)
MACRUM 0:276e7a263c35 3391 {
MACRUM 0:276e7a263c35 3392 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3393 TEST_IGNORE();
MACRUM 0:276e7a263c35 3394 #else
MACRUM 0:276e7a263c35 3395 TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero);
MACRUM 0:276e7a263c35 3396 #endif
MACRUM 0:276e7a263c35 3397 }
MACRUM 0:276e7a263c35 3398
MACRUM 0:276e7a263c35 3399 void testDoubleIsPosInf2(void)
MACRUM 0:276e7a263c35 3400 {
MACRUM 0:276e7a263c35 3401 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3402 TEST_IGNORE();
MACRUM 0:276e7a263c35 3403 #else
MACRUM 0:276e7a263c35 3404 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3405 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero);
MACRUM 0:276e7a263c35 3406 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3407 #endif
MACRUM 0:276e7a263c35 3408 }
MACRUM 0:276e7a263c35 3409
MACRUM 0:276e7a263c35 3410 void testDoubleIsNegInf1(void)
MACRUM 0:276e7a263c35 3411 {
MACRUM 0:276e7a263c35 3412 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3413 TEST_IGNORE();
MACRUM 0:276e7a263c35 3414 #else
MACRUM 0:276e7a263c35 3415 TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero);
MACRUM 0:276e7a263c35 3416 #endif
MACRUM 0:276e7a263c35 3417 }
MACRUM 0:276e7a263c35 3418
MACRUM 0:276e7a263c35 3419 void testDoubleIsNegInf2(void)
MACRUM 0:276e7a263c35 3420 {
MACRUM 0:276e7a263c35 3421 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3422 TEST_IGNORE();
MACRUM 0:276e7a263c35 3423 #else
MACRUM 0:276e7a263c35 3424 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3425 TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero);
MACRUM 0:276e7a263c35 3426 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3427 #endif
MACRUM 0:276e7a263c35 3428 }
MACRUM 0:276e7a263c35 3429
MACRUM 0:276e7a263c35 3430 void testDoubleIsNotPosInf1(void)
MACRUM 0:276e7a263c35 3431 {
MACRUM 0:276e7a263c35 3432 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3433 TEST_IGNORE();
MACRUM 0:276e7a263c35 3434 #else
MACRUM 0:276e7a263c35 3435 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3436 TEST_ASSERT_DOUBLE_IS_INF(2.0);
MACRUM 0:276e7a263c35 3437 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3438 #endif
MACRUM 0:276e7a263c35 3439 }
MACRUM 0:276e7a263c35 3440
MACRUM 0:276e7a263c35 3441 void testDoubleIsNotPosInf2(void)
MACRUM 0:276e7a263c35 3442 {
MACRUM 0:276e7a263c35 3443 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3444 TEST_IGNORE();
MACRUM 0:276e7a263c35 3445 #else
MACRUM 0:276e7a263c35 3446 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0);
MACRUM 0:276e7a263c35 3447 #endif
MACRUM 0:276e7a263c35 3448 }
MACRUM 0:276e7a263c35 3449
MACRUM 0:276e7a263c35 3450 void testDoubleIsNotNegInf(void)
MACRUM 0:276e7a263c35 3451 {
MACRUM 0:276e7a263c35 3452 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3453 TEST_IGNORE();
MACRUM 0:276e7a263c35 3454 #else
MACRUM 0:276e7a263c35 3455 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3456 TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876);
MACRUM 0:276e7a263c35 3457 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3458 #endif
MACRUM 0:276e7a263c35 3459 }
MACRUM 0:276e7a263c35 3460
MACRUM 0:276e7a263c35 3461 void testDoubleIsNan1(void)
MACRUM 0:276e7a263c35 3462 {
MACRUM 0:276e7a263c35 3463 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3464 TEST_IGNORE();
MACRUM 0:276e7a263c35 3465 #else
MACRUM 0:276e7a263c35 3466 TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero);
MACRUM 0:276e7a263c35 3467 #endif
MACRUM 0:276e7a263c35 3468 }
MACRUM 0:276e7a263c35 3469
MACRUM 0:276e7a263c35 3470 void testDoubleIsNan2(void)
MACRUM 0:276e7a263c35 3471 {
MACRUM 0:276e7a263c35 3472 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3473 TEST_IGNORE();
MACRUM 0:276e7a263c35 3474 #else
MACRUM 0:276e7a263c35 3475 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3476 TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero);
MACRUM 0:276e7a263c35 3477 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3478 #endif
MACRUM 0:276e7a263c35 3479 }
MACRUM 0:276e7a263c35 3480
MACRUM 0:276e7a263c35 3481 void testDoubleIsNotNan1(void)
MACRUM 0:276e7a263c35 3482 {
MACRUM 0:276e7a263c35 3483 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3484 TEST_IGNORE();
MACRUM 0:276e7a263c35 3485 #else
MACRUM 0:276e7a263c35 3486 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3487 TEST_ASSERT_DOUBLE_IS_NAN(234.9);
MACRUM 0:276e7a263c35 3488 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3489 #endif
MACRUM 0:276e7a263c35 3490 }
MACRUM 0:276e7a263c35 3491
MACRUM 0:276e7a263c35 3492 void testDoubleIsNotNan2(void)
MACRUM 0:276e7a263c35 3493 {
MACRUM 0:276e7a263c35 3494 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3495 TEST_IGNORE();
MACRUM 0:276e7a263c35 3496 #else
MACRUM 0:276e7a263c35 3497 TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9);
MACRUM 0:276e7a263c35 3498 #endif
MACRUM 0:276e7a263c35 3499 }
MACRUM 0:276e7a263c35 3500
MACRUM 0:276e7a263c35 3501 void testDoubleInfIsNotNan(void)
MACRUM 0:276e7a263c35 3502 {
MACRUM 0:276e7a263c35 3503 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3504 TEST_IGNORE();
MACRUM 0:276e7a263c35 3505 #else
MACRUM 0:276e7a263c35 3506 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3507 TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero);
MACRUM 0:276e7a263c35 3508 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3509 #endif
MACRUM 0:276e7a263c35 3510 }
MACRUM 0:276e7a263c35 3511
MACRUM 0:276e7a263c35 3512 void testDoubleNanIsNotInf(void)
MACRUM 0:276e7a263c35 3513 {
MACRUM 0:276e7a263c35 3514 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3515 TEST_IGNORE();
MACRUM 0:276e7a263c35 3516 #else
MACRUM 0:276e7a263c35 3517 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3518 TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero);
MACRUM 0:276e7a263c35 3519 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3520 #endif
MACRUM 0:276e7a263c35 3521 }
MACRUM 0:276e7a263c35 3522
MACRUM 0:276e7a263c35 3523 void testDoubleIsDeterminate1(void)
MACRUM 0:276e7a263c35 3524 {
MACRUM 0:276e7a263c35 3525 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3526 TEST_IGNORE();
MACRUM 0:276e7a263c35 3527 #else
MACRUM 0:276e7a263c35 3528 TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0);
MACRUM 0:276e7a263c35 3529 TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3);
MACRUM 0:276e7a263c35 3530 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3);
MACRUM 0:276e7a263c35 3531 #endif
MACRUM 0:276e7a263c35 3532 }
MACRUM 0:276e7a263c35 3533
MACRUM 0:276e7a263c35 3534 void testDoubleIsDeterminate2(void)
MACRUM 0:276e7a263c35 3535 {
MACRUM 0:276e7a263c35 3536 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3537 TEST_IGNORE();
MACRUM 0:276e7a263c35 3538 #else
MACRUM 0:276e7a263c35 3539 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3540 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3);
MACRUM 0:276e7a263c35 3541 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3542 #endif
MACRUM 0:276e7a263c35 3543 }
MACRUM 0:276e7a263c35 3544
MACRUM 0:276e7a263c35 3545 void testDoubleIsNotDeterminate1(void)
MACRUM 0:276e7a263c35 3546 {
MACRUM 0:276e7a263c35 3547 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3548 TEST_IGNORE();
MACRUM 0:276e7a263c35 3549 #else
MACRUM 0:276e7a263c35 3550 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero);
MACRUM 0:276e7a263c35 3551 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero);
MACRUM 0:276e7a263c35 3552 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero);
MACRUM 0:276e7a263c35 3553 #endif
MACRUM 0:276e7a263c35 3554 }
MACRUM 0:276e7a263c35 3555
MACRUM 0:276e7a263c35 3556 void testDoubleIsNotDeterminate2(void)
MACRUM 0:276e7a263c35 3557 {
MACRUM 0:276e7a263c35 3558 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3559 TEST_IGNORE();
MACRUM 0:276e7a263c35 3560 #else
MACRUM 0:276e7a263c35 3561 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3562 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero);
MACRUM 0:276e7a263c35 3563 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3564 #endif
MACRUM 0:276e7a263c35 3565 }
MACRUM 0:276e7a263c35 3566
MACRUM 0:276e7a263c35 3567 void testDoubleTraitFailsOnInvalidTrait(void)
MACRUM 0:276e7a263c35 3568 {
MACRUM 0:276e7a263c35 3569 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3570 TEST_IGNORE();
MACRUM 0:276e7a263c35 3571 #else
MACRUM 0:276e7a263c35 3572 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3573 UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
MACRUM 0:276e7a263c35 3574 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3575 #endif
MACRUM 0:276e7a263c35 3576 }
MACRUM 0:276e7a263c35 3577
MACRUM 0:276e7a263c35 3578 void testEqualDoubleArrays(void)
MACRUM 0:276e7a263c35 3579 {
MACRUM 0:276e7a263c35 3580 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3581 TEST_IGNORE();
MACRUM 0:276e7a263c35 3582 #else
MACRUM 0:276e7a263c35 3583 double p0[] = {1.0, -8.0, 25.4, -0.123};
MACRUM 0:276e7a263c35 3584 double p1[] = {1.0, -8.0, 25.4, -0.123};
MACRUM 0:276e7a263c35 3585 double p2[] = {1.0, -8.0, 25.4, -0.2};
MACRUM 0:276e7a263c35 3586 double p3[] = {1.0, -23.0, 25.0, -0.26};
MACRUM 0:276e7a263c35 3587
MACRUM 0:276e7a263c35 3588 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1);
MACRUM 0:276e7a263c35 3589 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4);
MACRUM 0:276e7a263c35 3590 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3591 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3);
MACRUM 0:276e7a263c35 3592 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1);
MACRUM 0:276e7a263c35 3593 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1);
MACRUM 0:276e7a263c35 3594 #endif
MACRUM 0:276e7a263c35 3595 }
MACRUM 0:276e7a263c35 3596
MACRUM 0:276e7a263c35 3597 void testNotEqualDoubleArraysExpectedNull(void)
MACRUM 0:276e7a263c35 3598 {
MACRUM 0:276e7a263c35 3599 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3600 TEST_IGNORE();
MACRUM 0:276e7a263c35 3601 #else
MACRUM 0:276e7a263c35 3602 double* p0 = NULL;
MACRUM 0:276e7a263c35 3603 double p1[] = {1.0, 8.0, 25.4, 0.252};
MACRUM 0:276e7a263c35 3604
MACRUM 0:276e7a263c35 3605 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3606 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3607 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3608 #endif
MACRUM 0:276e7a263c35 3609 }
MACRUM 0:276e7a263c35 3610
MACRUM 0:276e7a263c35 3611 void testNotEqualDoubleArraysActualNull(void)
MACRUM 0:276e7a263c35 3612 {
MACRUM 0:276e7a263c35 3613 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3614 TEST_IGNORE();
MACRUM 0:276e7a263c35 3615 #else
MACRUM 0:276e7a263c35 3616 double p0[] = {1.0, 8.0, 25.4, 0.253};
MACRUM 0:276e7a263c35 3617 double* p1 = NULL;
MACRUM 0:276e7a263c35 3618
MACRUM 0:276e7a263c35 3619 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3620 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3621 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3622 #endif
MACRUM 0:276e7a263c35 3623 }
MACRUM 0:276e7a263c35 3624
MACRUM 0:276e7a263c35 3625 void testNotEqualDoubleArrays1(void)
MACRUM 0:276e7a263c35 3626 {
MACRUM 0:276e7a263c35 3627 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3628 TEST_IGNORE();
MACRUM 0:276e7a263c35 3629 #else
MACRUM 0:276e7a263c35 3630 double p0[] = {1.0, 8.0, 25.4, 0.25666666667};
MACRUM 0:276e7a263c35 3631 double p1[] = {1.0, 8.0, 25.4, 0.25666666666};
MACRUM 0:276e7a263c35 3632
MACRUM 0:276e7a263c35 3633 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3634 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3635 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3636 #endif
MACRUM 0:276e7a263c35 3637 }
MACRUM 0:276e7a263c35 3638
MACRUM 0:276e7a263c35 3639 void testNotEqualDoubleArrays2(void)
MACRUM 0:276e7a263c35 3640 {
MACRUM 0:276e7a263c35 3641 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3642 TEST_IGNORE();
MACRUM 0:276e7a263c35 3643 #else
MACRUM 0:276e7a263c35 3644 double p0[] = {1.0, 8.0, 25.4, 0.253};
MACRUM 0:276e7a263c35 3645 double p1[] = {2.0, 8.0, 25.4, 0.253};
MACRUM 0:276e7a263c35 3646
MACRUM 0:276e7a263c35 3647 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3648 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3649 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3650 #endif
MACRUM 0:276e7a263c35 3651 }
MACRUM 0:276e7a263c35 3652
MACRUM 0:276e7a263c35 3653 void testNotEqualDoubleArrays3(void)
MACRUM 0:276e7a263c35 3654 {
MACRUM 0:276e7a263c35 3655 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3656 TEST_IGNORE();
MACRUM 0:276e7a263c35 3657 #else
MACRUM 0:276e7a263c35 3658 double p0[] = {1.0, 8.0, 25.4, 0.253};
MACRUM 0:276e7a263c35 3659 double p1[] = {1.0, 8.0, 25.5, 0.253};
MACRUM 0:276e7a263c35 3660
MACRUM 0:276e7a263c35 3661 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3662 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3663 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3664 #endif
MACRUM 0:276e7a263c35 3665 }
MACRUM 0:276e7a263c35 3666
MACRUM 0:276e7a263c35 3667 void testNotEqualDoubleArraysNegative1(void)
MACRUM 0:276e7a263c35 3668 {
MACRUM 0:276e7a263c35 3669 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3670 TEST_IGNORE();
MACRUM 0:276e7a263c35 3671 #else
MACRUM 0:276e7a263c35 3672 double p0[] = {-1.0, -8.0, -25.4, -0.2566666667};
MACRUM 0:276e7a263c35 3673 double p1[] = {-1.0, -8.0, -25.4, -0.2566666666};
MACRUM 0:276e7a263c35 3674
MACRUM 0:276e7a263c35 3675 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3676 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3677 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3678 #endif
MACRUM 0:276e7a263c35 3679 }
MACRUM 0:276e7a263c35 3680
MACRUM 0:276e7a263c35 3681 void testNotEqualDoubleArraysNegative2(void)
MACRUM 0:276e7a263c35 3682 {
MACRUM 0:276e7a263c35 3683 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3684 TEST_IGNORE();
MACRUM 0:276e7a263c35 3685 #else
MACRUM 0:276e7a263c35 3686 double p0[] = {-1.0, -8.0, -25.4, -0.253};
MACRUM 0:276e7a263c35 3687 double p1[] = {-2.0, -8.0, -25.4, -0.253};
MACRUM 0:276e7a263c35 3688
MACRUM 0:276e7a263c35 3689 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3690 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3691 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3692 #endif
MACRUM 0:276e7a263c35 3693 }
MACRUM 0:276e7a263c35 3694
MACRUM 0:276e7a263c35 3695 void testNotEqualDoubleArraysNegative3(void)
MACRUM 0:276e7a263c35 3696 {
MACRUM 0:276e7a263c35 3697 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3698 TEST_IGNORE();
MACRUM 0:276e7a263c35 3699 #else
MACRUM 0:276e7a263c35 3700 double p0[] = {-1.0, -8.0, -25.4, -0.253};
MACRUM 0:276e7a263c35 3701 double p1[] = {-1.0, -8.0, -25.5, -0.253};
MACRUM 0:276e7a263c35 3702
MACRUM 0:276e7a263c35 3703 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3704 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3705 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3706 #endif
MACRUM 0:276e7a263c35 3707 }
MACRUM 0:276e7a263c35 3708
MACRUM 0:276e7a263c35 3709 void testNotEqualDoubleArraysNaN(void)
MACRUM 0:276e7a263c35 3710 {
MACRUM 0:276e7a263c35 3711 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3712 TEST_IGNORE();
MACRUM 0:276e7a263c35 3713 #else
MACRUM 0:276e7a263c35 3714 double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
MACRUM 0:276e7a263c35 3715 double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
MACRUM 0:276e7a263c35 3716
MACRUM 0:276e7a263c35 3717 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3718 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3719 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3720 #endif
MACRUM 0:276e7a263c35 3721 }
MACRUM 0:276e7a263c35 3722
MACRUM 0:276e7a263c35 3723 void testNotEqualDoubleArraysInf(void)
MACRUM 0:276e7a263c35 3724 {
MACRUM 0:276e7a263c35 3725 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3726 TEST_IGNORE();
MACRUM 0:276e7a263c35 3727 #else
MACRUM 0:276e7a263c35 3728 double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
MACRUM 0:276e7a263c35 3729 double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
MACRUM 0:276e7a263c35 3730
MACRUM 0:276e7a263c35 3731 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3732 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
MACRUM 0:276e7a263c35 3733 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3734 #endif
MACRUM 0:276e7a263c35 3735 }
MACRUM 0:276e7a263c35 3736
MACRUM 0:276e7a263c35 3737 void testNotEqualDoubleArraysLengthZero(void)
MACRUM 0:276e7a263c35 3738 {
MACRUM 0:276e7a263c35 3739 #ifdef UNITY_EXCLUDE_DOUBLE
MACRUM 0:276e7a263c35 3740 TEST_IGNORE();
MACRUM 0:276e7a263c35 3741 #else
MACRUM 0:276e7a263c35 3742 double p0[1] = {0.0};
MACRUM 0:276e7a263c35 3743 double p1[1] = {0.0};
MACRUM 0:276e7a263c35 3744
MACRUM 0:276e7a263c35 3745 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3746 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0);
MACRUM 0:276e7a263c35 3747 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3748 #endif
MACRUM 0:276e7a263c35 3749 }
MACRUM 0:276e7a263c35 3750
MACRUM 0:276e7a263c35 3751 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ==================
MACRUM 0:276e7a263c35 3752
MACRUM 0:276e7a263c35 3753 void testThatDetailsCanBeHandleOneDetail(void)
MACRUM 0:276e7a263c35 3754 {
MACRUM 0:276e7a263c35 3755 #ifdef UNITY_EXCLUDE_DETAILS
MACRUM 0:276e7a263c35 3756 TEST_IGNORE();
MACRUM 0:276e7a263c35 3757 #else
MACRUM 0:276e7a263c35 3758 UNITY_SET_DETAIL("Detail1");
MACRUM 0:276e7a263c35 3759
MACRUM 0:276e7a263c35 3760 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3761 TEST_ASSERT_EQUAL_INT_MESSAGE(5, 6, "Should Fail And Say Detail1");
MACRUM 0:276e7a263c35 3762 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3763 #endif
MACRUM 0:276e7a263c35 3764 }
MACRUM 0:276e7a263c35 3765
MACRUM 0:276e7a263c35 3766 void testThatDetailsCanHandleTestFail(void)
MACRUM 0:276e7a263c35 3767 {
MACRUM 0:276e7a263c35 3768 #ifdef UNITY_EXCLUDE_DETAILS
MACRUM 0:276e7a263c35 3769 TEST_IGNORE();
MACRUM 0:276e7a263c35 3770 #else
MACRUM 0:276e7a263c35 3771 UNITY_SET_DETAILS("Detail1","Detail2");
MACRUM 0:276e7a263c35 3772
MACRUM 0:276e7a263c35 3773 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3774 TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2");
MACRUM 0:276e7a263c35 3775 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3776 #endif
MACRUM 0:276e7a263c35 3777 }
MACRUM 0:276e7a263c35 3778
MACRUM 0:276e7a263c35 3779 void testThatDetailsCanBeHandleTwoDetails(void)
MACRUM 0:276e7a263c35 3780 {
MACRUM 0:276e7a263c35 3781 #ifdef UNITY_EXCLUDE_DETAILS
MACRUM 0:276e7a263c35 3782 TEST_IGNORE();
MACRUM 0:276e7a263c35 3783 #else
MACRUM 0:276e7a263c35 3784 UNITY_SET_DETAILS("Detail1","Detail2");
MACRUM 0:276e7a263c35 3785
MACRUM 0:276e7a263c35 3786 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3787 TEST_ASSERT_EQUAL_HEX8_MESSAGE(7, 8, "Should Fail And Say Detail1 and Detail2");
MACRUM 0:276e7a263c35 3788 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3789 #endif
MACRUM 0:276e7a263c35 3790 }
MACRUM 0:276e7a263c35 3791
MACRUM 0:276e7a263c35 3792 void testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void)
MACRUM 0:276e7a263c35 3793 {
MACRUM 0:276e7a263c35 3794 #ifdef UNITY_EXCLUDE_DETAILS
MACRUM 0:276e7a263c35 3795 TEST_IGNORE();
MACRUM 0:276e7a263c35 3796 #else
MACRUM 0:276e7a263c35 3797 UNITY_SET_DETAILS("Detail1","Detail2");
MACRUM 0:276e7a263c35 3798 UNITY_SET_DETAIL("DetailNew");
MACRUM 0:276e7a263c35 3799
MACRUM 0:276e7a263c35 3800 EXPECT_ABORT_BEGIN
MACRUM 0:276e7a263c35 3801 TEST_ASSERT_EQUAL_STRING_MESSAGE("MEH", "GUH", "Should Fail And Say DetailNew");
MACRUM 0:276e7a263c35 3802 VERIFY_FAILS_END
MACRUM 0:276e7a263c35 3803 #endif
MACRUM 0:276e7a263c35 3804 }