1 /* ==========================================
2 Unity Project - A Test Framework for C
3 Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
4 [Released under MIT License. Please refer to license.txt for details]
5 ========================================== */
6
7 #include "unity.h"
8 #include <string.h>
9 #include <stdint.h>
10
11 // Dividing by these constants produces +/- infinity.
12 // The rationale is given in UnityAssertFloatIsInf's body.
13 #ifndef UNITY_EXCLUDE_FLOAT
14 static const UNITY_FLOAT f_zero = 0.0f;
15 #endif
16
17 #ifndef UNITY_EXCLUDE_DOUBLE
18 static const UNITY_DOUBLE d_zero = 0.0;
19 #endif
20
21 #define EXPECT_ABORT_BEGIN \
22 startPutcharSpy(); \
23 if (TEST_PROTECT()) \
24 {
25
26 #define VERIFY_FAILS_END \
27 } \
28 endPutcharSpy(); /* start/end Spy to suppress output of failure message */ \
29 Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \
30 if (Unity.CurrentTestFailed == 1) { \
31 SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
32 UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \
33 UNITY_OUTPUT_CHAR(':'); \
34 UnityPrint(Unity.CurrentTestName); \
35 UnityPrint(":FAIL: [[[[ Test Should Have Failed But Did Not ]]]]"); \
36 UNITY_OUTPUT_CHAR('\n'); \
37 }
38
39 #define VERIFY_IGNORES_END \
40 } \
41 endPutcharSpy(); /* start/end Spy to suppress output of ignore message */ \
42 Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \
43 Unity.CurrentTestIgnored = 0; \
44 if (Unity.CurrentTestFailed == 1) { \
45 SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
46 UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \
47 UNITY_OUTPUT_CHAR(':'); \
48 UnityPrint(Unity.CurrentTestName); \
49 UnityPrint(":FAIL: [[[[ Test Should Have Ignored But Did Not ]]]]"); \
50 UNITY_OUTPUT_CHAR('\n'); \
51 }
52
53 void startPutcharSpy(void);
54 void endPutcharSpy(void);
55 char* getBufferPutcharSpy(void);
56
57 static int SetToOneToFailInTearDown;
58 static int SetToOneMeanWeAlreadyCheckedThisGuy;
59
setUp(void)60 void setUp(void)
61 {
62 SetToOneToFailInTearDown = 0;
63 SetToOneMeanWeAlreadyCheckedThisGuy = 0;
64 }
65
tearDown(void)66 void tearDown(void)
67 {
68 endPutcharSpy(); /* Stop suppressing test output */
69 if (SetToOneToFailInTearDown == 1)
70 {
71 /* These will be skipped internally if already failed/ignored */
72 TEST_FAIL_MESSAGE("<= Failed in tearDown");
73 TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
74 }
75 if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
76 {
77 UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
78 UNITY_OUTPUT_CHAR('\n');
79 }
80 }
81
testUnitySizeInitializationReminder(void)82 void testUnitySizeInitializationReminder(void)
83 {
84 /* This test ensures that sizeof(struct UNITY_STORAGE_T) doesn't change. If this
85 * test breaks, go look at the initialization of the Unity global variable
86 * in unity.c and make sure we're filling in the proper fields. */
87 const char* message = "Unexpected size for UNITY_STORAGE_T struct. Please check that "
88 "the initialization of the Unity symbol in unity.c is "
89 "still correct.";
90
91 /* Define a structure with all the same fields as `struct UNITY_STORAGE_T`. */
92 #ifdef UNITY_EXCLUDE_DETAILS
93 struct {
94 const char* TestFile;
95 const char* CurrentTestName;
96 UNITY_LINE_TYPE CurrentTestLineNumber;
97 UNITY_COUNTER_TYPE NumberOfTests;
98 UNITY_COUNTER_TYPE TestFailures;
99 UNITY_COUNTER_TYPE TestIgnores;
100 UNITY_COUNTER_TYPE CurrentTestFailed;
101 UNITY_COUNTER_TYPE CurrentTestIgnored;
102 #ifndef UNITY_EXCLUDE_SETJMP_H
103 jmp_buf AbortFrame;
104 #endif
105 } _Expected_Unity;
106 #else
107 struct {
108 const char* TestFile;
109 const char* CurrentTestName;
110 const char* CurrentDetails1;
111 const char* CurrentDetails2;
112 UNITY_LINE_TYPE CurrentTestLineNumber;
113 UNITY_COUNTER_TYPE NumberOfTests;
114 UNITY_COUNTER_TYPE TestFailures;
115 UNITY_COUNTER_TYPE TestIgnores;
116 UNITY_COUNTER_TYPE CurrentTestFailed;
117 UNITY_COUNTER_TYPE CurrentTestIgnored;
118 #ifndef UNITY_EXCLUDE_SETJMP_H
119 jmp_buf AbortFrame;
120 #endif
121 } _Expected_Unity;
122 #endif
123
124 /* Compare our fake structure's size to the actual structure's size. They
125 * should be the same.
126 *
127 * This accounts for alignment, padding, and packing issues that might come
128 * up between different architectures. */
129 TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message);
130 }
131
testPassShouldEndImmediatelyWithPass(void)132 void testPassShouldEndImmediatelyWithPass(void)
133 {
134 TEST_PASS();
135 TEST_FAIL_MESSAGE("We should have passed already and finished this test");
136 }
137
testTrue(void)138 void testTrue(void)
139 {
140 TEST_ASSERT(1);
141
142 TEST_ASSERT_TRUE(1);
143 }
144
testFalse(void)145 void testFalse(void)
146 {
147 TEST_ASSERT_FALSE(0);
148
149 TEST_ASSERT_UNLESS(0);
150 }
151
testPreviousPass(void)152 void testPreviousPass(void)
153 {
154 TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
155 }
156
testNotVanilla(void)157 void testNotVanilla(void)
158 {
159 EXPECT_ABORT_BEGIN
160 TEST_ASSERT(0);
161 VERIFY_FAILS_END
162 }
163
testNotTrue(void)164 void testNotTrue(void)
165 {
166 EXPECT_ABORT_BEGIN
167 TEST_ASSERT_TRUE(0);
168 VERIFY_FAILS_END
169 }
170
testNotFalse(void)171 void testNotFalse(void)
172 {
173 EXPECT_ABORT_BEGIN
174 TEST_ASSERT_FALSE(1);
175 VERIFY_FAILS_END
176 }
177
testNotUnless(void)178 void testNotUnless(void)
179 {
180 EXPECT_ABORT_BEGIN
181 TEST_ASSERT_UNLESS(1);
182 VERIFY_FAILS_END
183 }
184
testNotNotEqual(void)185 void testNotNotEqual(void)
186 {
187 EXPECT_ABORT_BEGIN
188 TEST_ASSERT_NOT_EQUAL(10, 10);
189 VERIFY_FAILS_END
190 }
191
testFail(void)192 void testFail(void)
193 {
194 EXPECT_ABORT_BEGIN
195 TEST_FAIL_MESSAGE("Expected for testing");
196 VERIFY_FAILS_END
197 }
198
testIsNull(void)199 void testIsNull(void)
200 {
201 char* ptr1 = NULL;
202 const char* ptr2 = "hello";
203
204 TEST_ASSERT_NULL(ptr1);
205 TEST_ASSERT_NOT_NULL(ptr2);
206 }
207
testIsNullShouldFailIfNot(void)208 void testIsNullShouldFailIfNot(void)
209 {
210 const char* ptr1 = "hello";
211
212 EXPECT_ABORT_BEGIN
213 TEST_ASSERT_NULL(ptr1);
214 VERIFY_FAILS_END
215 }
216
testNotNullShouldFailIfNULL(void)217 void testNotNullShouldFailIfNULL(void)
218 {
219 char* ptr1 = NULL;
220
221 EXPECT_ABORT_BEGIN
222 TEST_ASSERT_NOT_NULL(ptr1);
223 VERIFY_FAILS_END
224 }
225
testIgnore(void)226 void testIgnore(void)
227 {
228 EXPECT_ABORT_BEGIN
229 TEST_IGNORE();
230 TEST_FAIL_MESSAGE("This should not be reached");
231 VERIFY_IGNORES_END
232 }
233
testIgnoreMessage(void)234 void testIgnoreMessage(void)
235 {
236 EXPECT_ABORT_BEGIN
237 TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!");
238 TEST_FAIL_MESSAGE("This should not be reached");
239 VERIFY_IGNORES_END
240 }
241
testNotEqualInts(void)242 void testNotEqualInts(void)
243 {
244 EXPECT_ABORT_BEGIN
245 TEST_ASSERT_EQUAL_INT(3982, 3983);
246 VERIFY_FAILS_END
247 }
248
testNotEqualInt8s(void)249 void testNotEqualInt8s(void)
250 {
251 EXPECT_ABORT_BEGIN
252 TEST_ASSERT_EQUAL_INT8(-127, -126);
253 VERIFY_FAILS_END
254 }
255
testNotEqualInt16s(void)256 void testNotEqualInt16s(void)
257 {
258 EXPECT_ABORT_BEGIN
259 TEST_ASSERT_EQUAL_INT16(-16383, -16382);
260 VERIFY_FAILS_END
261 }
262
testNotEqualInt32s(void)263 void testNotEqualInt32s(void)
264 {
265 EXPECT_ABORT_BEGIN
266 TEST_ASSERT_EQUAL_INT32(-2147483647, -2147483648); //use largest 32 bit negative to test printability
267 VERIFY_FAILS_END
268 }
269
testNotEqualBits(void)270 void testNotEqualBits(void)
271 {
272 EXPECT_ABORT_BEGIN
273 TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55);
274 VERIFY_FAILS_END
275 }
276
testNotEqualUInts(void)277 void testNotEqualUInts(void)
278 {
279 UNITY_UINT16 v0, v1;
280
281 v0 = 9000;
282 v1 = 9001;
283
284 EXPECT_ABORT_BEGIN
285 TEST_ASSERT_EQUAL_UINT(v0, v1);
286 VERIFY_FAILS_END
287 }
288
testNotEqualUInt8s(void)289 void testNotEqualUInt8s(void)
290 {
291 UNITY_UINT8 v0, v1;
292
293 v0 = 254;
294 v1 = 255;
295
296 EXPECT_ABORT_BEGIN
297 TEST_ASSERT_EQUAL_UINT8(v0, v1);
298 VERIFY_FAILS_END
299 }
300
testNotEqualUInt16s(void)301 void testNotEqualUInt16s(void)
302 {
303 UNITY_UINT16 v0, v1;
304
305 v0 = 65535;
306 v1 = 65534;
307
308 EXPECT_ABORT_BEGIN
309 TEST_ASSERT_EQUAL_UINT16(v0, v1);
310 VERIFY_FAILS_END
311 }
312
testNotEqualUInt32s(void)313 void testNotEqualUInt32s(void)
314 {
315 UNITY_UINT32 v0, v1;
316
317 v0 = 4294967295;
318 v1 = 4294967294;
319
320 EXPECT_ABORT_BEGIN
321 TEST_ASSERT_EQUAL_UINT32(v0, v1);
322 VERIFY_FAILS_END
323 }
324
testNotEqualHex8s(void)325 void testNotEqualHex8s(void)
326 {
327 UNITY_UINT8 v0, v1;
328
329 v0 = 0x23;
330 v1 = 0x22;
331
332 EXPECT_ABORT_BEGIN
333 TEST_ASSERT_EQUAL_HEX8(v0, v1);
334 VERIFY_FAILS_END
335 }
336
testNotEqualHex8sIfSigned(void)337 void testNotEqualHex8sIfSigned(void)
338 {
339 UNITY_INT8 v0, v1;
340
341 v0 = -2;
342 v1 = 2;
343
344 EXPECT_ABORT_BEGIN
345 TEST_ASSERT_EQUAL_HEX8(v0, v1);
346 VERIFY_FAILS_END
347 }
348
testNotEqualHex16s(void)349 void testNotEqualHex16s(void)
350 {
351 UNITY_UINT16 v0, v1;
352
353 v0 = 0x1234;
354 v1 = 0x1235;
355
356 EXPECT_ABORT_BEGIN
357 TEST_ASSERT_EQUAL_HEX16(v0, v1);
358 VERIFY_FAILS_END
359 }
360
testNotEqualHex16sIfSigned(void)361 void testNotEqualHex16sIfSigned(void)
362 {
363 UNITY_INT16 v0, v1;
364
365 v0 = -1024;
366 v1 = -1028;
367
368 EXPECT_ABORT_BEGIN
369 TEST_ASSERT_EQUAL_HEX16(v0, v1);
370 VERIFY_FAILS_END
371 }
372
testNotEqualHex32s(void)373 void testNotEqualHex32s(void)
374 {
375 UNITY_UINT32 v0, v1;
376
377 v0 = 900000;
378 v1 = 900001;
379
380 EXPECT_ABORT_BEGIN
381 TEST_ASSERT_EQUAL_HEX32(v0, v1);
382 VERIFY_FAILS_END
383 }
384
testNotEqualHex32sIfSigned(void)385 void testNotEqualHex32sIfSigned(void)
386 {
387 UNITY_INT32 v0, v1;
388
389 v0 = -900000;
390 v1 = 900001;
391
392 EXPECT_ABORT_BEGIN
393 TEST_ASSERT_EQUAL_HEX32(v0, v1);
394 VERIFY_FAILS_END
395 }
396
testEqualInts(void)397 void testEqualInts(void)
398 {
399 int v0, v1;
400 int *p0, *p1;
401
402 v0 = 19467;
403 v1 = 19467;
404 p0 = &v0;
405 p1 = &v1;
406
407 TEST_ASSERT_EQUAL_INT(1837, 1837);
408 TEST_ASSERT_EQUAL_INT(-27365, -27365);
409 TEST_ASSERT_EQUAL_INT(v0, v1);
410 TEST_ASSERT_EQUAL_INT(19467, v1);
411 TEST_ASSERT_EQUAL_INT(v0, 19467);
412 TEST_ASSERT_EQUAL_INT(*p0, v1);
413 TEST_ASSERT_EQUAL_INT(*p0, *p1);
414 TEST_ASSERT_EQUAL_INT(*p0, 19467);
415 }
416
testEqualInt8s(void)417 void testEqualInt8s(void)
418 {
419 UNITY_INT8 v0, v1;
420 UNITY_INT8 *p0, *p1;
421
422 v0 = 0x22;
423 v1 = 0x22;
424 p0 = &v0;
425 p1 = &v1;
426
427 TEST_ASSERT_EQUAL_INT8(0x22, 0x22);
428 TEST_ASSERT_EQUAL_INT8(v0, v1);
429 TEST_ASSERT_EQUAL_INT8(0x22, v1);
430 TEST_ASSERT_EQUAL_INT8(v0, 0x22);
431 TEST_ASSERT_EQUAL_INT8(*p0, v1);
432 TEST_ASSERT_EQUAL_INT8(*p0, *p1);
433 TEST_ASSERT_EQUAL_INT8(*p0, 0x22);
434 }
435
testEqualInt8sWhenThereAreDifferencesOutside8Bits(void)436 void testEqualInt8sWhenThereAreDifferencesOutside8Bits(void)
437 {
438 TEST_ASSERT_EQUAL_INT8(0x321,0x421);
439 TEST_ASSERT_EQUAL_INT8(0xFF21,0x0021);
440 }
441
testEqualInt16s(void)442 void testEqualInt16s(void)
443 {
444 UNITY_INT16 v0, v1;
445 UNITY_INT16 *p0, *p1;
446
447 v0 = 0x7876;
448 v1 = 0x7876;
449 p0 = &v0;
450 p1 = &v1;
451
452 TEST_ASSERT_EQUAL_INT16(0x7876, 0x7876);
453 TEST_ASSERT_EQUAL_INT16(v0, v1);
454 TEST_ASSERT_EQUAL_INT16(0x7876, v1);
455 TEST_ASSERT_EQUAL_INT16(v0, 0x7876);
456 TEST_ASSERT_EQUAL_INT16(*p0, v1);
457 TEST_ASSERT_EQUAL_INT16(*p0, *p1);
458 TEST_ASSERT_EQUAL_INT16(*p0, 0x7876);
459 }
460
testEqualInt16sNegatives(void)461 void testEqualInt16sNegatives(void)
462 {
463 UNITY_INT16 v0, v1;
464 UNITY_INT16 *p0, *p1;
465
466 v0 = -7876;
467 v1 = -7876;
468 p0 = &v0;
469 p1 = &v1;
470
471 TEST_ASSERT_EQUAL_INT16(-7876, -7876);
472 TEST_ASSERT_EQUAL_INT16(v0, v1);
473 TEST_ASSERT_EQUAL_INT16(-7876, v1);
474 TEST_ASSERT_EQUAL_INT16(v0, -7876);
475 TEST_ASSERT_EQUAL_INT16(*p0, v1);
476 TEST_ASSERT_EQUAL_INT16(*p0, *p1);
477 TEST_ASSERT_EQUAL_INT16(*p0, -7876);
478 }
479
testEqualInt16sWhenThereAreDifferencesOutside16Bits(void)480 void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void)
481 {
482 TEST_ASSERT_EQUAL_INT16(0x54321,0x64321);
483 TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321);
484 }
485
testEqualInt32s(void)486 void testEqualInt32s(void)
487 {
488 UNITY_INT32 v0, v1;
489 UNITY_INT32 *p0, *p1;
490
491 v0 = 0x78760000;
492 v1 = 0x78760000;
493 p0 = &v0;
494 p1 = &v1;
495
496 TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000);
497 TEST_ASSERT_EQUAL_INT32(v0, v1);
498 TEST_ASSERT_EQUAL_INT32(0x78760000, v1);
499 TEST_ASSERT_EQUAL_INT32(v0, 0x78760000);
500 TEST_ASSERT_EQUAL_INT32(*p0, v1);
501 TEST_ASSERT_EQUAL_INT32(*p0, *p1);
502 TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000);
503 }
504
testEqualInt32sNegatives(void)505 void testEqualInt32sNegatives(void)
506 {
507 UNITY_INT32 v0, v1;
508 UNITY_INT32 *p0, *p1;
509
510 v0 = -123456789;
511 v1 = -123456789;
512 p0 = &v0;
513 p1 = &v1;
514
515 TEST_ASSERT_EQUAL_INT32(-123456789, -123456789);
516 TEST_ASSERT_EQUAL_INT32(v0, v1);
517 TEST_ASSERT_EQUAL_INT32(-123456789, v1);
518 TEST_ASSERT_EQUAL_INT32(v0, -123456789);
519 TEST_ASSERT_EQUAL_INT32(*p0, v1);
520 TEST_ASSERT_EQUAL_INT32(*p0, *p1);
521 TEST_ASSERT_EQUAL_INT32(*p0, -123456789);
522 }
523
524
testEqualUints(void)525 void testEqualUints(void)
526 {
527 unsigned int v0, v1;
528 unsigned int *p0, *p1;
529
530 v0 = 19467;
531 v1 = 19467;
532 p0 = &v0;
533 p1 = &v1;
534
535 TEST_ASSERT_EQUAL_UINT(1837, 1837);
536 TEST_ASSERT_EQUAL_UINT(v0, v1);
537 TEST_ASSERT_EQUAL_UINT(19467, v1);
538 TEST_ASSERT_EQUAL_UINT(v0, 19467);
539 TEST_ASSERT_EQUAL_UINT(*p0, v1);
540 TEST_ASSERT_EQUAL_UINT(*p0, *p1);
541 TEST_ASSERT_EQUAL_UINT(*p0, 19467);
542 TEST_ASSERT_EQUAL_UINT(60872u, 60872u);
543 }
544
545
testEqualUint8s(void)546 void testEqualUint8s(void)
547 {
548 UNITY_UINT8 v0, v1;
549 UNITY_UINT8 *p0, *p1;
550
551 v0 = 0x22;
552 v1 = 0x22;
553 p0 = &v0;
554 p1 = &v1;
555
556 TEST_ASSERT_EQUAL_UINT8(0x22, 0x22);
557 TEST_ASSERT_EQUAL_UINT8(v0, v1);
558 TEST_ASSERT_EQUAL_UINT8(0x22, v1);
559 TEST_ASSERT_EQUAL_UINT8(v0, 0x22);
560 TEST_ASSERT_EQUAL_UINT8(*p0, v1);
561 TEST_ASSERT_EQUAL_UINT8(*p0, *p1);
562 TEST_ASSERT_EQUAL_UINT8(*p0, 0x22);
563 }
564
testEqualUint8sWhenThereAreDifferencesOutside8Bits(void)565 void testEqualUint8sWhenThereAreDifferencesOutside8Bits(void)
566 {
567 TEST_ASSERT_EQUAL_UINT8(0x321,0x421);
568 TEST_ASSERT_EQUAL_UINT8(0xFF21,0x0021);
569 }
570
testEqualUint16s(void)571 void testEqualUint16s(void)
572 {
573 UNITY_UINT16 v0, v1;
574 UNITY_UINT16 *p0, *p1;
575
576 v0 = 0x9876;
577 v1 = 0x9876;
578 p0 = &v0;
579 p1 = &v1;
580
581 TEST_ASSERT_EQUAL_UINT16(0x9876, 0x9876);
582 TEST_ASSERT_EQUAL_UINT16(v0, v1);
583 TEST_ASSERT_EQUAL_UINT16(0x9876, v1);
584 TEST_ASSERT_EQUAL_UINT16(v0, 0x9876);
585 TEST_ASSERT_EQUAL_UINT16(*p0, v1);
586 TEST_ASSERT_EQUAL_UINT16(*p0, *p1);
587 TEST_ASSERT_EQUAL_UINT16(*p0, 0x9876);
588 }
589
testEqualUint16sWhenThereAreDifferencesOutside16Bits(void)590 void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void)
591 {
592 TEST_ASSERT_EQUAL_UINT16(0x54321,0x64321);
593 TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321);
594 }
595
testEqualUint32s(void)596 void testEqualUint32s(void)
597 {
598 UNITY_UINT32 v0, v1;
599 UNITY_UINT32 *p0, *p1;
600
601 v0 = 0x98760000;
602 v1 = 0x98760000;
603 p0 = &v0;
604 p1 = &v1;
605
606 TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000);
607 TEST_ASSERT_EQUAL_UINT32(v0, v1);
608 TEST_ASSERT_EQUAL_UINT32(0x98760000, v1);
609 TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000);
610 TEST_ASSERT_EQUAL_UINT32(*p0, v1);
611 TEST_ASSERT_EQUAL_UINT32(*p0, *p1);
612 TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000);
613 }
614
testNotEqual(void)615 void testNotEqual(void)
616 {
617 TEST_ASSERT_NOT_EQUAL(0, 1);
618 TEST_ASSERT_NOT_EQUAL(1, 0);
619 TEST_ASSERT_NOT_EQUAL(100, 101);
620 TEST_ASSERT_NOT_EQUAL(0, -1);
621 TEST_ASSERT_NOT_EQUAL(65535, -65535);
622 TEST_ASSERT_NOT_EQUAL(75, 900);
623 TEST_ASSERT_NOT_EQUAL(-100, -101);
624 }
625
testEqualHex8s(void)626 void testEqualHex8s(void)
627 {
628 UNITY_UINT8 v0, v1;
629 UNITY_UINT8 *p0, *p1;
630
631 v0 = 0x22;
632 v1 = 0x22;
633 p0 = &v0;
634 p1 = &v1;
635
636 TEST_ASSERT_EQUAL_HEX8(0x22, 0x22);
637 TEST_ASSERT_EQUAL_HEX8(v0, v1);
638 TEST_ASSERT_EQUAL_HEX8(0x22, v1);
639 TEST_ASSERT_EQUAL_HEX8(v0, 0x22);
640 TEST_ASSERT_EQUAL_HEX8(*p0, v1);
641 TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
642 TEST_ASSERT_EQUAL_HEX8(*p0, 0x22);
643 }
644
testEqualHex8sWhenThereAreDifferencesOutside8Bits(void)645 void testEqualHex8sWhenThereAreDifferencesOutside8Bits(void)
646 {
647 TEST_ASSERT_EQUAL_HEX8(0x321,0x421);
648 TEST_ASSERT_EQUAL_HEX8(0xFF21,0x0021);
649 }
650
testEqualHex8sNegatives(void)651 void testEqualHex8sNegatives(void)
652 {
653 UNITY_UINT8 v0, v1;
654 UNITY_UINT8 *p0, *p1;
655
656 v0 = 0xDD;
657 v1 = 0xDD;
658 p0 = &v0;
659 p1 = &v1;
660
661 TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD);
662 TEST_ASSERT_EQUAL_HEX8(v0, v1);
663 TEST_ASSERT_EQUAL_HEX8(0xDD, v1);
664 TEST_ASSERT_EQUAL_HEX8(v0, 0xDD);
665 TEST_ASSERT_EQUAL_HEX8(*p0, v1);
666 TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
667 TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD);
668 }
669
testEqualHex16s(void)670 void testEqualHex16s(void)
671 {
672 UNITY_UINT16 v0, v1;
673 UNITY_UINT16 *p0, *p1;
674
675 v0 = 0x9876;
676 v1 = 0x9876;
677 p0 = &v0;
678 p1 = &v1;
679
680 TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876);
681 TEST_ASSERT_EQUAL_HEX16(v0, v1);
682 TEST_ASSERT_EQUAL_HEX16(0x9876, v1);
683 TEST_ASSERT_EQUAL_HEX16(v0, 0x9876);
684 TEST_ASSERT_EQUAL_HEX16(*p0, v1);
685 TEST_ASSERT_EQUAL_HEX16(*p0, *p1);
686 TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876);
687 }
688
testEqualHex16sWhenThereAreDifferencesOutside16Bits(void)689 void testEqualHex16sWhenThereAreDifferencesOutside16Bits(void)
690 {
691 TEST_ASSERT_EQUAL_HEX16(0x54321,0x64321);
692 TEST_ASSERT_EQUAL_HEX16(0xFFFF4321,0x00004321);
693 }
694
testEqualHex32s(void)695 void testEqualHex32s(void)
696 {
697 UNITY_UINT32 v0, v1;
698 UNITY_UINT32 *p0, *p1;
699
700 v0 = 0x98765432ul;
701 v1 = 0x98765432ul;
702 p0 = &v0;
703 p1 = &v1;
704
705 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul);
706 TEST_ASSERT_EQUAL_HEX32(v0, v1);
707 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1);
708 TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul);
709 TEST_ASSERT_EQUAL_HEX32(*p0, v1);
710 TEST_ASSERT_EQUAL_HEX32(*p0, *p1);
711 TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul);
712 }
713
testEqualBits(void)714 void testEqualBits(void)
715 {
716 UNITY_UINT32 v0 = 0xFF55AA00;
717 UNITY_UINT32 v1 = 0x55550000;
718
719 TEST_ASSERT_BITS(v1, v0, 0x55550000);
720 TEST_ASSERT_BITS(v1, v0, 0xFF55CC00);
721 TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00);
722 TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0);
723 TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F);
724 TEST_ASSERT_BITS_HIGH(v1, v0);
725 TEST_ASSERT_BITS_LOW(0x000055FF, v0);
726 TEST_ASSERT_BIT_HIGH(30, v0);
727 TEST_ASSERT_BIT_LOW(5, v0);
728 }
729
testNotEqualBitHigh(void)730 void testNotEqualBitHigh(void)
731 {
732 UNITY_UINT32 v0 = 0x7F55AA00;
733
734 EXPECT_ABORT_BEGIN
735 TEST_ASSERT_BIT_HIGH(31, v0);
736 VERIFY_FAILS_END
737 }
738
testNotEqualBitLow(void)739 void testNotEqualBitLow(void)
740 {
741 UNITY_UINT32 v0 = 0xFF55AA00;
742
743 EXPECT_ABORT_BEGIN
744 TEST_ASSERT_BIT_LOW(30, v0);
745 VERIFY_FAILS_END
746 }
747
testNotEqualBitsHigh(void)748 void testNotEqualBitsHigh(void)
749 {
750 UNITY_UINT32 v0 = 0xFF55AA00;
751 UNITY_UINT32 v1 = 0x55550000;
752
753 EXPECT_ABORT_BEGIN
754 TEST_ASSERT_BITS_HIGH(v0, v1);
755 VERIFY_FAILS_END
756
757 }
758
testNotEqualBitsLow(void)759 void testNotEqualBitsLow(void)
760 {
761 UNITY_UINT32 v0 = 0xFF55AA00;
762 UNITY_UINT32 v1 = 0x55550000;
763
764 EXPECT_ABORT_BEGIN
765 TEST_ASSERT_BITS_LOW(v0, v1);
766 VERIFY_FAILS_END
767 }
768
769
testEqualShorts(void)770 void testEqualShorts(void)
771 {
772 short v0, v1;
773 short *p0, *p1;
774
775 v0 = 19467;
776 v1 = 19467;
777 p0 = &v0;
778 p1 = &v1;
779
780 TEST_ASSERT_EQUAL_INT(1837, 1837);
781 TEST_ASSERT_EQUAL_INT(-2987, -2987);
782 TEST_ASSERT_EQUAL_INT(v0, v1);
783 TEST_ASSERT_EQUAL_INT(19467, v1);
784 TEST_ASSERT_EQUAL_INT(v0, 19467);
785 TEST_ASSERT_EQUAL_INT(*p0, v1);
786 TEST_ASSERT_EQUAL_INT(*p0, *p1);
787 TEST_ASSERT_EQUAL_INT(*p0, 19467);
788 }
789
testEqualUShorts(void)790 void testEqualUShorts(void)
791 {
792 unsigned short v0, v1;
793 unsigned short *p0, *p1;
794
795 v0 = 19467;
796 v1 = 19467;
797 p0 = &v0;
798 p1 = &v1;
799
800 TEST_ASSERT_EQUAL_UINT(1837, 1837);
801 TEST_ASSERT_EQUAL_UINT(2987, 2987);
802 TEST_ASSERT_EQUAL_UINT(v0, v1);
803 TEST_ASSERT_EQUAL_UINT(19467, v1);
804 TEST_ASSERT_EQUAL_UINT(v0, 19467);
805 TEST_ASSERT_EQUAL_UINT(*p0, v1);
806 TEST_ASSERT_EQUAL_UINT(*p0, *p1);
807 TEST_ASSERT_EQUAL_UINT(*p0, 19467);
808 }
809
testEqualChars(void)810 void testEqualChars(void)
811 {
812 signed char v0, v1;
813 signed char *p0, *p1;
814
815 v0 = 109;
816 v1 = 109;
817 p0 = &v0;
818 p1 = &v1;
819
820 TEST_ASSERT_EQUAL_INT(42, 42);
821 TEST_ASSERT_EQUAL_INT(-116, -116);
822 TEST_ASSERT_EQUAL_INT(v0, v1);
823 TEST_ASSERT_EQUAL_INT(109, v1);
824 TEST_ASSERT_EQUAL_INT(v0, 109);
825 TEST_ASSERT_EQUAL_INT(*p0, v1);
826 TEST_ASSERT_EQUAL_INT(*p0, *p1);
827 TEST_ASSERT_EQUAL_INT(*p0, 109);
828 }
829
testEqualUChars(void)830 void testEqualUChars(void)
831 {
832 unsigned char v0, v1;
833 unsigned char *p0, *p1;
834
835 v0 = 251;
836 v1 = 251;
837 p0 = &v0;
838 p1 = &v1;
839
840 TEST_ASSERT_EQUAL_INT(42, 42);
841 TEST_ASSERT_EQUAL_INT(v0, v1);
842 TEST_ASSERT_EQUAL_INT(251, v1);
843 TEST_ASSERT_EQUAL_INT(v0, 251);
844 TEST_ASSERT_EQUAL_INT(*p0, v1);
845 TEST_ASSERT_EQUAL_INT(*p0, *p1);
846 TEST_ASSERT_EQUAL_INT(*p0, 251);
847 }
848
testEqualPointers(void)849 void testEqualPointers(void)
850 {
851 int v0, v1;
852 int *p0, *p1, *p2;
853
854 v0 = 19467;
855 v1 = 18271;
856 p0 = &v0;
857 p1 = &v1;
858 p2 = &v1;
859
860 TEST_ASSERT_EQUAL_PTR(p0, &v0);
861 TEST_ASSERT_EQUAL_PTR(&v1, p1);
862 TEST_ASSERT_EQUAL_PTR(p2, p1);
863 TEST_ASSERT_EQUAL_PTR(&v0, &v0);
864 }
865
testNotEqualPointers(void)866 void testNotEqualPointers(void)
867 {
868 EXPECT_ABORT_BEGIN
869 TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677);
870 VERIFY_FAILS_END
871 }
872
testIntsWithinDelta(void)873 void testIntsWithinDelta(void)
874 {
875 TEST_ASSERT_INT_WITHIN(1, 5000, 5001);
876 TEST_ASSERT_INT_WITHIN(5, 5000, 4996);
877 TEST_ASSERT_INT_WITHIN(5, 5000, 5005);
878 TEST_ASSERT_INT_WITHIN(500, 50, -440);
879
880 TEST_ASSERT_INT_WITHIN(2, -1, -1);
881 TEST_ASSERT_INT_WITHIN(5, 1, -1);
882 TEST_ASSERT_INT_WITHIN(5, -1, 1);
883 }
884
testIntsWithinDeltaAndCustomMessage(void)885 void testIntsWithinDeltaAndCustomMessage(void)
886 {
887 TEST_ASSERT_INT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
888 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
889 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
890 TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message.");
891
892 TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message.");
893 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
894 TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message.");
895 }
896
testIntsNotWithinDelta(void)897 void testIntsNotWithinDelta(void)
898 {
899 EXPECT_ABORT_BEGIN
900 TEST_ASSERT_INT_WITHIN(5, 5000, 5006);
901 VERIFY_FAILS_END
902 }
903
testIntsNotWithinDeltaAndCustomMessage(void)904 void testIntsNotWithinDeltaAndCustomMessage(void)
905 {
906 EXPECT_ABORT_BEGIN
907 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5006, "Custom Message.");
908 VERIFY_FAILS_END
909 }
910
testUIntsWithinDelta(void)911 void testUIntsWithinDelta(void)
912 {
913 TEST_ASSERT_UINT_WITHIN(1, 5000, 5001);
914 TEST_ASSERT_UINT_WITHIN(5, 5000, 4996);
915 TEST_ASSERT_UINT_WITHIN(5, 5000, 5005);
916 }
917
testUIntsWithinDeltaAndCustomMessage(void)918 void testUIntsWithinDeltaAndCustomMessage(void)
919 {
920 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
921 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
922 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
923 }
924
testUIntsNotWithinDelta(void)925 void testUIntsNotWithinDelta(void)
926 {
927 EXPECT_ABORT_BEGIN
928 TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u);
929 VERIFY_FAILS_END
930 }
931
testUIntsNotWithinDeltaAndCustomMessage(void)932 void testUIntsNotWithinDeltaAndCustomMessage(void)
933 {
934 EXPECT_ABORT_BEGIN
935 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
936 VERIFY_FAILS_END
937 }
938
testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void)939 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void)
940 {
941 EXPECT_ABORT_BEGIN
942 TEST_ASSERT_UINT_WITHIN(5, 1, -1);
943 VERIFY_FAILS_END
944 }
945
testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void)946 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void)
947 {
948 EXPECT_ABORT_BEGIN
949 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
950 VERIFY_FAILS_END
951 }
952
testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void)953 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void)
954 {
955 EXPECT_ABORT_BEGIN
956 TEST_ASSERT_UINT_WITHIN(5, -1, 1);
957 VERIFY_FAILS_END
958 }
959
testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void)960 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void)
961 {
962 EXPECT_ABORT_BEGIN
963 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, -1, 1, "Custom Message.");
964 VERIFY_FAILS_END
965 }
966
testHEX32sWithinDelta(void)967 void testHEX32sWithinDelta(void)
968 {
969 TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001);
970 TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996);
971 TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005);
972 }
973
testHEX32sWithinDeltaAndCustomMessage(void)974 void testHEX32sWithinDeltaAndCustomMessage(void)
975 {
976 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
977 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
978 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
979 }
980
testHEX32sNotWithinDelta(void)981 void testHEX32sNotWithinDelta(void)
982 {
983 EXPECT_ABORT_BEGIN
984 TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u);
985 VERIFY_FAILS_END
986 }
987
testHEX32sNotWithinDeltaAndCustomMessage(void)988 void testHEX32sNotWithinDeltaAndCustomMessage(void)
989 {
990 EXPECT_ABORT_BEGIN
991 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
992 VERIFY_FAILS_END
993 }
994
testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)995 void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
996 {
997 EXPECT_ABORT_BEGIN
998 TEST_ASSERT_HEX32_WITHIN(5, 1, -1);
999 VERIFY_FAILS_END
1000 }
1001
testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)1002 void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)
1003 {
1004 EXPECT_ABORT_BEGIN
1005 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
1006 VERIFY_FAILS_END
1007 }
1008
testHEX16sWithinDelta(void)1009 void testHEX16sWithinDelta(void)
1010 {
1011 TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001);
1012 TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996);
1013 TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005);
1014 }
1015
testHEX16sWithinDeltaAndCustomMessage(void)1016 void testHEX16sWithinDeltaAndCustomMessage(void)
1017 {
1018 TEST_ASSERT_HEX16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
1019 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
1020 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
1021 }
1022
testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)1023 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
1024 {
1025 TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321);
1026 }
1027
testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)1028 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
1029 {
1030 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
1031 }
1032
testHEX16sNotWithinDelta(void)1033 void testHEX16sNotWithinDelta(void)
1034 {
1035 EXPECT_ABORT_BEGIN
1036 TEST_ASSERT_HEX16_WITHIN(2, 65535, 0);
1037 VERIFY_FAILS_END
1038 }
1039
testHEX16sNotWithinDeltaAndCustomMessage(void)1040 void testHEX16sNotWithinDeltaAndCustomMessage(void)
1041 {
1042 EXPECT_ABORT_BEGIN
1043 TEST_ASSERT_HEX16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message.");
1044 VERIFY_FAILS_END
1045 }
1046
testHEX8sWithinDelta(void)1047 void testHEX8sWithinDelta(void)
1048 {
1049 TEST_ASSERT_HEX8_WITHIN(1, 254, 255);
1050 TEST_ASSERT_HEX8_WITHIN(5, 251, 255);
1051 TEST_ASSERT_HEX8_WITHIN(5, 1, 4);
1052 }
1053
testHEX8sWithinDeltaAndCustomMessage(void)1054 void testHEX8sWithinDeltaAndCustomMessage(void)
1055 {
1056 TEST_ASSERT_HEX8_WITHIN_MESSAGE(1, 254, 255, "Custom Message.");
1057 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 251, 255, "Custom Message.");
1058 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
1059 }
1060
testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)1061 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
1062 {
1063 TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23);
1064 }
1065
testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)1066 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
1067 {
1068 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
1069 }
1070
testHEX8sNotWithinDelta(void)1071 void testHEX8sNotWithinDelta(void)
1072 {
1073 EXPECT_ABORT_BEGIN
1074 TEST_ASSERT_HEX8_WITHIN(2, 255, 0);
1075 VERIFY_FAILS_END
1076 }
1077
testHEX8sNotWithinDeltaAndCustomMessage(void)1078 void testHEX8sNotWithinDeltaAndCustomMessage(void)
1079 {
1080 EXPECT_ABORT_BEGIN
1081 TEST_ASSERT_HEX8_WITHIN_MESSAGE(2, 255, 0, "Custom Message.");
1082 VERIFY_FAILS_END
1083 }
1084
1085 //-----------------
1086
testUINT32sWithinDelta(void)1087 void testUINT32sWithinDelta(void)
1088 {
1089 TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001);
1090 TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996);
1091 TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005);
1092 }
1093
testUINT32sWithinDeltaAndCustomMessage(void)1094 void testUINT32sWithinDeltaAndCustomMessage(void)
1095 {
1096 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
1097 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
1098 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
1099 }
1100
testUINT32sNotWithinDelta(void)1101 void testUINT32sNotWithinDelta(void)
1102 {
1103 EXPECT_ABORT_BEGIN
1104 TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u);
1105 VERIFY_FAILS_END
1106 }
1107
testUINT32sNotWithinDeltaAndCustomMessage(void)1108 void testUINT32sNotWithinDeltaAndCustomMessage(void)
1109 {
1110 EXPECT_ABORT_BEGIN
1111 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
1112 VERIFY_FAILS_END
1113 }
1114
testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)1115 void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
1116 {
1117 EXPECT_ABORT_BEGIN
1118 TEST_ASSERT_UINT32_WITHIN(5, 1, -1);
1119 VERIFY_FAILS_END
1120 }
1121
testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)1122 void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)
1123 {
1124 EXPECT_ABORT_BEGIN
1125 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
1126 VERIFY_FAILS_END
1127 }
1128
testUINT16sWithinDelta(void)1129 void testUINT16sWithinDelta(void)
1130 {
1131 TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001);
1132 TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996);
1133 TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005);
1134 }
1135
testUINT16sWithinDeltaAndCustomMessage(void)1136 void testUINT16sWithinDeltaAndCustomMessage(void)
1137 {
1138 TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
1139 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
1140 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
1141 }
1142
testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)1143 void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
1144 {
1145 TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321);
1146 }
1147
testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)1148 void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
1149 {
1150 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
1151 }
1152
testUINT16sNotWithinDelta(void)1153 void testUINT16sNotWithinDelta(void)
1154 {
1155 EXPECT_ABORT_BEGIN
1156 TEST_ASSERT_UINT16_WITHIN(2, 65535, 0);
1157 VERIFY_FAILS_END
1158 }
1159
testUINT16sNotWithinDeltaAndCustomMessage(void)1160 void testUINT16sNotWithinDeltaAndCustomMessage(void)
1161 {
1162 EXPECT_ABORT_BEGIN
1163 TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message.");
1164 VERIFY_FAILS_END
1165 }
1166
testUINT8sWithinDelta(void)1167 void testUINT8sWithinDelta(void)
1168 {
1169 TEST_ASSERT_UINT8_WITHIN(1, 254, 255);
1170 TEST_ASSERT_UINT8_WITHIN(5, 251, 255);
1171 TEST_ASSERT_UINT8_WITHIN(5, 1, 4);
1172 }
1173
testUINT8sWithinDeltaAndCustomMessage(void)1174 void testUINT8sWithinDeltaAndCustomMessage(void)
1175 {
1176 TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message.");
1177 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message.");
1178 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
1179 }
1180
testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)1181 void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
1182 {
1183 TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23);
1184 }
1185
testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)1186 void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
1187 {
1188 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
1189 }
1190
testUINT8sNotWithinDelta(void)1191 void testUINT8sNotWithinDelta(void)
1192 {
1193 EXPECT_ABORT_BEGIN
1194 TEST_ASSERT_UINT8_WITHIN(2, 255, 0);
1195 VERIFY_FAILS_END
1196 }
1197
testUINT8sNotWithinDeltaAndCustomMessage(void)1198 void testUINT8sNotWithinDeltaAndCustomMessage(void)
1199 {
1200 EXPECT_ABORT_BEGIN
1201 TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message.");
1202 VERIFY_FAILS_END
1203 }
1204
testINT32sWithinDelta(void)1205 void testINT32sWithinDelta(void)
1206 {
1207 TEST_ASSERT_INT32_WITHIN(1, 5000, 5001);
1208 TEST_ASSERT_INT32_WITHIN(5, 1, -2);
1209 TEST_ASSERT_INT32_WITHIN(5, -2, 1);
1210 }
1211
testINT32sWithinDeltaAndCustomMessage(void)1212 void testINT32sWithinDeltaAndCustomMessage(void)
1213 {
1214 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
1215 }
1216
testINT32sNotWithinDelta(void)1217 void testINT32sNotWithinDelta(void)
1218 {
1219 EXPECT_ABORT_BEGIN
1220 TEST_ASSERT_INT32_WITHIN(1, -3, 1);
1221 VERIFY_FAILS_END
1222 }
1223
testINT32sNotWithinDeltaAndDifferenceOverflows(void)1224 void testINT32sNotWithinDeltaAndDifferenceOverflows(void)
1225 {
1226 EXPECT_ABORT_BEGIN
1227 TEST_ASSERT_INT32_WITHIN(1, -1, 0x7FFFFFFF);
1228 VERIFY_FAILS_END
1229 }
testINT32sNotWithinDeltaAndCustomMessage(void)1230 void testINT32sNotWithinDeltaAndCustomMessage(void)
1231 {
1232 EXPECT_ABORT_BEGIN
1233 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message.");
1234 VERIFY_FAILS_END
1235 }
1236
testINT16sWithinDelta(void)1237 void testINT16sWithinDelta(void)
1238 {
1239 TEST_ASSERT_INT16_WITHIN(1, 5000, 5001);
1240 TEST_ASSERT_INT16_WITHIN(5, 2, -2);
1241 TEST_ASSERT_INT16_WITHIN(5, -2, 2);
1242 }
1243
testINT16sWithinDeltaAndCustomMessage(void)1244 void testINT16sWithinDeltaAndCustomMessage(void)
1245 {
1246 TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
1247 }
1248
testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)1249 void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
1250 {
1251 TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321);
1252 }
1253
testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)1254 void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
1255 {
1256 TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
1257 }
1258
testINT16sNotWithinDelta(void)1259 void testINT16sNotWithinDelta(void)
1260 {
1261 EXPECT_ABORT_BEGIN
1262 TEST_ASSERT_INT16_WITHIN(2, 4, -2);
1263 VERIFY_FAILS_END
1264 }
1265
testINT16sNotWithinDeltaAndCustomMessage(void)1266 void testINT16sNotWithinDeltaAndCustomMessage(void)
1267 {
1268 EXPECT_ABORT_BEGIN
1269 TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message.");
1270 VERIFY_FAILS_END
1271 }
1272
testINT8sWithinDelta(void)1273 void testINT8sWithinDelta(void)
1274 {
1275 TEST_ASSERT_INT8_WITHIN(1, 127, 126);
1276 TEST_ASSERT_INT8_WITHIN(5, -2, 2);
1277 TEST_ASSERT_INT8_WITHIN(5, 2, -2);
1278 }
1279
testINT8sWithinDeltaAndCustomMessage(void)1280 void testINT8sWithinDeltaAndCustomMessage(void)
1281 {
1282 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
1283 }
1284
testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)1285 void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
1286 {
1287 TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23);
1288 }
1289
testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)1290 void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
1291 {
1292 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
1293 }
1294
testINT8sNotWithinDelta(void)1295 void testINT8sNotWithinDelta(void)
1296 {
1297 EXPECT_ABORT_BEGIN
1298 TEST_ASSERT_INT8_WITHIN(2, -3, 0);
1299 VERIFY_FAILS_END
1300 }
1301
testINT8sNotWithinDeltaAndCustomMessage(void)1302 void testINT8sNotWithinDeltaAndCustomMessage(void)
1303 {
1304 EXPECT_ABORT_BEGIN
1305 TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message.");
1306 VERIFY_FAILS_END
1307 }
1308
1309
1310 //-----------------
testGreaterThan(void)1311 void testGreaterThan(void)
1312 {
1313 UNITY_INT v0, v1;
1314 UNITY_INT *p0, *p1;
1315
1316 v0 = 0;
1317 v1 = 1;
1318 p0 = &v0;
1319 p1 = &v1;
1320
1321 TEST_ASSERT_GREATER_THAN(v0, v1);
1322 TEST_ASSERT_GREATER_THAN(*p0, v1);
1323 TEST_ASSERT_GREATER_THAN(v0, *p1);
1324 TEST_ASSERT_GREATER_THAN(*p0, *p1);
1325 }
1326
testGreaterThanINT(void)1327 void testGreaterThanINT(void)
1328 {
1329 UNITY_INT v0, v1;
1330 UNITY_INT *p0, *p1;
1331
1332 v0 = 302;
1333 v1 = 3334;
1334 p0 = &v0;
1335 p1 = &v1;
1336
1337 TEST_ASSERT_GREATER_THAN_INT(v0, v1);
1338 TEST_ASSERT_GREATER_THAN_INT(*p0, v1);
1339 TEST_ASSERT_GREATER_THAN_INT(v0, *p1);
1340 TEST_ASSERT_GREATER_THAN_INT(*p0, *p1);
1341 }
1342
1343
testGreaterThanINT8(void)1344 void testGreaterThanINT8(void)
1345 {
1346 UNITY_INT8 v0, v1;
1347 UNITY_INT8 *p0, *p1;
1348
1349 v0 = -128;
1350 v1 = 127;
1351 p0 = &v0;
1352 p1 = &v1;
1353
1354 TEST_ASSERT_GREATER_THAN_INT8(v0, v1);
1355 TEST_ASSERT_GREATER_THAN_INT8(*p0, v1);
1356 TEST_ASSERT_GREATER_THAN_INT8(v0, *p1);
1357 TEST_ASSERT_GREATER_THAN_INT8(*p0, *p1);
1358 }
1359
testGreaterThanINT16(void)1360 void testGreaterThanINT16(void)
1361 {
1362 UNITY_INT16 v0, v1;
1363 UNITY_INT16 *p0, *p1;
1364
1365 v0 = -32768;
1366 v1 = 32767;
1367 p0 = &v0;
1368 p1 = &v1;
1369
1370 TEST_ASSERT_GREATER_THAN_INT16(v0, v1);
1371 TEST_ASSERT_GREATER_THAN_INT16(*p0, v1);
1372 TEST_ASSERT_GREATER_THAN_INT16(v0, *p1);
1373 TEST_ASSERT_GREATER_THAN_INT16(*p0, *p1);
1374 }
1375
testGreaterThanINT32(void)1376 void testGreaterThanINT32(void)
1377 {
1378 UNITY_INT32 v0, v1;
1379 UNITY_INT32 *p0, *p1;
1380
1381 v0 = -214783648;
1382 v1 = 214783647;
1383 p0 = &v0;
1384 p1 = &v1;
1385
1386 TEST_ASSERT_GREATER_THAN_INT32(v0, v1);
1387 TEST_ASSERT_GREATER_THAN_INT32(*p0, v1);
1388 TEST_ASSERT_GREATER_THAN_INT32(v0, *p1);
1389 TEST_ASSERT_GREATER_THAN_INT32(*p0, *p1);
1390 }
1391
testGreaterThanUINT(void)1392 void testGreaterThanUINT(void)
1393 {
1394 UNITY_UINT v0, v1;
1395 UNITY_UINT *p0, *p1;
1396
1397 v0 = 0;
1398 v1 = 1;
1399 p0 = &v0;
1400 p1 = &v1;
1401
1402 TEST_ASSERT_GREATER_THAN_UINT(v0, v1);
1403 TEST_ASSERT_GREATER_THAN_UINT(*p0, v1);
1404 TEST_ASSERT_GREATER_THAN_UINT(v0, *p1);
1405 TEST_ASSERT_GREATER_THAN_UINT(*p0, *p1);
1406 }
1407
1408
testGreaterThanUINT8(void)1409 void testGreaterThanUINT8(void)
1410 {
1411 UNITY_UINT8 v0, v1;
1412 UNITY_UINT8 *p0, *p1;
1413
1414 v0 = 0;
1415 v1 = 255;
1416 p0 = &v0;
1417 p1 = &v1;
1418
1419 TEST_ASSERT_GREATER_THAN_UINT8(v0, v1);
1420 TEST_ASSERT_GREATER_THAN_UINT8(*p0, v1);
1421 TEST_ASSERT_GREATER_THAN_UINT8(v0, *p1);
1422 TEST_ASSERT_GREATER_THAN_UINT8(*p0, *p1);
1423 }
1424
testGreaterThanUINT16(void)1425 void testGreaterThanUINT16(void)
1426 {
1427 UNITY_UINT16 v0, v1;
1428 UNITY_UINT16 *p0, *p1;
1429
1430 v0 = 0;
1431 v1 = 65535;
1432 p0 = &v0;
1433 p1 = &v1;
1434
1435 TEST_ASSERT_GREATER_THAN_UINT16(v0, v1);
1436 TEST_ASSERT_GREATER_THAN_UINT16(*p0, v1);
1437 TEST_ASSERT_GREATER_THAN_UINT16(v0, *p1);
1438 TEST_ASSERT_GREATER_THAN_UINT16(*p0, *p1);
1439 }
1440
testGreaterThanUINT32(void)1441 void testGreaterThanUINT32(void)
1442 {
1443 UNITY_UINT32 v0, v1;
1444 UNITY_UINT32 *p0, *p1;
1445
1446 v0 = 0;
1447 v1 = 4294967295;
1448 p0 = &v0;
1449 p1 = &v1;
1450
1451 TEST_ASSERT_GREATER_THAN_UINT32(v0, v1);
1452 TEST_ASSERT_GREATER_THAN_UINT32(*p0, v1);
1453 TEST_ASSERT_GREATER_THAN_UINT32(v0, *p1);
1454 TEST_ASSERT_GREATER_THAN_UINT32(*p0, *p1);
1455 }
1456
testGreaterThanHEX8(void)1457 void testGreaterThanHEX8(void)
1458 {
1459 UNITY_UINT8 v0, v1;
1460 UNITY_UINT8 *p0, *p1;
1461
1462 v0 = 0x00;
1463 v1 = 0xFF;
1464 p0 = &v0;
1465 p1 = &v1;
1466
1467 TEST_ASSERT_GREATER_THAN_HEX8(v0, v1);
1468 TEST_ASSERT_GREATER_THAN_HEX8(*p0, v1);
1469 TEST_ASSERT_GREATER_THAN_HEX8(v0, *p1);
1470 TEST_ASSERT_GREATER_THAN_HEX8(*p0, *p1);
1471 }
1472
testGreaterThanHEX16(void)1473 void testGreaterThanHEX16(void)
1474 {
1475 UNITY_UINT16 v0, v1;
1476 UNITY_UINT16 *p0, *p1;
1477
1478 v0 = 0x0000;
1479 v1 = 0xFFFF;
1480 p0 = &v0;
1481 p1 = &v1;
1482
1483 TEST_ASSERT_GREATER_THAN_HEX16(v0, v1);
1484 TEST_ASSERT_GREATER_THAN_HEX16(*p0, v1);
1485 TEST_ASSERT_GREATER_THAN_HEX16(v0, *p1);
1486 TEST_ASSERT_GREATER_THAN_HEX16(*p0, *p1);
1487 }
1488
testGreaterThanHEX32(void)1489 void testGreaterThanHEX32(void)
1490 {
1491 UNITY_UINT32 v0, v1;
1492 UNITY_UINT32 *p0, *p1;
1493
1494 v0 = 0x00000000;
1495 v1 = 0xFFFFFFFF;
1496 p0 = &v0;
1497 p1 = &v1;
1498
1499 TEST_ASSERT_GREATER_THAN_HEX32(v0, v1);
1500 TEST_ASSERT_GREATER_THAN_HEX32(*p0, v1);
1501 TEST_ASSERT_GREATER_THAN_HEX32(v0, *p1);
1502 TEST_ASSERT_GREATER_THAN_HEX32(*p0, *p1);
1503 }
1504
1505
testNotGreaterThan(void)1506 void testNotGreaterThan(void)
1507 {
1508 EXPECT_ABORT_BEGIN
1509 TEST_ASSERT_GREATER_THAN(0, -1);
1510 VERIFY_FAILS_END
1511 }
1512
testLessThan(void)1513 void testLessThan(void)
1514 {
1515 UNITY_INT v0, v1;
1516 UNITY_INT *p0, *p1;
1517
1518 v0 = 0;
1519 v1 = -1;
1520 p0 = &v0;
1521 p1 = &v1;
1522
1523 TEST_ASSERT_LESS_THAN(v0, v1);
1524 TEST_ASSERT_LESS_THAN(*p0, v1);
1525 TEST_ASSERT_LESS_THAN(v0, *p1);
1526 TEST_ASSERT_LESS_THAN(*p0, *p1);
1527 }
1528
testLessThanINT(void)1529 void testLessThanINT(void)
1530 {
1531 UNITY_INT v0, v1;
1532 UNITY_INT *p0, *p1;
1533
1534 v0 = 3334;
1535 v1 = 302;
1536 p0 = &v0;
1537 p1 = &v1;
1538
1539 TEST_ASSERT_LESS_THAN_INT(v0, v1);
1540 TEST_ASSERT_LESS_THAN_INT(*p0, v1);
1541 TEST_ASSERT_LESS_THAN_INT(v0, *p1);
1542 TEST_ASSERT_LESS_THAN_INT(*p0, *p1);
1543 }
1544
1545
testLessThanINT8(void)1546 void testLessThanINT8(void)
1547 {
1548 UNITY_INT8 v0, v1;
1549 UNITY_INT8 *p0, *p1;
1550
1551 v0 = 127;
1552 v1 = -128;
1553 p0 = &v0;
1554 p1 = &v1;
1555
1556 TEST_ASSERT_LESS_THAN_INT8(v0, v1);
1557 TEST_ASSERT_LESS_THAN_INT8(*p0, v1);
1558 TEST_ASSERT_LESS_THAN_INT8(v0, *p1);
1559 TEST_ASSERT_LESS_THAN_INT8(*p0, *p1);
1560 }
1561
testLessThanINT16(void)1562 void testLessThanINT16(void)
1563 {
1564 UNITY_INT16 v0, v1;
1565 UNITY_INT16 *p0, *p1;
1566
1567 v0 = 32767;
1568 v1 = -32768;
1569 p0 = &v0;
1570 p1 = &v1;
1571
1572 TEST_ASSERT_LESS_THAN_INT16(v0, v1);
1573 TEST_ASSERT_LESS_THAN_INT16(*p0, v1);
1574 TEST_ASSERT_LESS_THAN_INT16(v0, *p1);
1575 TEST_ASSERT_LESS_THAN_INT16(*p0, *p1);
1576 }
1577
testLessThanINT32(void)1578 void testLessThanINT32(void)
1579 {
1580 UNITY_INT32 v0, v1;
1581 UNITY_INT32 *p0, *p1;
1582
1583 v0 = 214783647;
1584 v1 = -214783648;
1585 p0 = &v0;
1586 p1 = &v1;
1587
1588 TEST_ASSERT_LESS_THAN_INT32(v0, v1);
1589 TEST_ASSERT_LESS_THAN_INT32(*p0, v1);
1590 TEST_ASSERT_LESS_THAN_INT32(v0, *p1);
1591 TEST_ASSERT_LESS_THAN_INT32(*p0, *p1);
1592 }
1593
testLessThanUINT(void)1594 void testLessThanUINT(void)
1595 {
1596 UNITY_UINT v0, v1;
1597 UNITY_UINT *p0, *p1;
1598
1599 v0 = 1;
1600 v1 = 0;
1601 p0 = &v0;
1602 p1 = &v1;
1603
1604 TEST_ASSERT_LESS_THAN_UINT(v0, v1);
1605 TEST_ASSERT_LESS_THAN_UINT(*p0, v1);
1606 TEST_ASSERT_LESS_THAN_UINT(v0, *p1);
1607 TEST_ASSERT_LESS_THAN_UINT(*p0, *p1);
1608 }
1609
1610
testLessThanUINT8(void)1611 void testLessThanUINT8(void)
1612 {
1613 UNITY_UINT8 v0, v1;
1614 UNITY_UINT8 *p0, *p1;
1615
1616 v0 = 255;
1617 v1 = 0;
1618 p0 = &v0;
1619 p1 = &v1;
1620
1621 TEST_ASSERT_LESS_THAN_UINT8(v0, v1);
1622 TEST_ASSERT_LESS_THAN_UINT8(*p0, v1);
1623 TEST_ASSERT_LESS_THAN_UINT8(v0, *p1);
1624 TEST_ASSERT_LESS_THAN_UINT8(*p0, *p1);
1625 }
1626
testLessThanUINT16(void)1627 void testLessThanUINT16(void)
1628 {
1629 UNITY_UINT16 v0, v1;
1630 UNITY_UINT16 *p0, *p1;
1631
1632 v0 = 65535;
1633 v1 = 0;
1634 p0 = &v0;
1635 p1 = &v1;
1636
1637 TEST_ASSERT_LESS_THAN_UINT16(v0, v1);
1638 TEST_ASSERT_LESS_THAN_UINT16(*p0, v1);
1639 TEST_ASSERT_LESS_THAN_UINT16(v0, *p1);
1640 TEST_ASSERT_LESS_THAN_UINT16(*p0, *p1);
1641 }
1642
testLessThanUINT32(void)1643 void testLessThanUINT32(void)
1644 {
1645 UNITY_UINT32 v0, v1;
1646 UNITY_UINT32 *p0, *p1;
1647
1648 v0 = 4294967295;
1649 v1 = 0;
1650 p0 = &v0;
1651 p1 = &v1;
1652
1653 TEST_ASSERT_LESS_THAN_UINT32(v0, v1);
1654 TEST_ASSERT_LESS_THAN_UINT32(*p0, v1);
1655 TEST_ASSERT_LESS_THAN_UINT32(v0, *p1);
1656 TEST_ASSERT_LESS_THAN_UINT32(*p0, *p1);
1657 }
1658
testLessThanHEX8(void)1659 void testLessThanHEX8(void)
1660 {
1661 UNITY_UINT8 v0, v1;
1662 UNITY_UINT8 *p0, *p1;
1663
1664 v0 = 0xFF;
1665 v1 = 0x00;
1666 p0 = &v0;
1667 p1 = &v1;
1668
1669 TEST_ASSERT_LESS_THAN_HEX8(v0, v1);
1670 TEST_ASSERT_LESS_THAN_HEX8(*p0, v1);
1671 TEST_ASSERT_LESS_THAN_HEX8(v0, *p1);
1672 TEST_ASSERT_LESS_THAN_HEX8(*p0, *p1);
1673 }
1674
testLessThanHEX16(void)1675 void testLessThanHEX16(void)
1676 {
1677 UNITY_UINT16 v0, v1;
1678 UNITY_UINT16 *p0, *p1;
1679
1680 v0 = 0xFFFF;
1681 v1 = 0x0000;
1682 p0 = &v0;
1683 p1 = &v1;
1684
1685 TEST_ASSERT_LESS_THAN_HEX16(v0, v1);
1686 TEST_ASSERT_LESS_THAN_HEX16(*p0, v1);
1687 TEST_ASSERT_LESS_THAN_HEX16(v0, *p1);
1688 TEST_ASSERT_LESS_THAN_HEX16(*p0, *p1);
1689 }
1690
testLessThanHEX32(void)1691 void testLessThanHEX32(void)
1692 {
1693 UNITY_UINT32 v0, v1;
1694 UNITY_UINT32 *p0, *p1;
1695
1696 v0 = 0xFFFFFFFF;
1697 v1 = 0x00000000;
1698 p0 = &v0;
1699 p1 = &v1;
1700
1701 TEST_ASSERT_LESS_THAN_HEX32(v0, v1);
1702 TEST_ASSERT_LESS_THAN_HEX32(*p0, v1);
1703 TEST_ASSERT_LESS_THAN_HEX32(v0, *p1);
1704 TEST_ASSERT_LESS_THAN_HEX32(*p0, *p1);
1705 }
1706
1707
testNotLessThan(void)1708 void testNotLessThan(void)
1709 {
1710 EXPECT_ABORT_BEGIN
1711 TEST_ASSERT_LESS_THAN(0, 1);
1712 VERIFY_FAILS_END
1713 }
1714
1715
1716
1717 //-----------------
testEqualStrings(void)1718 void testEqualStrings(void)
1719 {
1720 const char *testString = "foo";
1721
1722 TEST_ASSERT_EQUAL_STRING(testString, testString);
1723 TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo");
1724 TEST_ASSERT_EQUAL_STRING("foo", testString);
1725 TEST_ASSERT_EQUAL_STRING(testString, "foo");
1726 TEST_ASSERT_EQUAL_STRING("", "");
1727 }
1728
testEqualStringsLen(void)1729 void testEqualStringsLen(void)
1730 {
1731 const char *testString = "foobar";
1732 TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString));
1733 TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba");
1734 TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3);
1735 TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3);
1736 TEST_ASSERT_EQUAL_STRING_LEN("", "", 3);
1737 }
1738
testEqualStringsWithCarriageReturnsAndLineFeeds(void)1739 void testEqualStringsWithCarriageReturnsAndLineFeeds(void)
1740 {
1741 const char *testString = "foo\r\nbar";
1742
1743 TEST_ASSERT_EQUAL_STRING(testString, testString);
1744 TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar");
1745 TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString);
1746 TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar");
1747 TEST_ASSERT_EQUAL_STRING("", "");
1748 }
1749
testNotEqualString1(void)1750 void testNotEqualString1(void)
1751 {
1752 EXPECT_ABORT_BEGIN
1753 TEST_ASSERT_EQUAL_STRING("foo", "bar");
1754 VERIFY_FAILS_END
1755 }
1756
testNotEqualStringLen1(void)1757 void testNotEqualStringLen1(void)
1758 {
1759 EXPECT_ABORT_BEGIN
1760 TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6);
1761 VERIFY_FAILS_END
1762 }
1763
testNotEqualString2(void)1764 void testNotEqualString2(void)
1765 {
1766 EXPECT_ABORT_BEGIN
1767 TEST_ASSERT_EQUAL_STRING("foo", "");
1768 VERIFY_FAILS_END
1769 }
1770
testNotEqualStringLen2(void)1771 void testNotEqualStringLen2(void)
1772 {
1773 EXPECT_ABORT_BEGIN
1774 TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3);
1775 VERIFY_FAILS_END
1776 }
1777
testNotEqualString3(void)1778 void testNotEqualString3(void)
1779 {
1780 EXPECT_ABORT_BEGIN
1781 TEST_ASSERT_EQUAL_STRING("", "bar");
1782 VERIFY_FAILS_END
1783 }
1784
testNotEqualStringLen3(void)1785 void testNotEqualStringLen3(void)
1786 {
1787 EXPECT_ABORT_BEGIN
1788 TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3);
1789 VERIFY_FAILS_END
1790 }
1791
testNotEqualString4(void)1792 void testNotEqualString4(void)
1793 {
1794 EXPECT_ABORT_BEGIN
1795 TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n");
1796 VERIFY_FAILS_END
1797 }
1798
testNotEqualStringLen4(void)1799 void testNotEqualStringLen4(void)
1800 {
1801 EXPECT_ABORT_BEGIN
1802 TEST_ASSERT_EQUAL_STRING_LEN("ba\r\x16", "ba\r\n", 4);
1803 VERIFY_FAILS_END
1804 }
1805
testNotEqualString5(void)1806 void testNotEqualString5(void)
1807 {
1808 const char str1[] = { 0x41, 0x42, 0x03, 0x00 };
1809 const char str2[] = { 0x41, 0x42, 0x04, 0x00 };
1810 EXPECT_ABORT_BEGIN
1811 TEST_ASSERT_EQUAL_STRING(str1, str2);
1812 VERIFY_FAILS_END
1813 }
1814
testNotEqualString_ExpectedStringIsNull(void)1815 void testNotEqualString_ExpectedStringIsNull(void)
1816 {
1817 EXPECT_ABORT_BEGIN
1818 TEST_ASSERT_EQUAL_STRING(NULL, "bar");
1819 VERIFY_FAILS_END
1820 }
1821
testNotEqualStringLen_ExpectedStringIsNull(void)1822 void testNotEqualStringLen_ExpectedStringIsNull(void)
1823 {
1824 EXPECT_ABORT_BEGIN
1825 TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1);
1826 VERIFY_FAILS_END
1827 }
1828
testNotEqualString_ActualStringIsNull(void)1829 void testNotEqualString_ActualStringIsNull(void)
1830 {
1831 EXPECT_ABORT_BEGIN
1832 TEST_ASSERT_EQUAL_STRING("foo", NULL);
1833 VERIFY_FAILS_END
1834 }
1835
testNotEqualStringLen_ActualStringIsNull(void)1836 void testNotEqualStringLen_ActualStringIsNull(void)
1837 {
1838 EXPECT_ABORT_BEGIN
1839 TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1);
1840 VERIFY_FAILS_END
1841 }
1842
testEqualStringArrays(void)1843 void testEqualStringArrays(void)
1844 {
1845 const char *testStrings[] = { "foo", "boo", "woo", "moo" };
1846 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
1847
1848 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3);
1849 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3);
1850 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2);
1851 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1);
1852 }
1853
testNotEqualStringArray1(void)1854 void testNotEqualStringArray1(void)
1855 {
1856 const char *testStrings[] = { "foo", "boo", "woo", "moo" };
1857 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
1858
1859 EXPECT_ABORT_BEGIN
1860 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1861 VERIFY_FAILS_END
1862 }
1863
testNotEqualStringArray2(void)1864 void testNotEqualStringArray2(void)
1865 {
1866 const char *testStrings[] = { "zoo", "boo", "woo", "moo" };
1867 const char *expStrings[] = { "foo", "boo", "woo", "moo" };
1868
1869 EXPECT_ABORT_BEGIN
1870 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1871 VERIFY_FAILS_END
1872 }
1873
testNotEqualStringArray3(void)1874 void testNotEqualStringArray3(void)
1875 {
1876 const char *testStrings[] = { "foo", "boo", "woo", NULL };
1877 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
1878
1879 EXPECT_ABORT_BEGIN
1880 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1881 VERIFY_FAILS_END
1882 }
1883
testNotEqualStringArray4(void)1884 void testNotEqualStringArray4(void)
1885 {
1886 const char *testStrings[] = { "foo", "boo", "woo", "moo" };
1887 const char *expStrings[] = { "foo", NULL, "woo", "moo" };
1888
1889 EXPECT_ABORT_BEGIN
1890 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1891 VERIFY_FAILS_END
1892 }
1893
testNotEqualStringArray5(void)1894 void testNotEqualStringArray5(void)
1895 {
1896 const char **testStrings = NULL;
1897 const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
1898
1899 EXPECT_ABORT_BEGIN
1900 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1901 VERIFY_FAILS_END
1902 }
1903
testNotEqualStringArray6(void)1904 void testNotEqualStringArray6(void)
1905 {
1906 const char *testStrings[] = { "foo", "boo", "woo", "zoo" };
1907 const char **expStrings = NULL;
1908
1909 EXPECT_ABORT_BEGIN
1910 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1911 VERIFY_FAILS_END
1912 }
1913
testEqualStringArrayIfBothNulls(void)1914 void testEqualStringArrayIfBothNulls(void)
1915 {
1916 const char **testStrings = NULL;
1917 const char **expStrings = NULL;
1918
1919 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
1920 }
1921
testNotEqualStringArrayLengthZero(void)1922 void testNotEqualStringArrayLengthZero(void)
1923 {
1924 const char *testStrings[] = {NULL};
1925 const char **expStrings = NULL;
1926
1927 EXPECT_ABORT_BEGIN
1928 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0);
1929 VERIFY_FAILS_END
1930 }
1931
testEqualStringEachEqual(void)1932 void testEqualStringEachEqual(void)
1933 {
1934 const char *testStrings1[] = { "foo", "foo", "foo", "foo" };
1935 const char *testStrings2[] = { "boo", "boo", "boo", "zoo" };
1936 const char *testStrings3[] = { "", "", "", "" };
1937
1938 TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 4);
1939 TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 1);
1940 TEST_ASSERT_EACH_EQUAL_STRING("boo", testStrings2, 3);
1941 TEST_ASSERT_EACH_EQUAL_STRING("", testStrings3, 4);
1942 }
1943
testNotEqualStringEachEqual1(void)1944 void testNotEqualStringEachEqual1(void)
1945 {
1946 const char *testStrings[] = { "foo", "foo", "foo", "moo" };
1947
1948 EXPECT_ABORT_BEGIN
1949 TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
1950 VERIFY_FAILS_END
1951 }
1952
testNotEqualStringEachEqual2(void)1953 void testNotEqualStringEachEqual2(void)
1954 {
1955 const char *testStrings[] = { "boo", "foo", "foo", "foo" };
1956
1957 EXPECT_ABORT_BEGIN
1958 TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
1959 VERIFY_FAILS_END
1960 }
1961
testNotEqualStringEachEqual3(void)1962 void testNotEqualStringEachEqual3(void)
1963 {
1964 const char *testStrings[] = { "foo", "foo", "foo", NULL };
1965
1966 EXPECT_ABORT_BEGIN
1967 TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
1968 VERIFY_FAILS_END
1969 }
1970
testNotEqualStringEachEqual4(void)1971 void testNotEqualStringEachEqual4(void)
1972 {
1973 const char *testStrings[] = { "foo", "foo", "woo", "foo" };
1974
1975 EXPECT_ABORT_BEGIN
1976 TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
1977 VERIFY_FAILS_END
1978 }
1979
testNotEqualStringEachEqual5(void)1980 void testNotEqualStringEachEqual5(void)
1981 {
1982 EXPECT_ABORT_BEGIN
1983 TEST_ASSERT_EACH_EQUAL_STRING("foo", NULL, 1);
1984 VERIFY_FAILS_END
1985 }
1986
testEqualMemory(void)1987 void testEqualMemory(void)
1988 {
1989 const char *testString = "whatever";
1990
1991 TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8);
1992 TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8);
1993 TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8);
1994 TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8);
1995 TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2);
1996 TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1);
1997 }
1998
testNotEqualMemory1(void)1999 void testNotEqualMemory1(void)
2000 {
2001 EXPECT_ABORT_BEGIN
2002 TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3);
2003 VERIFY_FAILS_END
2004 }
2005
testNotEqualMemory2(void)2006 void testNotEqualMemory2(void)
2007 {
2008 EXPECT_ABORT_BEGIN
2009 TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4);
2010 VERIFY_FAILS_END
2011 }
2012
testNotEqualMemory3(void)2013 void testNotEqualMemory3(void)
2014 {
2015 EXPECT_ABORT_BEGIN
2016 TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4);
2017 VERIFY_FAILS_END
2018 }
2019
testNotEqualMemory4(void)2020 void testNotEqualMemory4(void)
2021 {
2022 EXPECT_ABORT_BEGIN
2023 TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4);
2024 VERIFY_FAILS_END
2025 }
2026
testNotEqualMemoryLengthZero(void)2027 void testNotEqualMemoryLengthZero(void)
2028 {
2029 EXPECT_ABORT_BEGIN
2030 TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0);
2031 VERIFY_FAILS_END
2032 }
2033
testEqualIntArrays(void)2034 void testEqualIntArrays(void)
2035 {
2036 int p0[] = {1, 8, 987, -2};
2037 int p1[] = {1, 8, 987, -2};
2038 int p2[] = {1, 8, 987, 2};
2039 int p3[] = {1, 500, 600, 700};
2040
2041 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1);
2042 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4);
2043 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
2044 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3);
2045 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1);
2046 TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1);
2047 }
2048
testNotEqualIntArraysNullExpected(void)2049 void testNotEqualIntArraysNullExpected(void)
2050 {
2051 int* p0 = NULL;
2052 int p1[] = {1, 8, 987, 2};
2053
2054 EXPECT_ABORT_BEGIN
2055 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
2056 VERIFY_FAILS_END
2057 }
2058
testNotEqualIntArraysNullActual(void)2059 void testNotEqualIntArraysNullActual(void)
2060 {
2061 int* p1 = NULL;
2062 int p0[] = {1, 8, 987, 2};
2063
2064 EXPECT_ABORT_BEGIN
2065 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
2066 VERIFY_FAILS_END
2067 }
2068
testNotEqualIntArrays1(void)2069 void testNotEqualIntArrays1(void)
2070 {
2071 int p0[] = {1, 8, 987, -2};
2072 int p1[] = {1, 8, 987, 2};
2073
2074 EXPECT_ABORT_BEGIN
2075 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
2076 VERIFY_FAILS_END
2077 }
2078
testNotEqualIntArrays2(void)2079 void testNotEqualIntArrays2(void)
2080 {
2081 int p0[] = {1, 8, 987, -2};
2082 int p1[] = {2, 8, 987, -2};
2083
2084 EXPECT_ABORT_BEGIN
2085 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
2086 VERIFY_FAILS_END
2087 }
2088
testNotEqualIntArrays3(void)2089 void testNotEqualIntArrays3(void)
2090 {
2091 int p0[] = {1, 8, 987, -2};
2092 int p1[] = {1, 8, 986, -2};
2093
2094 EXPECT_ABORT_BEGIN
2095 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
2096 VERIFY_FAILS_END
2097 }
2098
testNotEqualIntArraysLengthZero(void)2099 void testNotEqualIntArraysLengthZero(void)
2100 {
2101 UNITY_UINT32 p0[1] = {1};
2102 UNITY_UINT32 p1[1] = {1};
2103
2104 EXPECT_ABORT_BEGIN
2105 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0);
2106 VERIFY_FAILS_END
2107 }
2108
testEqualIntEachEqual(void)2109 void testEqualIntEachEqual(void)
2110 {
2111 int p0[] = {1, 1, 1, 1};
2112 int p1[] = {987, 987, 987, 987};
2113 int p2[] = {-2, -2, -2, -3};
2114 int p3[] = {1, 5, 600, 700};
2115
2116 TEST_ASSERT_EACH_EQUAL_INT(1, p0, 1);
2117 TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4);
2118 TEST_ASSERT_EACH_EQUAL_INT(987, p1, 4);
2119 TEST_ASSERT_EACH_EQUAL_INT(-2, p2, 3);
2120 TEST_ASSERT_EACH_EQUAL_INT(1, p3, 1);
2121 }
2122
testNotEqualIntEachEqualNullActual(void)2123 void testNotEqualIntEachEqualNullActual(void)
2124 {
2125 int* p1 = NULL;
2126
2127 EXPECT_ABORT_BEGIN
2128 TEST_ASSERT_EACH_EQUAL_INT(1, p1, 4);
2129 VERIFY_FAILS_END
2130 }
2131
testNotEqualIntEachEqual1(void)2132 void testNotEqualIntEachEqual1(void)
2133 {
2134 int p0[] = {1, 1, 1, -2};
2135
2136 EXPECT_ABORT_BEGIN
2137 TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4);
2138 VERIFY_FAILS_END
2139 }
2140
testNotEqualIntEachEqual2(void)2141 void testNotEqualIntEachEqual2(void)
2142 {
2143 int p0[] = {-5, -5, -1, -5};
2144
2145 EXPECT_ABORT_BEGIN
2146 TEST_ASSERT_EACH_EQUAL_INT(-5, p0, 4);
2147 VERIFY_FAILS_END
2148 }
2149
testNotEqualIntEachEqual3(void)2150 void testNotEqualIntEachEqual3(void)
2151 {
2152 int p0[] = {1, 88, 88, 88};
2153
2154 EXPECT_ABORT_BEGIN
2155 TEST_ASSERT_EACH_EQUAL_INT(88, p0, 4);
2156 VERIFY_FAILS_END
2157 }
2158
testNotEqualEachEqualLengthZero(void)2159 void testNotEqualEachEqualLengthZero(void)
2160 {
2161 UNITY_UINT32 p0[1] = {1};
2162
2163 EXPECT_ABORT_BEGIN
2164 TEST_ASSERT_EACH_EQUAL_INT(0, p0, 0);
2165 VERIFY_FAILS_END
2166 }
2167
testEqualPtrArrays(void)2168 void testEqualPtrArrays(void)
2169 {
2170 char A = 1;
2171 char B = 2;
2172 char C = 3;
2173 char* p0[] = {&A, &B, &C};
2174 char* p1[] = {&A, &B, &C, &A};
2175 char* p2[] = {&A, &B};
2176 char* p3[] = {&A};
2177
2178 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 1);
2179 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 3);
2180 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 3);
2181 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p2, 2);
2182 TEST_ASSERT_EQUAL_PTR_ARRAY(p3, p0, 1);
2183 }
2184
testNotEqualPtrArraysNullExpected(void)2185 void testNotEqualPtrArraysNullExpected(void)
2186 {
2187 char A = 1;
2188 char B = 2;
2189 char** p0 = NULL;
2190 char* p1[] = {&A, &B};
2191
2192 EXPECT_ABORT_BEGIN
2193 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 2);
2194 VERIFY_FAILS_END
2195 }
2196
testNotEqualPtrArraysNullActual(void)2197 void testNotEqualPtrArraysNullActual(void)
2198 {
2199 char A = 1;
2200 char B = 2;
2201 char** p0 = NULL;
2202 char* p1[] = {&A, &B};
2203
2204 EXPECT_ABORT_BEGIN
2205 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p0, 2);
2206 VERIFY_FAILS_END
2207 }
2208
testNotEqualPtrArrays1(void)2209 void testNotEqualPtrArrays1(void)
2210 {
2211 char A = 1;
2212 char B = 2;
2213 char C = 3;
2214 char* p0[] = {&A, &B, &C, &B};
2215 char* p1[] = {&A, &B, &C, &A};
2216
2217 EXPECT_ABORT_BEGIN
2218 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4);
2219 VERIFY_FAILS_END
2220 }
2221
testNotEqualPtrArrays2(void)2222 void testNotEqualPtrArrays2(void)
2223 {
2224 char A = 1;
2225 char B = 2;
2226 char C = 3;
2227 char* p0[] = {&B, &B, &C, &A};
2228 char* p1[] = {&A, &B, &C, &A};
2229
2230 EXPECT_ABORT_BEGIN
2231 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4);
2232 VERIFY_FAILS_END
2233 }
2234
testNotEqualPtrArrays3(void)2235 void testNotEqualPtrArrays3(void)
2236 {
2237 char A = 1;
2238 char B = 2;
2239 char C = 3;
2240 char* p0[] = {&A, &B, &B, &A};
2241 char* p1[] = {&A, &B, &C, &A};
2242
2243 EXPECT_ABORT_BEGIN
2244 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4);
2245 VERIFY_FAILS_END
2246 }
2247
testEqualPtrEachEqual(void)2248 void testEqualPtrEachEqual(void)
2249 {
2250 char A = 1;
2251 char B = 2;
2252 char C = 3;
2253 char* p0[] = {&A, &A, &A};
2254 char* p1[] = {&A, &B, &C, &A};
2255 char* p2[] = {&B, &B};
2256 char* p3[] = {&C};
2257
2258 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 1);
2259 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 3);
2260 TEST_ASSERT_EACH_EQUAL_PTR(&A, p1, 1);
2261 TEST_ASSERT_EACH_EQUAL_PTR(&B, p2, 2);
2262 TEST_ASSERT_EACH_EQUAL_PTR(&C, p3, 1);
2263 }
2264
testNotEqualPtrEachEqualNullExpected(void)2265 void testNotEqualPtrEachEqualNullExpected(void)
2266 {
2267 char A = 1;
2268 char B = 1;
2269 char* p0[] = {&A, &B};
2270
2271 EXPECT_ABORT_BEGIN
2272 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2);
2273 VERIFY_FAILS_END
2274 }
2275
testNotEqualPtrEachEqualNullActual(void)2276 void testNotEqualPtrEachEqualNullActual(void)
2277 {
2278 char A = 1;
2279 char** p0 = NULL;
2280
2281 EXPECT_ABORT_BEGIN
2282 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2);
2283 VERIFY_FAILS_END
2284 }
2285
testNotEqualPtrEachEqual1(void)2286 void testNotEqualPtrEachEqual1(void)
2287 {
2288 char A = 1;
2289 char B = 1;
2290 char* p0[] = {&A, &A, &A, &B};
2291
2292 EXPECT_ABORT_BEGIN
2293 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 4);
2294 VERIFY_FAILS_END
2295 }
2296
testNotEqualPtrEachEqual2(void)2297 void testNotEqualPtrEachEqual2(void)
2298 {
2299 char A = 1;
2300 char B = 1;
2301 char* p0[] = {&B, &B, &A, &B};
2302
2303 EXPECT_ABORT_BEGIN
2304 TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4);
2305 VERIFY_FAILS_END
2306 }
2307
testNotEqualPtrEachEqual3(void)2308 void testNotEqualPtrEachEqual3(void)
2309 {
2310 char A = 1;
2311 char B = 1;
2312 char* p0[] = {&A, &B, &B, &B};
2313
2314 EXPECT_ABORT_BEGIN
2315 TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4);
2316 VERIFY_FAILS_END
2317 }
2318
testEqualInt8Arrays(void)2319 void testEqualInt8Arrays(void)
2320 {
2321 UNITY_INT8 p0[] = {1, 8, 117, -2};
2322 UNITY_INT8 p1[] = {1, 8, 117, -2};
2323 UNITY_INT8 p2[] = {1, 8, 117, 2};
2324 UNITY_INT8 p3[] = {1, 50, 60, 70};
2325
2326 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1);
2327 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4);
2328 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4);
2329 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3);
2330 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1);
2331 }
2332
testNotEqualInt8Arrays(void)2333 void testNotEqualInt8Arrays(void)
2334 {
2335 UNITY_INT8 p0[] = {1, 8, 36, -2};
2336 UNITY_INT8 p1[] = {1, 8, 36, 2};
2337
2338 EXPECT_ABORT_BEGIN
2339 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4);
2340 VERIFY_FAILS_END
2341 }
2342
testEqualInt8EachEqual(void)2343 void testEqualInt8EachEqual(void)
2344 {
2345 UNITY_INT8 p0[] = {1, 1, 1, 1};
2346 UNITY_INT8 p1[] = {117, 117, 117, -2};
2347 UNITY_INT8 p2[] = {-1, -1, 117, 2};
2348 UNITY_INT8 p3[] = {1, 50, 60, 70};
2349
2350 TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 1);
2351 TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 4);
2352 TEST_ASSERT_EACH_EQUAL_INT8(117, p1, 3);
2353 TEST_ASSERT_EACH_EQUAL_INT8(-1, p2, 2);
2354 TEST_ASSERT_EACH_EQUAL_INT8(1, p3, 1);
2355 }
2356
testNotEqualInt8EachEqual(void)2357 void testNotEqualInt8EachEqual(void)
2358 {
2359 UNITY_INT8 p0[] = {1, 8, 36, -2};
2360
2361 EXPECT_ABORT_BEGIN
2362 TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 2);
2363 VERIFY_FAILS_END
2364 }
2365
testEqualUIntArrays(void)2366 void testEqualUIntArrays(void)
2367 {
2368 unsigned int p0[] = {1, 8, 987, 65132u};
2369 unsigned int p1[] = {1, 8, 987, 65132u};
2370 unsigned int p2[] = {1, 8, 987, 2};
2371 unsigned int p3[] = {1, 500, 600, 700};
2372
2373 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1);
2374 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4);
2375 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
2376 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3);
2377 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1);
2378 }
2379
testNotEqualUIntArrays1(void)2380 void testNotEqualUIntArrays1(void)
2381 {
2382 unsigned int p0[] = {1, 8, 987, 65132u};
2383 unsigned int p1[] = {1, 8, 987, 65131u};
2384
2385 EXPECT_ABORT_BEGIN
2386 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
2387 VERIFY_FAILS_END
2388 }
2389
testNotEqualUIntArrays2(void)2390 void testNotEqualUIntArrays2(void)
2391 {
2392 unsigned int p0[] = {1, 8, 987, 65132u};
2393 unsigned int p1[] = {2, 8, 987, 65132u};
2394
2395 EXPECT_ABORT_BEGIN
2396 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
2397 VERIFY_FAILS_END
2398 }
2399
testNotEqualUIntArrays3(void)2400 void testNotEqualUIntArrays3(void)
2401 {
2402 unsigned int p0[] = {1, 8, 987, 65132u};
2403 unsigned int p1[] = {1, 8, 986, 65132u};
2404
2405 EXPECT_ABORT_BEGIN
2406 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
2407 VERIFY_FAILS_END
2408 }
2409
testEqualUIntEachEqual(void)2410 void testEqualUIntEachEqual(void)
2411 {
2412 unsigned int p0[] = {1, 1, 1, 1};
2413 unsigned int p1[] = {65132u, 65132u, 65132u, 65132u};
2414 unsigned int p2[] = {8, 8, 987, 2};
2415 unsigned int p3[] = {1, 500, 600, 700};
2416
2417 TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 1);
2418 TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4);
2419 TEST_ASSERT_EACH_EQUAL_UINT(65132u, p1, 4);
2420 TEST_ASSERT_EACH_EQUAL_UINT(8, p2, 2);
2421 TEST_ASSERT_EACH_EQUAL_UINT(1, p3, 1);
2422 }
2423
testNotEqualUIntEachEqual1(void)2424 void testNotEqualUIntEachEqual1(void)
2425 {
2426 unsigned int p0[] = {1, 65132u, 65132u, 65132u};
2427
2428 EXPECT_ABORT_BEGIN
2429 TEST_ASSERT_EACH_EQUAL_UINT(65132u, p0, 4);
2430 VERIFY_FAILS_END
2431 }
2432
testNotEqualUIntEachEqual2(void)2433 void testNotEqualUIntEachEqual2(void)
2434 {
2435 unsigned int p0[] = {987, 8, 987, 987};
2436
2437 EXPECT_ABORT_BEGIN
2438 TEST_ASSERT_EACH_EQUAL_UINT(987, p0, 4);
2439 VERIFY_FAILS_END
2440 }
2441
testNotEqualUIntEachEqual3(void)2442 void testNotEqualUIntEachEqual3(void)
2443 {
2444 unsigned int p0[] = {1, 1, 1, 65132u};
2445
2446 EXPECT_ABORT_BEGIN
2447 TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4);
2448 VERIFY_FAILS_END
2449 }
2450
testEqualInt16Arrays(void)2451 void testEqualInt16Arrays(void)
2452 {
2453 UNITY_INT16 p0[] = {1, 8, 117, 3};
2454 UNITY_INT16 p1[] = {1, 8, 117, 3};
2455 UNITY_INT16 p2[] = {1, 8, 117, 2};
2456 UNITY_INT16 p3[] = {1, 50, 60, 70};
2457
2458 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1);
2459 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4);
2460 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4);
2461 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3);
2462 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1);
2463 }
2464
testNotEqualInt16Arrays(void)2465 void testNotEqualInt16Arrays(void)
2466 {
2467 UNITY_INT16 p0[] = {1, 8, 127, 3};
2468 UNITY_INT16 p1[] = {1, 8, 127, 2};
2469
2470 EXPECT_ABORT_BEGIN
2471 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4);
2472 VERIFY_FAILS_END
2473 }
2474
testEqualInt16EachEqual(void)2475 void testEqualInt16EachEqual(void)
2476 {
2477 UNITY_INT16 p0[] = {1, 1, 1, 1};
2478 UNITY_INT16 p1[] = {32111, 32111, 32111, 3};
2479 UNITY_INT16 p2[] = {-1, -1, -1, 2};
2480 UNITY_INT16 p3[] = {1, 50, 60, 70};
2481
2482 TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 1);
2483 TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 4);
2484 TEST_ASSERT_EACH_EQUAL_INT16(32111, p1, 3);
2485 TEST_ASSERT_EACH_EQUAL_INT16(-1, p2, 3);
2486 TEST_ASSERT_EACH_EQUAL_INT16(1, p3, 1);
2487 }
2488
testNotEqualInt16EachEqual(void)2489 void testNotEqualInt16EachEqual(void)
2490 {
2491 UNITY_INT16 p0[] = {127, 127, 127, 3};
2492
2493 EXPECT_ABORT_BEGIN
2494 TEST_ASSERT_EACH_EQUAL_INT16(127, p0, 4);
2495 VERIFY_FAILS_END
2496 }
2497
testEqualInt32Arrays(void)2498 void testEqualInt32Arrays(void)
2499 {
2500 UNITY_INT32 p0[] = {1, 8, 117, 3};
2501 UNITY_INT32 p1[] = {1, 8, 117, 3};
2502 UNITY_INT32 p2[] = {1, 8, 117, 2};
2503 UNITY_INT32 p3[] = {1, 50, 60, 70};
2504
2505 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1);
2506 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4);
2507 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4);
2508 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3);
2509 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1);
2510 }
2511
testNotEqualInt32Arrays(void)2512 void testNotEqualInt32Arrays(void)
2513 {
2514 UNITY_INT32 p0[] = {1, 8, 127, 3};
2515 UNITY_INT32 p1[] = {1, 8, 127, 2};
2516
2517 EXPECT_ABORT_BEGIN
2518 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4);
2519 VERIFY_FAILS_END
2520 }
2521
testEqualInt32EachEqual(void)2522 void testEqualInt32EachEqual(void)
2523 {
2524 UNITY_INT32 p0[] = {8, 8, 8, 8};
2525 UNITY_INT32 p1[] = {65537, 65537, 65537, 65537};
2526 UNITY_INT32 p2[] = {-3, -3, -3, 2};
2527 UNITY_INT32 p3[] = {1, 50, 60, 70};
2528
2529 TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 1);
2530 TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 4);
2531 TEST_ASSERT_EACH_EQUAL_INT32(65537, p1, 4);
2532 TEST_ASSERT_EACH_EQUAL_INT32(-3, p2, 3);
2533 TEST_ASSERT_EACH_EQUAL_INT32(1, p3, 1);
2534 }
2535
testNotEqualInt32EachEqual(void)2536 void testNotEqualInt32EachEqual(void)
2537 {
2538 UNITY_INT32 p0[] = {127, 8, 127, 127};
2539
2540 EXPECT_ABORT_BEGIN
2541 TEST_ASSERT_EACH_EQUAL_INT32(127, p0, 4);
2542 VERIFY_FAILS_END
2543 }
2544
testEqualUINT8Arrays(void)2545 void testEqualUINT8Arrays(void)
2546 {
2547 UNITY_UINT8 p0[] = {1, 8, 100, 127};
2548 UNITY_UINT8 p1[] = {1, 8, 100, 127};
2549 UNITY_UINT8 p2[] = {1, 8, 100, 2};
2550 UNITY_UINT8 p3[] = {1, 50, 60, 70};
2551
2552 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1);
2553 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4);
2554 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
2555 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3);
2556 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1);
2557 }
2558
testNotEqualUINT8Arrays1(void)2559 void testNotEqualUINT8Arrays1(void)
2560 {
2561 unsigned char p0[] = {1, 8, 100, 127u};
2562 unsigned char p1[] = {1, 8, 100, 255u};
2563
2564 EXPECT_ABORT_BEGIN
2565 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
2566 VERIFY_FAILS_END
2567 }
2568
testNotEqualUINT8Arrays2(void)2569 void testNotEqualUINT8Arrays2(void)
2570 {
2571 unsigned char p0[] = {1, 8, 100, 127u};
2572 unsigned char p1[] = {1, 8, 100, 255u};
2573
2574 EXPECT_ABORT_BEGIN
2575 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
2576 VERIFY_FAILS_END
2577 }
2578
testNotEqualUINT8Arrays3(void)2579 void testNotEqualUINT8Arrays3(void)
2580 {
2581 unsigned char p0[] = {1, 8, 100, 127u};
2582 unsigned char p1[] = {1, 8, 100, 255u};
2583
2584 EXPECT_ABORT_BEGIN
2585 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
2586 VERIFY_FAILS_END
2587 }
2588
2589
testEqualUINT16Arrays(void)2590 void testEqualUINT16Arrays(void)
2591 {
2592 unsigned short p0[] = {1, 8, 987, 65132u};
2593 unsigned short p1[] = {1, 8, 987, 65132u};
2594 unsigned short p2[] = {1, 8, 987, 2};
2595 unsigned short p3[] = {1, 500, 600, 700};
2596
2597 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1);
2598 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4);
2599 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
2600 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3);
2601 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1);
2602 }
2603
testNotEqualUINT16Arrays1(void)2604 void testNotEqualUINT16Arrays1(void)
2605 {
2606 unsigned short p0[] = {1, 8, 987, 65132u};
2607 unsigned short p1[] = {1, 8, 987, 65131u};
2608
2609 EXPECT_ABORT_BEGIN
2610 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
2611 VERIFY_FAILS_END
2612 }
2613
testNotEqualUINT16Arrays2(void)2614 void testNotEqualUINT16Arrays2(void)
2615 {
2616 unsigned short p0[] = {1, 8, 987, 65132u};
2617 unsigned short p1[] = {2, 8, 987, 65132u};
2618
2619 EXPECT_ABORT_BEGIN
2620 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
2621 VERIFY_FAILS_END
2622 }
2623
testNotEqualUINT16Arrays3(void)2624 void testNotEqualUINT16Arrays3(void)
2625 {
2626 unsigned short p0[] = {1, 8, 987, 65132u};
2627 unsigned short p1[] = {1, 8, 986, 65132u};
2628
2629 EXPECT_ABORT_BEGIN
2630 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
2631 VERIFY_FAILS_END
2632 }
2633
testEqualUINT32Arrays(void)2634 void testEqualUINT32Arrays(void)
2635 {
2636 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2637 UNITY_UINT32 p1[] = {1, 8, 987, 65132u};
2638 UNITY_UINT32 p2[] = {1, 8, 987, 2};
2639 UNITY_UINT32 p3[] = {1, 500, 600, 700};
2640
2641 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1);
2642 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4);
2643 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
2644 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3);
2645 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1);
2646 }
2647
testNotEqualUINT32Arrays1(void)2648 void testNotEqualUINT32Arrays1(void)
2649 {
2650 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2651 UNITY_UINT32 p1[] = {1, 8, 987, 65131u};
2652
2653 EXPECT_ABORT_BEGIN
2654 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
2655 VERIFY_FAILS_END
2656 }
2657
testNotEqualUINT32Arrays2(void)2658 void testNotEqualUINT32Arrays2(void)
2659 {
2660 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2661 UNITY_UINT32 p1[] = {2, 8, 987, 65132u};
2662
2663 EXPECT_ABORT_BEGIN
2664 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
2665 VERIFY_FAILS_END
2666 }
2667
testNotEqualUINT32Arrays3(void)2668 void testNotEqualUINT32Arrays3(void)
2669 {
2670 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2671 UNITY_UINT32 p1[] = {1, 8, 986, 65132u};
2672
2673 EXPECT_ABORT_BEGIN
2674 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
2675 VERIFY_FAILS_END
2676 }
2677
testEqualHEXArrays(void)2678 void testEqualHEXArrays(void)
2679 {
2680 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2681 UNITY_UINT32 p1[] = {1, 8, 987, 65132u};
2682 UNITY_UINT32 p2[] = {1, 8, 987, 2};
2683 UNITY_UINT32 p3[] = {1, 500, 600, 700};
2684
2685 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1);
2686 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4);
2687 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
2688 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3);
2689 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1);
2690 }
2691
testNotEqualHEXArrays1(void)2692 void testNotEqualHEXArrays1(void)
2693 {
2694 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2695 UNITY_UINT32 p1[] = {1, 8, 987, 65131u};
2696
2697 EXPECT_ABORT_BEGIN
2698 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
2699 VERIFY_FAILS_END
2700 }
2701
testNotEqualHEXArrays2(void)2702 void testNotEqualHEXArrays2(void)
2703 {
2704 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2705 UNITY_UINT32 p1[] = {2, 8, 987, 65132u};
2706
2707 EXPECT_ABORT_BEGIN
2708 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
2709 VERIFY_FAILS_END
2710 }
2711
testNotEqualHEXArrays3(void)2712 void testNotEqualHEXArrays3(void)
2713 {
2714 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2715 UNITY_UINT32 p1[] = {1, 8, 986, 65132u};
2716
2717 EXPECT_ABORT_BEGIN
2718 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
2719 VERIFY_FAILS_END
2720 }
2721
testEqualHEX32Arrays(void)2722 void testEqualHEX32Arrays(void)
2723 {
2724 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2725 UNITY_UINT32 p1[] = {1, 8, 987, 65132u};
2726 UNITY_UINT32 p2[] = {1, 8, 987, 2};
2727 UNITY_UINT32 p3[] = {1, 500, 600, 700};
2728
2729 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1);
2730 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4);
2731 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
2732 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3);
2733 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1);
2734 }
2735
testNotEqualHEX32Arrays1(void)2736 void testNotEqualHEX32Arrays1(void)
2737 {
2738 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2739 UNITY_UINT32 p1[] = {1, 8, 987, 65131u};
2740
2741 EXPECT_ABORT_BEGIN
2742 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
2743 VERIFY_FAILS_END
2744 }
2745
testNotEqualHEX32Arrays2(void)2746 void testNotEqualHEX32Arrays2(void)
2747 {
2748 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2749 UNITY_UINT32 p1[] = {2, 8, 987, 65132u};
2750
2751 EXPECT_ABORT_BEGIN
2752 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
2753 VERIFY_FAILS_END
2754 }
2755
testNotEqualHEX32Arrays3(void)2756 void testNotEqualHEX32Arrays3(void)
2757 {
2758 UNITY_UINT32 p0[] = {1, 8, 987, 65132u};
2759 UNITY_UINT32 p1[] = {1, 8, 986, 65132u};
2760
2761 EXPECT_ABORT_BEGIN
2762 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
2763 VERIFY_FAILS_END
2764 }
2765
testEqualHEX16Arrays(void)2766 void testEqualHEX16Arrays(void)
2767 {
2768 unsigned short p0[] = {1, 8, 987, 65132u};
2769 unsigned short p1[] = {1, 8, 987, 65132u};
2770 unsigned short p2[] = {1, 8, 987, 2};
2771 unsigned short p3[] = {1, 500, 600, 700};
2772
2773 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1);
2774 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4);
2775 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
2776 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3);
2777 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1);
2778 }
2779
testNotEqualHEX16Arrays1(void)2780 void testNotEqualHEX16Arrays1(void)
2781 {
2782 unsigned short p0[] = {1, 8, 987, 65132u};
2783 unsigned short p1[] = {1, 8, 987, 65131u};
2784
2785 EXPECT_ABORT_BEGIN
2786 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
2787 VERIFY_FAILS_END
2788 }
2789
testNotEqualHEX16Arrays2(void)2790 void testNotEqualHEX16Arrays2(void)
2791 {
2792 unsigned short p0[] = {1, 8, 987, 65132u};
2793 unsigned short p1[] = {2, 8, 987, 65132u};
2794
2795 EXPECT_ABORT_BEGIN
2796 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
2797 VERIFY_FAILS_END
2798 }
2799
testNotEqualHEX16Arrays3(void)2800 void testNotEqualHEX16Arrays3(void)
2801 {
2802 unsigned short p0[] = {1, 8, 987, 65132u};
2803 unsigned short p1[] = {1, 8, 986, 65132u};
2804
2805 EXPECT_ABORT_BEGIN
2806 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
2807 VERIFY_FAILS_END
2808 }
2809
testEqualHEX8Arrays(void)2810 void testEqualHEX8Arrays(void)
2811 {
2812 unsigned char p0[] = {1, 8, 254u, 123};
2813 unsigned char p1[] = {1, 8, 254u, 123};
2814 unsigned char p2[] = {1, 8, 254u, 2};
2815 unsigned char p3[] = {1, 23, 25, 26};
2816
2817 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1);
2818 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4);
2819 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
2820 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3);
2821 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1);
2822 }
2823
testNotEqualHEX8Arrays1(void)2824 void testNotEqualHEX8Arrays1(void)
2825 {
2826 unsigned char p0[] = {1, 8, 254u, 253u};
2827 unsigned char p1[] = {1, 8, 254u, 252u};
2828
2829 EXPECT_ABORT_BEGIN
2830 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
2831 VERIFY_FAILS_END
2832 }
2833
testNotEqualHEX8Arrays2(void)2834 void testNotEqualHEX8Arrays2(void)
2835 {
2836 unsigned char p0[] = {1, 8, 254u, 253u};
2837 unsigned char p1[] = {2, 8, 254u, 253u};
2838
2839 EXPECT_ABORT_BEGIN
2840 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
2841 VERIFY_FAILS_END
2842 }
2843
testNotEqualHEX8Arrays3(void)2844 void testNotEqualHEX8Arrays3(void)
2845 {
2846 unsigned char p0[] = {1, 8, 254u, 253u};
2847 unsigned char p1[] = {1, 8, 255u, 253u};
2848
2849 EXPECT_ABORT_BEGIN
2850 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
2851 VERIFY_FAILS_END
2852 }
2853
testEqualUINT8EachEqual(void)2854 void testEqualUINT8EachEqual(void)
2855 {
2856 UNITY_UINT8 p0[] = {127u, 127u, 127u, 127u};
2857 UNITY_UINT8 p1[] = {1u, 1u, 1u, 1u};
2858 UNITY_UINT8 p2[] = {128u, 128u, 128u, 2u};
2859 UNITY_UINT8 p3[] = {1u, 50u, 60u, 70u};
2860
2861 TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 1);
2862 TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4);
2863 TEST_ASSERT_EACH_EQUAL_UINT8(1u, p1, 4);
2864 TEST_ASSERT_EACH_EQUAL_UINT8(128u, p2, 3);
2865 TEST_ASSERT_EACH_EQUAL_UINT8(1u, p3, 1);
2866 }
2867
testNotEqualUINT8EachEqual1(void)2868 void testNotEqualUINT8EachEqual1(void)
2869 {
2870 unsigned char p0[] = {127u, 127u, 128u, 127u};
2871
2872 EXPECT_ABORT_BEGIN
2873 TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4);
2874 VERIFY_FAILS_END
2875 }
2876
testNotEqualUINT8EachEqual2(void)2877 void testNotEqualUINT8EachEqual2(void)
2878 {
2879 unsigned char p0[] = {1, 1, 1, 127u};
2880
2881 EXPECT_ABORT_BEGIN
2882 TEST_ASSERT_EACH_EQUAL_UINT8(1, p0, 4);
2883 VERIFY_FAILS_END
2884 }
2885
testNotEqualUINT8EachEqual3(void)2886 void testNotEqualUINT8EachEqual3(void)
2887 {
2888 unsigned char p0[] = {54u, 55u, 55u, 55u};
2889
2890 EXPECT_ABORT_BEGIN
2891 TEST_ASSERT_EACH_EQUAL_UINT8(55u, p0, 4);
2892 VERIFY_FAILS_END
2893 }
2894
testEqualUINT16EachEqual(void)2895 void testEqualUINT16EachEqual(void)
2896 {
2897 unsigned short p0[] = {65132u, 65132u, 65132u, 65132u};
2898 unsigned short p1[] = {987, 987, 987, 987};
2899 unsigned short p2[] = {1, 1, 1, 2};
2900 unsigned short p3[] = {1, 500, 600, 700};
2901
2902 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 1);
2903 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4);
2904 TEST_ASSERT_EACH_EQUAL_UINT16(987, p1, 4);
2905 TEST_ASSERT_EACH_EQUAL_UINT16(1, p2, 3);
2906 TEST_ASSERT_EACH_EQUAL_UINT16(1, p3, 1);
2907 }
2908
testNotEqualUINT16EachEqual1(void)2909 void testNotEqualUINT16EachEqual1(void)
2910 {
2911 unsigned short p0[] = {1, 65132u, 65132u, 65132u};
2912
2913 EXPECT_ABORT_BEGIN
2914 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4);
2915 VERIFY_FAILS_END
2916 }
2917
testNotEqualUINT16EachEqual2(void)2918 void testNotEqualUINT16EachEqual2(void)
2919 {
2920 unsigned short p0[] = {65132u, 65132u, 987, 65132u};
2921
2922 EXPECT_ABORT_BEGIN
2923 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4);
2924 VERIFY_FAILS_END
2925 }
2926
testNotEqualUINT16EachEqual3(void)2927 void testNotEqualUINT16EachEqual3(void)
2928 {
2929 unsigned short p0[] = {65132u, 65132u, 65132u, 65133u};
2930
2931 EXPECT_ABORT_BEGIN
2932 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4);
2933 VERIFY_FAILS_END
2934 }
2935
testEqualUINT32EachEqual(void)2936 void testEqualUINT32EachEqual(void)
2937 {
2938 UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u};
2939 UNITY_UINT32 p1[] = {987, 987, 987, 987};
2940 UNITY_UINT32 p2[] = {8, 8, 8, 2};
2941 UNITY_UINT32 p3[] = {1, 500, 600, 700};
2942
2943 TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 1);
2944 TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4);
2945 TEST_ASSERT_EACH_EQUAL_UINT32(987, p1, 4);
2946 TEST_ASSERT_EACH_EQUAL_UINT32(8, p2, 3);
2947 TEST_ASSERT_EACH_EQUAL_UINT32(1, p3, 1);
2948 }
2949
testNotEqualUINT32EachEqual1(void)2950 void testNotEqualUINT32EachEqual1(void)
2951 {
2952 UNITY_UINT32 p0[] = {65132u, 65132u, 987, 65132u};
2953
2954 EXPECT_ABORT_BEGIN
2955 TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4);
2956 VERIFY_FAILS_END
2957 }
2958
testNotEqualUINT32EachEqual2(void)2959 void testNotEqualUINT32EachEqual2(void)
2960 {
2961 UNITY_UINT32 p0[] = {1, 987, 987, 987};
2962
2963 EXPECT_ABORT_BEGIN
2964 TEST_ASSERT_EACH_EQUAL_UINT32(987, p0, 4);
2965 VERIFY_FAILS_END
2966 }
2967
testNotEqualUINT32EachEqual3(void)2968 void testNotEqualUINT32EachEqual3(void)
2969 {
2970 UNITY_UINT32 p0[] = {1, 1, 1, 65132u};
2971
2972 EXPECT_ABORT_BEGIN
2973 TEST_ASSERT_EACH_EQUAL_UINT32(1, p0, 4);
2974 VERIFY_FAILS_END
2975 }
2976
testEqualHEXEachEqual(void)2977 void testEqualHEXEachEqual(void)
2978 {
2979 UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u};
2980 UNITY_UINT32 p1[] = {987, 987, 987, 987};
2981 UNITY_UINT32 p2[] = {8, 8, 8, 2};
2982 UNITY_UINT32 p3[] = {1, 500, 600, 700};
2983
2984 TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 1);
2985 TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 4);
2986 TEST_ASSERT_EACH_EQUAL_HEX(987, p1, 4);
2987 TEST_ASSERT_EACH_EQUAL_HEX(8, p2, 3);
2988 TEST_ASSERT_EACH_EQUAL_HEX(1, p3, 1);
2989 }
2990
testNotEqualHEXEachEqual1(void)2991 void testNotEqualHEXEachEqual1(void)
2992 {
2993 UNITY_UINT32 p0[] = {1, 65132u, 65132u, 65132u};
2994
2995 EXPECT_ABORT_BEGIN
2996 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4);
2997 VERIFY_FAILS_END
2998 }
2999
testNotEqualHEXEachEqual2(void)3000 void testNotEqualHEXEachEqual2(void)
3001 {
3002 UNITY_UINT32 p0[] = {987, 987, 987, 65132u};
3003
3004 EXPECT_ABORT_BEGIN
3005 TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4);
3006 VERIFY_FAILS_END
3007 }
3008
testNotEqualHEXEachEqual3(void)3009 void testNotEqualHEXEachEqual3(void)
3010 {
3011 UNITY_UINT32 p0[] = {8, 8, 987, 8};
3012
3013 EXPECT_ABORT_BEGIN
3014 TEST_ASSERT_EACH_EQUAL_HEX(8, p0, 4);
3015 VERIFY_FAILS_END
3016 }
3017
testEqualHEX32EachEqual(void)3018 void testEqualHEX32EachEqual(void)
3019 {
3020 UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u};
3021 UNITY_UINT32 p1[] = {987, 987, 987, 987};
3022 UNITY_UINT32 p2[] = {8, 8, 8, 2};
3023 UNITY_UINT32 p3[] = {1, 500, 600, 700};
3024
3025 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 1);
3026 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4);
3027 TEST_ASSERT_EACH_EQUAL_HEX32(987, p1, 4);
3028 TEST_ASSERT_EACH_EQUAL_HEX32(8, p2, 3);
3029 TEST_ASSERT_EACH_EQUAL_HEX32(1, p3, 1);
3030 }
3031
testNotEqualHEX32EachEqual1(void)3032 void testNotEqualHEX32EachEqual1(void)
3033 {
3034 UNITY_UINT32 p0[] = {65132u, 8, 65132u, 65132u};
3035
3036 EXPECT_ABORT_BEGIN
3037 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4);
3038 VERIFY_FAILS_END
3039 }
3040
testNotEqualHEX32EachEqual2(void)3041 void testNotEqualHEX32EachEqual2(void)
3042 {
3043 UNITY_UINT32 p0[] = {1, 987, 987, 987};
3044
3045 EXPECT_ABORT_BEGIN
3046 TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4);
3047 VERIFY_FAILS_END
3048 }
3049
testNotEqualHEX32EachEqual3(void)3050 void testNotEqualHEX32EachEqual3(void)
3051 {
3052 UNITY_UINT32 p0[] = {8, 8, 8, 65132u};
3053
3054 EXPECT_ABORT_BEGIN
3055 TEST_ASSERT_EACH_EQUAL_HEX32(8, p0, 4);
3056 VERIFY_FAILS_END
3057 }
3058
testEqualHEX16EachEqual(void)3059 void testEqualHEX16EachEqual(void)
3060 {
3061 UNITY_UINT16 p0[] = {65132u, 65132u, 65132u, 65132u};
3062 UNITY_UINT16 p1[] = {987, 987, 987, 987};
3063 UNITY_UINT16 p2[] = {8, 8, 8, 2};
3064 UNITY_UINT16 p3[] = {1, 500, 600, 700};
3065
3066 TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 1);
3067 TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4);
3068 TEST_ASSERT_EACH_EQUAL_HEX16(987, p1, 4);
3069 TEST_ASSERT_EACH_EQUAL_HEX16(8, p2, 3);
3070 TEST_ASSERT_EACH_EQUAL_HEX16(1, p3, 1);
3071 }
3072
testNotEqualHEX16EachEqual1(void)3073 void testNotEqualHEX16EachEqual1(void)
3074 {
3075 unsigned short p0[] = {65132u, 65132u, 987, 65132u};
3076
3077 EXPECT_ABORT_BEGIN
3078 TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4);
3079 VERIFY_FAILS_END
3080 }
3081
testNotEqualHEX16EachEqual2(void)3082 void testNotEqualHEX16EachEqual2(void)
3083 {
3084 unsigned short p0[] = {1, 987, 987, 987};
3085
3086 EXPECT_ABORT_BEGIN
3087 TEST_ASSERT_EACH_EQUAL_HEX16(987, p0, 4);
3088 VERIFY_FAILS_END
3089 }
3090
testNotEqualHEX16EachEqual3(void)3091 void testNotEqualHEX16EachEqual3(void)
3092 {
3093 unsigned short p0[] = {8, 8, 8, 65132u};
3094
3095 EXPECT_ABORT_BEGIN
3096 TEST_ASSERT_EACH_EQUAL_HEX16(8, p0, 4);
3097 VERIFY_FAILS_END
3098 }
3099
testEqualHEX8EachEqual(void)3100 void testEqualHEX8EachEqual(void)
3101 {
3102 unsigned char p0[] = {254u, 254u, 254u, 254u};
3103 unsigned char p1[] = {123, 123, 123, 123};
3104 unsigned char p2[] = {8, 8, 8, 2};
3105 unsigned char p3[] = {1, 23, 25, 26};
3106
3107 TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 1);
3108 TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4);
3109 TEST_ASSERT_EACH_EQUAL_HEX8(123, p1, 4);
3110 TEST_ASSERT_EACH_EQUAL_HEX8(8, p2, 3);
3111 TEST_ASSERT_EACH_EQUAL_HEX8(1, p3, 1);
3112 }
3113
testNotEqualHEX8EachEqual1(void)3114 void testNotEqualHEX8EachEqual1(void)
3115 {
3116 unsigned char p0[] = {253u, 253u, 254u, 253u};
3117
3118 EXPECT_ABORT_BEGIN
3119 TEST_ASSERT_EACH_EQUAL_HEX8(253u, p0, 4);
3120 VERIFY_FAILS_END
3121 }
3122
testNotEqualHEX8EachEqual2(void)3123 void testNotEqualHEX8EachEqual2(void)
3124 {
3125 unsigned char p0[] = {254u, 254u, 254u, 253u};
3126
3127 EXPECT_ABORT_BEGIN
3128 TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4);
3129 VERIFY_FAILS_END
3130 }
3131
testNotEqualHEX8EachEqual3(void)3132 void testNotEqualHEX8EachEqual3(void)
3133 {
3134 unsigned char p0[] = {1, 8, 8, 8};
3135
3136 EXPECT_ABORT_BEGIN
3137 TEST_ASSERT_EACH_EQUAL_HEX8(8, p0, 4);
3138 VERIFY_FAILS_END
3139 }
3140
testEqualMemoryArrays(void)3141 void testEqualMemoryArrays(void)
3142 {
3143 int p0[] = {1, 8, 987, -2};
3144 int p1[] = {1, 8, 987, -2};
3145 int p2[] = {1, 8, 987, 2};
3146 int p3[] = {1, 500, 600, 700};
3147
3148 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 1);
3149 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 4);
3150 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
3151 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, sizeof(int), 3);
3152 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, sizeof(int), 1);
3153 }
3154
testNotEqualMemoryArraysExpectedNull(void)3155 void testNotEqualMemoryArraysExpectedNull(void)
3156 {
3157 int* p0 = NULL;
3158 int p1[] = {1, 8, 987, 2};
3159
3160 EXPECT_ABORT_BEGIN
3161 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
3162 VERIFY_FAILS_END
3163 }
3164
testNotEqualMemoryArraysActualNull(void)3165 void testNotEqualMemoryArraysActualNull(void)
3166 {
3167 int p0[] = {1, 8, 987, -2};
3168 int* p1 = NULL;
3169
3170 EXPECT_ABORT_BEGIN
3171 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
3172 VERIFY_FAILS_END
3173 }
3174
testNotEqualMemoryArrays1(void)3175 void testNotEqualMemoryArrays1(void)
3176 {
3177 int p0[] = {1, 8, 987, -2};
3178 int p1[] = {1, 8, 987, 2};
3179
3180 EXPECT_ABORT_BEGIN
3181 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
3182 VERIFY_FAILS_END
3183 }
3184
testNotEqualMemoryArrays2(void)3185 void testNotEqualMemoryArrays2(void)
3186 {
3187 int p0[] = {1, 8, 987, -2};
3188 int p1[] = {2, 8, 987, -2};
3189
3190 EXPECT_ABORT_BEGIN
3191 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
3192 VERIFY_FAILS_END
3193 }
3194
testNotEqualMemoryArrays3(void)3195 void testNotEqualMemoryArrays3(void)
3196 {
3197 int p0[] = {1, 8, 987, -2};
3198 int p1[] = {1, 8, 986, -2};
3199
3200 EXPECT_ABORT_BEGIN
3201 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4);
3202 VERIFY_FAILS_END
3203 }
3204
testEqualMemoryEachEqual(void)3205 void testEqualMemoryEachEqual(void)
3206 {
3207 int p0[] = {1, 8, 987, -2};
3208 int p1[] = {1, 8, 987, -2, 1, 8, 987, -2};
3209 int p2[] = {8, 8, 8, 2};
3210 int p3[] = {8, 500, 600, 700};
3211 int v = 8;
3212
3213 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p0, sizeof(int)*4, 1);
3214 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 2);
3215 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 1);
3216 TEST_ASSERT_EACH_EQUAL_MEMORY(&v, p2, sizeof(int), 3);
3217 TEST_ASSERT_EACH_EQUAL_MEMORY(&v, p3, sizeof(int), 1);
3218 }
3219
testNotEqualMemoryEachEqualExpectedNull(void)3220 void testNotEqualMemoryEachEqualExpectedNull(void)
3221 {
3222 int* p0 = NULL;
3223 int p1[] = {1, 8, 987, 2};
3224
3225 EXPECT_ABORT_BEGIN
3226 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int), 4);
3227 VERIFY_FAILS_END
3228 }
3229
testNotEqualMemoryEachEqualActualNull(void)3230 void testNotEqualMemoryEachEqualActualNull(void)
3231 {
3232 int p0[] = {1, 8, 987, -2};
3233 int* p1 = NULL;
3234
3235 EXPECT_ABORT_BEGIN
3236 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int), 4);
3237 VERIFY_FAILS_END
3238 }
3239
testNotEqualMemoryEachEqual1(void)3240 void testNotEqualMemoryEachEqual1(void)
3241 {
3242 int p0[] = {1, 8, 987, -2};
3243 int p1[] = {9, 8, 987, -2, 1, 8, 987, -2, 1, 8, 987, -2};
3244
3245 EXPECT_ABORT_BEGIN
3246 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 3);
3247 VERIFY_FAILS_END
3248 }
3249
testNotEqualMemoryEachEqual2(void)3250 void testNotEqualMemoryEachEqual2(void)
3251 {
3252 int p0[] = {1, 8, 987, -2};
3253 int p1[] = {1, 8, 987, -2, 1, 8, 987, -2, 1, 8, 987, 9};
3254
3255 EXPECT_ABORT_BEGIN
3256 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 3);
3257 VERIFY_FAILS_END
3258 }
3259
testNotEqualMemoryEachEqual3(void)3260 void testNotEqualMemoryEachEqual3(void)
3261 {
3262 int p0[] = {1, 8, 987, -2};
3263 int p1[] = {1, 8, 987, -2, 1, 9, 987, -2, 1, 8, 987, -2};
3264
3265 EXPECT_ABORT_BEGIN
3266 TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 3);
3267 VERIFY_FAILS_END
3268 }
3269
testProtection(void)3270 void testProtection(void)
3271 {
3272 volatile int mask = 0;
3273
3274 if (TEST_PROTECT())
3275 {
3276 mask |= 1;
3277 TEST_ABORT();
3278 }
3279 else
3280 {
3281 Unity.CurrentTestFailed = 0;
3282 mask |= 2;
3283 }
3284
3285 TEST_ASSERT_EQUAL(3, mask);
3286 }
3287
testIgnoredAndThenFailInTearDown(void)3288 void testIgnoredAndThenFailInTearDown(void)
3289 {
3290 SetToOneToFailInTearDown = 1;
3291 TEST_IGNORE();
3292 }
3293
3294 // Tricky series of macros to set USING_OUTPUT_SPY
3295 #define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
3296 #define ASSIGN_VALUE(a) VAL_##a
3297 #define VAL_putcharSpy 0, 1
3298 #define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway)
3299 #define SECOND_PARAM(a, b, ...) b
3300 #if USING_SPY_AS(UNITY_OUTPUT_CHAR)
3301 #define USING_OUTPUT_SPY // true only if UNITY_OUTPUT_CHAR = putcharSpy
3302 #endif
3303
3304 #ifdef USING_OUTPUT_SPY
3305 #include <stdio.h>
3306 #define SPY_BUFFER_MAX 40
3307 static char putcharSpyBuffer[SPY_BUFFER_MAX];
3308 #endif
3309 static int indexSpyBuffer;
3310 static int putcharSpyEnabled;
3311
startPutcharSpy(void)3312 void startPutcharSpy(void) {indexSpyBuffer = 0; putcharSpyEnabled = 1;}
3313
endPutcharSpy(void)3314 void endPutcharSpy(void) {putcharSpyEnabled = 0;}
3315
getBufferPutcharSpy(void)3316 char* getBufferPutcharSpy(void)
3317 {
3318 #ifdef USING_OUTPUT_SPY
3319 putcharSpyBuffer[indexSpyBuffer] = '\0';
3320 return putcharSpyBuffer;
3321 #else
3322 return NULL;
3323 #endif
3324 }
3325
putcharSpy(int c)3326 void putcharSpy(int c)
3327 {
3328 #ifdef USING_OUTPUT_SPY
3329 if (putcharSpyEnabled)
3330 {
3331 if (indexSpyBuffer < SPY_BUFFER_MAX - 1)
3332 putcharSpyBuffer[indexSpyBuffer++] = (char)c;
3333 } else
3334 putchar((char)c);
3335 #endif
3336 }
3337
testFailureCountIncrementsAndIsReturnedAtEnd(void)3338 void testFailureCountIncrementsAndIsReturnedAtEnd(void)
3339 {
3340 UNITY_UINT savedFailures = Unity.TestFailures;
3341 Unity.CurrentTestFailed = 1;
3342 startPutcharSpy(); // Suppress output
3343 UnityConcludeTest();
3344 endPutcharSpy();
3345 TEST_ASSERT_EQUAL(savedFailures + 1, Unity.TestFailures);
3346
3347 startPutcharSpy(); // Suppress output
3348 int failures = UnityEnd();
3349 Unity.TestFailures--;
3350 endPutcharSpy();
3351 TEST_ASSERT_EQUAL(savedFailures + 1, failures);
3352 }
3353
testCstringsEscapeSequence(void)3354 void testCstringsEscapeSequence(void)
3355 {
3356 #ifndef USING_OUTPUT_SPY
3357 TEST_IGNORE();
3358 #else
3359 startPutcharSpy();
3360 UnityPrint("\x16\x10");
3361 endPutcharSpy();
3362 TEST_ASSERT_EQUAL_STRING("\\x16\\x10", getBufferPutcharSpy());
3363 #endif
3364 }
3365
testHexPrintsUpToMaxNumberOfNibbles(void)3366 void testHexPrintsUpToMaxNumberOfNibbles(void)
3367 {
3368 #ifndef USING_OUTPUT_SPY
3369 TEST_IGNORE();
3370 #else
3371 startPutcharSpy();
3372 UnityPrintNumberHex(0xBEE, 21);
3373 endPutcharSpy();
3374 TEST_ASSERT_EQUAL_INT(sizeof(UNITY_INT)*2, strlen(getBufferPutcharSpy()));
3375 #endif
3376 }
3377
3378 #define TEST_ASSERT_EQUAL_PRINT_NUMBERS(expected, actual) { \
3379 startPutcharSpy(); UnityPrintNumber((actual)); endPutcharSpy(); \
3380 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \
3381 }
3382
3383 #define TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS(expected, actual) { \
3384 startPutcharSpy(); UnityPrintNumberUnsigned((actual)); endPutcharSpy(); \
3385 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \
3386 }
3387
testPrintNumbers32(void)3388 void testPrintNumbers32(void)
3389 {
3390 #ifndef USING_OUTPUT_SPY
3391 TEST_IGNORE_MESSAGE("Compile with '-D UNITY_OUTPUT_CHAR=putcharSpy' to enable print testing");
3392 #else
3393 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0);
3394 TEST_ASSERT_EQUAL_PRINT_NUMBERS("1", 1);
3395 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", -1);
3396 TEST_ASSERT_EQUAL_PRINT_NUMBERS("2000000000", 2000000000);
3397 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-2147483648", (UNITY_INT32)0x80000000);
3398 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT32)0xFFFFFFFF);
3399 #endif
3400 }
3401
testPrintNumbersUnsigned32(void)3402 void testPrintNumbersUnsigned32(void)
3403 {
3404 #ifndef USING_OUTPUT_SPY
3405 TEST_IGNORE();
3406 #else
3407 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0);
3408 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1", 1);
3409 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1500000000", 1500000000);
3410 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("2147483648", (UNITY_UINT32)0x80000000);
3411 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("4294967295", (UNITY_UINT32)0xFFFFFFFF);
3412 #endif
3413 }
3414
3415 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES 64 BIT SUPPORT ==================
3416
testPrintNumbersInt64(void)3417 void testPrintNumbersInt64(void)
3418 {
3419 #ifndef UNITY_SUPPORT_64
3420 TEST_IGNORE();
3421 #else
3422 #ifndef USING_OUTPUT_SPY
3423 TEST_IGNORE();
3424 #else
3425 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0);
3426 TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000);
3427 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (UNITY_INT)0x8000000000000000);
3428 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT)0xFFFFFFFFFFFFFFFF);
3429 #endif
3430 #endif
3431 }
3432
testPrintNumbersUInt64(void)3433 void testPrintNumbersUInt64(void)
3434 {
3435 #ifndef UNITY_SUPPORT_64
3436 TEST_IGNORE();
3437 #else
3438 #ifndef USING_OUTPUT_SPY
3439 TEST_IGNORE();
3440 #else
3441 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0);
3442 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000);
3443 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808", (UNITY_UINT)0x8000000000000000);
3444 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (UNITY_UINT)0xFFFFFFFFFFFFFFFF);
3445 #endif
3446 #endif
3447 }
3448
testEqualHex64s(void)3449 void testEqualHex64s(void)
3450 {
3451 #ifndef UNITY_SUPPORT_64
3452 TEST_IGNORE();
3453 #else
3454 UNITY_UINT64 v0, v1;
3455 UNITY_UINT64 *p0, *p1;
3456
3457 v0 = 0x9876543201234567;
3458 v1 = 0x9876543201234567;
3459 p0 = &v0;
3460 p1 = &v1;
3461
3462 TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567);
3463 TEST_ASSERT_EQUAL_HEX64(v0, v1);
3464 TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1);
3465 TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567);
3466 TEST_ASSERT_EQUAL_HEX64(*p0, v1);
3467 TEST_ASSERT_EQUAL_HEX64(*p0, *p1);
3468 TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567);
3469 #endif
3470 }
3471
testEqualUint64s(void)3472 void testEqualUint64s(void)
3473 {
3474 #ifndef UNITY_SUPPORT_64
3475 TEST_IGNORE();
3476 #else
3477 UNITY_UINT64 v0, v1;
3478 UNITY_UINT64 *p0, *p1;
3479
3480 v0 = 0x9876543201234567;
3481 v1 = 0x9876543201234567;
3482 p0 = &v0;
3483 p1 = &v1;
3484
3485 TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567);
3486 TEST_ASSERT_EQUAL_UINT64(v0, v1);
3487 TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1);
3488 TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567);
3489 TEST_ASSERT_EQUAL_UINT64(*p0, v1);
3490 TEST_ASSERT_EQUAL_UINT64(*p0, *p1);
3491 TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567);
3492 #endif
3493 }
3494
testEqualInt64s(void)3495 void testEqualInt64s(void)
3496 {
3497 #ifndef UNITY_SUPPORT_64
3498 TEST_IGNORE();
3499 #else
3500 UNITY_INT64 v0, v1;
3501 UNITY_INT64 *p0, *p1;
3502
3503 v0 = (UNITY_INT64)0x9876543201234567;
3504 v1 = (UNITY_INT64)0x9876543201234567;
3505 p0 = &v0;
3506 p1 = &v1;
3507
3508 TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567);
3509 TEST_ASSERT_EQUAL_INT64(v0, v1);
3510 TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1);
3511 TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567);
3512 TEST_ASSERT_EQUAL_INT64(*p0, v1);
3513 TEST_ASSERT_EQUAL_INT64(*p0, *p1);
3514 TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567);
3515 #endif
3516 }
3517
3518
testNotEqualHex64s(void)3519 void testNotEqualHex64s(void)
3520 {
3521 #ifndef UNITY_SUPPORT_64
3522 TEST_IGNORE();
3523 #else
3524 UNITY_UINT64 v0, v1;
3525
3526 v0 = 9000000000;
3527 v1 = 9100000000;
3528
3529 EXPECT_ABORT_BEGIN
3530 TEST_ASSERT_EQUAL_HEX64(v0, v1);
3531 VERIFY_FAILS_END
3532 #endif
3533 }
3534
testNotEqualUint64s(void)3535 void testNotEqualUint64s(void)
3536 {
3537 #ifndef UNITY_SUPPORT_64
3538 TEST_IGNORE();
3539 #else
3540 UNITY_UINT64 v0, v1;
3541
3542 v0 = 9000000000;
3543 v1 = 9100000000;
3544
3545 EXPECT_ABORT_BEGIN
3546 TEST_ASSERT_EQUAL_UINT64(v0, v1);
3547 VERIFY_FAILS_END
3548 #endif
3549 }
3550
testNotEqualInt64s(void)3551 void testNotEqualInt64s(void)
3552 {
3553 #ifndef UNITY_SUPPORT_64
3554 TEST_IGNORE();
3555 #else
3556 UNITY_INT64 v0, v1;
3557
3558 v0 = -9000000000;
3559 v1 = 9100000000;
3560
3561 EXPECT_ABORT_BEGIN
3562 TEST_ASSERT_EQUAL_INT64(v0, v1);
3563 VERIFY_FAILS_END
3564 #endif
3565 }
3566
testNotEqualHex64sIfSigned(void)3567 void testNotEqualHex64sIfSigned(void)
3568 {
3569 #ifndef UNITY_SUPPORT_64
3570 TEST_IGNORE();
3571 #else
3572 UNITY_INT64 v0, v1;
3573
3574 v0 = -9000000000;
3575 v1 = 9000000000;
3576
3577 EXPECT_ABORT_BEGIN
3578 TEST_ASSERT_EQUAL_HEX64(v0, v1);
3579 VERIFY_FAILS_END
3580 #endif
3581 }
3582
testHEX64sWithinDelta(void)3583 void testHEX64sWithinDelta(void)
3584 {
3585 #ifndef UNITY_SUPPORT_64
3586 TEST_IGNORE();
3587 #else
3588 TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
3589 TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996);
3590 TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005);
3591 #endif
3592 }
3593
testHEX64sNotWithinDelta(void)3594 void testHEX64sNotWithinDelta(void)
3595 {
3596 #ifndef UNITY_SUPPORT_64
3597 TEST_IGNORE();
3598 #else
3599 EXPECT_ABORT_BEGIN
3600 TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
3601 VERIFY_FAILS_END
3602 #endif
3603 }
3604
testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)3605 void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
3606 {
3607 #ifndef UNITY_SUPPORT_64
3608 TEST_IGNORE();
3609 #else
3610 EXPECT_ABORT_BEGIN
3611 TEST_ASSERT_HEX64_WITHIN(5, 1, -1);
3612 VERIFY_FAILS_END
3613 #endif
3614 }
3615
testUINT64sWithinDelta(void)3616 void testUINT64sWithinDelta(void)
3617 {
3618 #ifndef UNITY_SUPPORT_64
3619 TEST_IGNORE();
3620 #else
3621 TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
3622 TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996);
3623 TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005);
3624 #endif
3625 }
3626
testUINT64sNotWithinDelta(void)3627 void testUINT64sNotWithinDelta(void)
3628 {
3629 #ifndef UNITY_SUPPORT_64
3630 TEST_IGNORE();
3631 #else
3632 EXPECT_ABORT_BEGIN
3633 TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
3634 VERIFY_FAILS_END
3635 #endif
3636 }
3637
testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)3638 void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
3639 {
3640 #ifndef UNITY_SUPPORT_64
3641 TEST_IGNORE();
3642 #else
3643 EXPECT_ABORT_BEGIN
3644 TEST_ASSERT_UINT64_WITHIN(5, 1, -1);
3645 VERIFY_FAILS_END
3646 #endif
3647 }
3648
testINT64sWithinDelta(void)3649 void testINT64sWithinDelta(void)
3650 {
3651 #ifndef UNITY_SUPPORT_64
3652 TEST_IGNORE();
3653 #else
3654 TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
3655 TEST_ASSERT_INT64_WITHIN(5, 5000, 4996);
3656 TEST_ASSERT_INT64_WITHIN(5, 5000, 5005);
3657 #endif
3658 }
3659
testINT64sNotWithinDelta(void)3660 void testINT64sNotWithinDelta(void)
3661 {
3662 #ifndef UNITY_SUPPORT_64
3663 TEST_IGNORE();
3664 #else
3665 EXPECT_ABORT_BEGIN
3666 TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
3667 VERIFY_FAILS_END
3668 #endif
3669 }
3670
testINT64sNotWithinDeltaAndDifferenceOverflows(void)3671 void testINT64sNotWithinDeltaAndDifferenceOverflows(void)
3672 {
3673 #ifndef UNITY_SUPPORT_64
3674 TEST_IGNORE();
3675 #else
3676 EXPECT_ABORT_BEGIN
3677 TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF);
3678 VERIFY_FAILS_END
3679 #endif
3680 }
3681
testEqualHEX64Arrays(void)3682 void testEqualHEX64Arrays(void)
3683 {
3684 #ifndef UNITY_SUPPORT_64
3685 TEST_IGNORE();
3686 #else
3687 UNITY_UINT64 p0[] = {1, 8, 987, 65132u};
3688 UNITY_UINT64 p1[] = {1, 8, 987, 65132u};
3689 UNITY_UINT64 p2[] = {1, 8, 987, 2};
3690 UNITY_UINT64 p3[] = {1, 500, 600, 700};
3691
3692 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1);
3693 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4);
3694 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
3695 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3);
3696 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1);
3697 #endif
3698 }
3699
testEqualUint64Arrays(void)3700 void testEqualUint64Arrays(void)
3701 {
3702 #ifndef UNITY_SUPPORT_64
3703 TEST_IGNORE();
3704 #else
3705 UNITY_UINT64 p0[] = {1, 8, 987, 65132u};
3706 UNITY_UINT64 p1[] = {1, 8, 987, 65132u};
3707 UNITY_UINT64 p2[] = {1, 8, 987, 2};
3708 UNITY_UINT64 p3[] = {1, 500, 600, 700};
3709
3710 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1);
3711 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4);
3712 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4);
3713 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3);
3714 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1);
3715 #endif
3716 }
3717
testEqualInt64Arrays(void)3718 void testEqualInt64Arrays(void)
3719 {
3720 #ifndef UNITY_SUPPORT_64
3721 TEST_IGNORE();
3722 #else
3723 UNITY_INT64 p0[] = {1, 8, 987, -65132};
3724 UNITY_INT64 p1[] = {1, 8, 987, -65132};
3725 UNITY_INT64 p2[] = {1, 8, 987, -2};
3726 UNITY_INT64 p3[] = {1, 500, 600, 700};
3727
3728 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1);
3729 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4);
3730 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4);
3731 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3);
3732 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1);
3733 #endif
3734 }
3735
3736
testNotEqualHEX64Arrays1(void)3737 void testNotEqualHEX64Arrays1(void)
3738 {
3739 #ifndef UNITY_SUPPORT_64
3740 TEST_IGNORE();
3741 #else
3742 UNITY_UINT64 p0[] = {1, 8, 987, 65132u};
3743 UNITY_UINT64 p1[] = {1, 8, 987, 65131u};
3744
3745 EXPECT_ABORT_BEGIN
3746 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
3747 VERIFY_FAILS_END
3748 #endif
3749 }
3750
testNotEqualHEX64Arrays2(void)3751 void testNotEqualHEX64Arrays2(void)
3752 {
3753 #ifndef UNITY_SUPPORT_64
3754 TEST_IGNORE();
3755 #else
3756 UNITY_UINT64 p0[] = {1, 8, 987, 65132u};
3757 UNITY_UINT64 p1[] = {2, 8, 987, 65132u};
3758
3759 EXPECT_ABORT_BEGIN
3760 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
3761 VERIFY_FAILS_END
3762 #endif
3763 }
3764
testNotEqualUint64Arrays(void)3765 void testNotEqualUint64Arrays(void)
3766 {
3767 #ifndef UNITY_SUPPORT_64
3768 TEST_IGNORE();
3769 #else
3770 UNITY_UINT64 p0[] = {1, 8, 987, 65132u};
3771 UNITY_UINT64 p1[] = {1, 8, 987, 65131u};
3772
3773 EXPECT_ABORT_BEGIN
3774 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4);
3775 VERIFY_FAILS_END
3776 #endif
3777 }
3778
testNotEqualInt64Arrays(void)3779 void testNotEqualInt64Arrays(void)
3780 {
3781 #ifndef UNITY_SUPPORT_64
3782 TEST_IGNORE();
3783 #else
3784 UNITY_INT64 p0[] = {1, 8, 987, -65132};
3785 UNITY_INT64 p1[] = {1, 8, 987, -65131};
3786
3787 EXPECT_ABORT_BEGIN
3788 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4);
3789 VERIFY_FAILS_END
3790 #endif
3791 }
3792 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ==================
3793
testFloatsWithinDelta(void)3794 void testFloatsWithinDelta(void)
3795 {
3796 #ifdef UNITY_EXCLUDE_FLOAT
3797 TEST_IGNORE();
3798 #else
3799 TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
3800 TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
3801 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
3802 TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
3803 #endif
3804 }
3805
testFloatsNotWithinDelta(void)3806 void testFloatsNotWithinDelta(void)
3807 {
3808 #ifdef UNITY_EXCLUDE_FLOAT
3809 TEST_IGNORE();
3810 #else
3811 EXPECT_ABORT_BEGIN
3812 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
3813 VERIFY_FAILS_END
3814 #endif
3815 }
3816
testFloatsEqual(void)3817 void testFloatsEqual(void)
3818 {
3819 #ifdef UNITY_EXCLUDE_FLOAT
3820 TEST_IGNORE();
3821 #else
3822 TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
3823 TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
3824 TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
3825 TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
3826 #endif
3827 }
3828
testFloatsNotEqual(void)3829 void testFloatsNotEqual(void)
3830 {
3831 #ifdef UNITY_EXCLUDE_FLOAT
3832 TEST_IGNORE();
3833 #else
3834 EXPECT_ABORT_BEGIN
3835 TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
3836 VERIFY_FAILS_END
3837 #endif
3838 }
3839
testFloatsNotEqualNegative1(void)3840 void testFloatsNotEqualNegative1(void)
3841 {
3842 #ifdef UNITY_EXCLUDE_FLOAT
3843 TEST_IGNORE();
3844 #else
3845 EXPECT_ABORT_BEGIN
3846 TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
3847 VERIFY_FAILS_END
3848 #endif
3849 }
3850
testFloatsNotEqualNegative2(void)3851 void testFloatsNotEqualNegative2(void)
3852 {
3853 #ifdef UNITY_EXCLUDE_FLOAT
3854 TEST_IGNORE();
3855 #else
3856 EXPECT_ABORT_BEGIN
3857 TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
3858 VERIFY_FAILS_END
3859 #endif
3860 }
3861
testFloatsNotEqualActualNaN(void)3862 void testFloatsNotEqualActualNaN(void)
3863 {
3864 #ifdef UNITY_EXCLUDE_FLOAT
3865 TEST_IGNORE();
3866 #else
3867 EXPECT_ABORT_BEGIN
3868 TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero);
3869 VERIFY_FAILS_END
3870 #endif
3871 }
3872
testFloatsNotEqualExpectedNaN(void)3873 void testFloatsNotEqualExpectedNaN(void)
3874 {
3875 #ifdef UNITY_EXCLUDE_FLOAT
3876 TEST_IGNORE();
3877 #else
3878 EXPECT_ABORT_BEGIN
3879 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f);
3880 VERIFY_FAILS_END
3881 #endif
3882 }
3883
testFloatsEqualBothNaN(void)3884 void testFloatsEqualBothNaN(void)
3885 {
3886 #ifdef UNITY_EXCLUDE_FLOAT
3887 TEST_IGNORE();
3888 #else
3889 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
3890 #endif
3891 }
3892
testFloatsNotEqualInfNaN(void)3893 void testFloatsNotEqualInfNaN(void)
3894 {
3895 #ifdef UNITY_EXCLUDE_FLOAT
3896 TEST_IGNORE();
3897 #else
3898 EXPECT_ABORT_BEGIN
3899 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero);
3900 VERIFY_FAILS_END
3901 #endif
3902 }
3903
testFloatsNotEqualNaNInf(void)3904 void testFloatsNotEqualNaNInf(void)
3905 {
3906 #ifdef UNITY_EXCLUDE_FLOAT
3907 TEST_IGNORE();
3908 #else
3909 EXPECT_ABORT_BEGIN
3910 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero);
3911 VERIFY_FAILS_END
3912 #endif
3913 }
3914
testFloatsNotEqualActualInf(void)3915 void testFloatsNotEqualActualInf(void)
3916 {
3917 #ifdef UNITY_EXCLUDE_FLOAT
3918 TEST_IGNORE();
3919 #else
3920 EXPECT_ABORT_BEGIN
3921 TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero);
3922 VERIFY_FAILS_END
3923 #endif
3924 }
3925
testFloatsNotEqualExpectedInf(void)3926 void testFloatsNotEqualExpectedInf(void)
3927 {
3928 #ifdef UNITY_EXCLUDE_FLOAT
3929 TEST_IGNORE();
3930 #else
3931 EXPECT_ABORT_BEGIN
3932 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f);
3933 VERIFY_FAILS_END
3934 #endif
3935 }
3936
testFloatsEqualBothInf(void)3937 void testFloatsEqualBothInf(void)
3938 {
3939 #ifdef UNITY_EXCLUDE_FLOAT
3940 TEST_IGNORE();
3941 #else
3942 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
3943 #endif
3944 }
3945
testFloatsNotEqualPlusMinusInf(void)3946 void testFloatsNotEqualPlusMinusInf(void)
3947 {
3948 #ifdef UNITY_EXCLUDE_FLOAT
3949 TEST_IGNORE();
3950 #else
3951 EXPECT_ABORT_BEGIN
3952 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero);
3953 VERIFY_FAILS_END
3954 #endif
3955 }
3956
testFloatIsPosInf1(void)3957 void testFloatIsPosInf1(void)
3958 {
3959 #ifdef UNITY_EXCLUDE_FLOAT
3960 TEST_IGNORE();
3961 #else
3962 TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero);
3963 #endif
3964 }
3965
testFloatIsPosInf2(void)3966 void testFloatIsPosInf2(void)
3967 {
3968 #ifdef UNITY_EXCLUDE_FLOAT
3969 TEST_IGNORE();
3970 #else
3971 EXPECT_ABORT_BEGIN
3972 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero);
3973 VERIFY_FAILS_END
3974 #endif
3975 }
3976
testFloatIsNegInf1(void)3977 void testFloatIsNegInf1(void)
3978 {
3979 #ifdef UNITY_EXCLUDE_FLOAT
3980 TEST_IGNORE();
3981 #else
3982 TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero);
3983 #endif
3984 }
3985
testFloatIsNegInf2(void)3986 void testFloatIsNegInf2(void)
3987 {
3988 #ifdef UNITY_EXCLUDE_FLOAT
3989 TEST_IGNORE();
3990 #else
3991 EXPECT_ABORT_BEGIN
3992 TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero);
3993 VERIFY_FAILS_END
3994 #endif
3995 }
3996
testFloatIsNotPosInf1(void)3997 void testFloatIsNotPosInf1(void)
3998 {
3999 #ifdef UNITY_EXCLUDE_FLOAT
4000 TEST_IGNORE();
4001 #else
4002 EXPECT_ABORT_BEGIN
4003 TEST_ASSERT_FLOAT_IS_INF(2.0f);
4004 VERIFY_FAILS_END
4005 #endif
4006 }
4007
testFloatIsNotPosInf2(void)4008 void testFloatIsNotPosInf2(void)
4009 {
4010 #ifdef UNITY_EXCLUDE_FLOAT
4011 TEST_IGNORE();
4012 #else
4013 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f);
4014 #endif
4015 }
4016
testFloatIsNotNegInf(void)4017 void testFloatIsNotNegInf(void)
4018 {
4019 #ifdef UNITY_EXCLUDE_FLOAT
4020 TEST_IGNORE();
4021 #else
4022 EXPECT_ABORT_BEGIN
4023 TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f);
4024 VERIFY_FAILS_END
4025 #endif
4026 }
4027
testFloatIsNan1(void)4028 void testFloatIsNan1(void)
4029 {
4030 #ifdef UNITY_EXCLUDE_FLOAT
4031 TEST_IGNORE();
4032 #else
4033 TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero);
4034 #endif
4035 }
4036
testFloatIsNan2(void)4037 void testFloatIsNan2(void)
4038 {
4039 #ifdef UNITY_EXCLUDE_FLOAT
4040 TEST_IGNORE();
4041 #else
4042 EXPECT_ABORT_BEGIN
4043 TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero);
4044 VERIFY_FAILS_END
4045 #endif
4046 }
4047
testFloatIsNotNan1(void)4048 void testFloatIsNotNan1(void)
4049 {
4050 #ifdef UNITY_EXCLUDE_FLOAT
4051 TEST_IGNORE();
4052 #else
4053 EXPECT_ABORT_BEGIN
4054 TEST_ASSERT_FLOAT_IS_NAN(234.9f);
4055 VERIFY_FAILS_END
4056 #endif
4057 }
4058
testFloatIsNotNan2(void)4059 void testFloatIsNotNan2(void)
4060 {
4061 #ifdef UNITY_EXCLUDE_FLOAT
4062 TEST_IGNORE();
4063 #else
4064 TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f);
4065 #endif
4066 }
4067
testFloatInfIsNotNan(void)4068 void testFloatInfIsNotNan(void)
4069 {
4070 #ifdef UNITY_EXCLUDE_FLOAT
4071 TEST_IGNORE();
4072 #else
4073 EXPECT_ABORT_BEGIN
4074 TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero);
4075 VERIFY_FAILS_END
4076 #endif
4077 }
4078
testFloatNanIsNotInf(void)4079 void testFloatNanIsNotInf(void)
4080 {
4081 #ifdef UNITY_EXCLUDE_FLOAT
4082 TEST_IGNORE();
4083 #else
4084 EXPECT_ABORT_BEGIN
4085 TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero);
4086 VERIFY_FAILS_END
4087 #endif
4088 }
4089
testFloatIsDeterminate1(void)4090 void testFloatIsDeterminate1(void)
4091 {
4092 #ifdef UNITY_EXCLUDE_FLOAT
4093 TEST_IGNORE();
4094 #else
4095 TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f);
4096 TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f);
4097 TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f);
4098 #endif
4099 }
4100
testFloatIsDeterminate2(void)4101 void testFloatIsDeterminate2(void)
4102 {
4103 #ifdef UNITY_EXCLUDE_FLOAT
4104 TEST_IGNORE();
4105 #else
4106 EXPECT_ABORT_BEGIN
4107 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f);
4108 VERIFY_FAILS_END
4109 #endif
4110 }
4111
testFloatIsNotDeterminate1(void)4112 void testFloatIsNotDeterminate1(void)
4113 {
4114 #ifdef UNITY_EXCLUDE_FLOAT
4115 TEST_IGNORE();
4116 #else
4117 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero);
4118 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero);
4119 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero);
4120 #endif
4121 }
4122
testFloatIsNotDeterminate2(void)4123 void testFloatIsNotDeterminate2(void)
4124 {
4125 #ifdef UNITY_EXCLUDE_FLOAT
4126 TEST_IGNORE();
4127 #else
4128 EXPECT_ABORT_BEGIN
4129 TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero);
4130 VERIFY_FAILS_END
4131 #endif
4132 }
4133
testFloatTraitFailsOnInvalidTrait(void)4134 void testFloatTraitFailsOnInvalidTrait(void)
4135 {
4136 #ifdef UNITY_EXCLUDE_FLOAT
4137 TEST_IGNORE();
4138 #else
4139 EXPECT_ABORT_BEGIN
4140 UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
4141 VERIFY_FAILS_END
4142 #endif
4143 }
4144
4145
testEqualFloatArrays(void)4146 void testEqualFloatArrays(void)
4147 {
4148 #ifdef UNITY_EXCLUDE_FLOAT
4149 TEST_IGNORE();
4150 #else
4151 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f};
4152 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f};
4153 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f};
4154 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
4155
4156 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1);
4157 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4);
4158 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4159 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3);
4160 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1);
4161 TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1);
4162 #endif
4163 }
4164
testNotEqualFloatArraysExpectedNull(void)4165 void testNotEqualFloatArraysExpectedNull(void)
4166 {
4167 #ifdef UNITY_EXCLUDE_FLOAT
4168 TEST_IGNORE();
4169 #else
4170 float* p0 = NULL;
4171 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
4172
4173 EXPECT_ABORT_BEGIN
4174 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4175 VERIFY_FAILS_END
4176 #endif
4177 }
4178
testNotEqualFloatArraysActualNull(void)4179 void testNotEqualFloatArraysActualNull(void)
4180 {
4181 #ifdef UNITY_EXCLUDE_FLOAT
4182 TEST_IGNORE();
4183 #else
4184 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
4185 float* p1 = NULL;
4186
4187 EXPECT_ABORT_BEGIN
4188 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4189 VERIFY_FAILS_END
4190 #endif
4191 }
4192
testNotEqualFloatArrays1(void)4193 void testNotEqualFloatArrays1(void)
4194 {
4195 #ifdef UNITY_EXCLUDE_FLOAT
4196 TEST_IGNORE();
4197 #else
4198 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
4199 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
4200
4201 EXPECT_ABORT_BEGIN
4202 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4203 VERIFY_FAILS_END
4204 #endif
4205 }
4206
testNotEqualFloatArrays2(void)4207 void testNotEqualFloatArrays2(void)
4208 {
4209 #ifdef UNITY_EXCLUDE_FLOAT
4210 TEST_IGNORE();
4211 #else
4212 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
4213 float p1[] = {2.0f, 8.0f, 25.4f, 0.253f};
4214
4215 EXPECT_ABORT_BEGIN
4216 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4217 VERIFY_FAILS_END
4218 #endif
4219 }
4220
testNotEqualFloatArrays3(void)4221 void testNotEqualFloatArrays3(void)
4222 {
4223 #ifdef UNITY_EXCLUDE_FLOAT
4224 TEST_IGNORE();
4225 #else
4226 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
4227 float p1[] = {1.0f, 8.0f, 25.5f, 0.253f};
4228
4229 EXPECT_ABORT_BEGIN
4230 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4231 VERIFY_FAILS_END
4232 #endif
4233 }
4234
testNotEqualFloatArraysNegative1(void)4235 void testNotEqualFloatArraysNegative1(void)
4236 {
4237 #ifdef UNITY_EXCLUDE_FLOAT
4238 TEST_IGNORE();
4239 #else
4240 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
4241 float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f};
4242
4243 EXPECT_ABORT_BEGIN
4244 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4245 VERIFY_FAILS_END
4246 #endif
4247 }
4248
testNotEqualFloatArraysNegative2(void)4249 void testNotEqualFloatArraysNegative2(void)
4250 {
4251 #ifdef UNITY_EXCLUDE_FLOAT
4252 TEST_IGNORE();
4253 #else
4254 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
4255 float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f};
4256
4257 EXPECT_ABORT_BEGIN
4258 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4259 VERIFY_FAILS_END
4260 #endif
4261 }
4262
testNotEqualFloatArraysNegative3(void)4263 void testNotEqualFloatArraysNegative3(void)
4264 {
4265 #ifdef UNITY_EXCLUDE_FLOAT
4266 TEST_IGNORE();
4267 #else
4268 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
4269 float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f};
4270
4271 EXPECT_ABORT_BEGIN
4272 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4273 VERIFY_FAILS_END
4274 #endif
4275 }
4276
testEqualFloatArraysNaN(void)4277 void testEqualFloatArraysNaN(void)
4278 {
4279 #ifdef UNITY_EXCLUDE_FLOAT
4280 TEST_IGNORE();
4281 #else
4282 float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
4283 float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
4284
4285 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4286 #endif
4287 }
4288
testEqualFloatArraysInf(void)4289 void testEqualFloatArraysInf(void)
4290 {
4291 #ifdef UNITY_EXCLUDE_FLOAT
4292 TEST_IGNORE();
4293 #else
4294 float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
4295 float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
4296
4297 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
4298 #endif
4299 }
4300
testNotEqualFloatArraysLengthZero(void)4301 void testNotEqualFloatArraysLengthZero(void)
4302 {
4303 #ifdef UNITY_EXCLUDE_FLOAT
4304 TEST_IGNORE();
4305 #else
4306 float p0[1] = {0.0f};
4307 float p1[1] = {0.0f};
4308
4309 EXPECT_ABORT_BEGIN
4310 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0);
4311 VERIFY_FAILS_END
4312 #endif
4313 }
4314
testEqualFloatEachEqual(void)4315 void testEqualFloatEachEqual(void)
4316 {
4317 #ifdef UNITY_EXCLUDE_FLOAT
4318 TEST_IGNORE();
4319 #else
4320 float p0[] = {1.0f, 1.0f, 1.0f, 1.0f};
4321 float p1[] = {-0.123f, -0.123f, -0.123f, -0.123f};
4322 float p2[] = {25.4f, 25.4f, 25.4f, -0.2f};
4323 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
4324
4325 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 1);
4326 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4);
4327 TEST_ASSERT_EACH_EQUAL_FLOAT(-0.123f, p1, 4);
4328 TEST_ASSERT_EACH_EQUAL_FLOAT(25.4f, p2, 3);
4329 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p3, 1);
4330 #endif
4331 }
4332
testNotEqualFloatEachEqualActualNull(void)4333 void testNotEqualFloatEachEqualActualNull(void)
4334 {
4335 #ifdef UNITY_EXCLUDE_FLOAT
4336 TEST_IGNORE();
4337 #else
4338 float* p0 = NULL;
4339
4340 EXPECT_ABORT_BEGIN
4341 TEST_ASSERT_EACH_EQUAL_FLOAT(5, p0, 4);
4342 VERIFY_FAILS_END
4343 #endif
4344 }
4345
testNotEqualFloatEachEqual1(void)4346 void testNotEqualFloatEachEqual1(void)
4347 {
4348 #ifdef UNITY_EXCLUDE_FLOAT
4349 TEST_IGNORE();
4350 #else
4351 float p0[] = {0.253f, 8.0f, 0.253f, 0.253f};
4352
4353 EXPECT_ABORT_BEGIN
4354 TEST_ASSERT_EACH_EQUAL_FLOAT(0.253f, p0, 4);
4355 VERIFY_FAILS_END
4356 #endif
4357 }
4358
testNotEqualFloatEachEqual2(void)4359 void testNotEqualFloatEachEqual2(void)
4360 {
4361 #ifdef UNITY_EXCLUDE_FLOAT
4362 TEST_IGNORE();
4363 #else
4364 float p0[] = {8.0f, 8.0f, 8.0f, 0.253f};
4365
4366 EXPECT_ABORT_BEGIN
4367 TEST_ASSERT_EACH_EQUAL_FLOAT(8.0f, p0, 4);
4368 VERIFY_FAILS_END
4369 #endif
4370 }
4371
testNotEqualFloatEachEqual3(void)4372 void testNotEqualFloatEachEqual3(void)
4373 {
4374 #ifdef UNITY_EXCLUDE_FLOAT
4375 TEST_IGNORE();
4376 #else
4377 float p0[] = {1.0f, 1.0f, 1.0f, 0.253f};
4378
4379 EXPECT_ABORT_BEGIN
4380 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4);
4381 VERIFY_FAILS_END
4382 #endif
4383 }
4384
testNotEqualFloatEachEqualNegative1(void)4385 void testNotEqualFloatEachEqualNegative1(void)
4386 {
4387 #ifdef UNITY_EXCLUDE_FLOAT
4388 TEST_IGNORE();
4389 #else
4390 float p0[] = {-1.0f, -0.253f, -0.253f, -0.253f};
4391
4392 EXPECT_ABORT_BEGIN
4393 TEST_ASSERT_EACH_EQUAL_FLOAT(-0.253f, p0, 4);
4394 VERIFY_FAILS_END
4395 #endif
4396 }
4397
testNotEqualFloatEachEqualNegative2(void)4398 void testNotEqualFloatEachEqualNegative2(void)
4399 {
4400 #ifdef UNITY_EXCLUDE_FLOAT
4401 TEST_IGNORE();
4402 #else
4403 float p0[] = {-25.4f, -8.0f, -25.4f, -25.4f};
4404
4405 EXPECT_ABORT_BEGIN
4406 TEST_ASSERT_EACH_EQUAL_FLOAT(-25.4f, p0, 4);
4407 VERIFY_FAILS_END
4408 #endif
4409 }
4410
testNotEqualFloatEachEqualNegative3(void)4411 void testNotEqualFloatEachEqualNegative3(void)
4412 {
4413 #ifdef UNITY_EXCLUDE_FLOAT
4414 TEST_IGNORE();
4415 #else
4416 float p0[] = {-8.0f, -8.0f, -8.0f, -0.253f};
4417
4418 EXPECT_ABORT_BEGIN
4419 TEST_ASSERT_EACH_EQUAL_FLOAT(-8.0f, p0, 4);
4420 VERIFY_FAILS_END
4421 #endif
4422 }
4423
testEqualFloatEachEqualNaN(void)4424 void testEqualFloatEachEqualNaN(void)
4425 {
4426 #ifdef UNITY_EXCLUDE_FLOAT
4427 TEST_IGNORE();
4428 #else
4429 float p0[] = {0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero};
4430
4431 TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f / f_zero, p0, 4);
4432 #endif
4433 }
4434
testEqualFloatEachEqualInf(void)4435 void testEqualFloatEachEqualInf(void)
4436 {
4437 #ifdef UNITY_EXCLUDE_FLOAT
4438 TEST_IGNORE();
4439 #else
4440 float p0[] = {1.0f / f_zero, 1.0f / f_zero, 25.4f, 0.253f};
4441
4442 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f / f_zero, p0, 2);
4443 #endif
4444 }
4445
testNotEqualFloatEachEqualLengthZero(void)4446 void testNotEqualFloatEachEqualLengthZero(void)
4447 {
4448 #ifdef UNITY_EXCLUDE_FLOAT
4449 TEST_IGNORE();
4450 #else
4451 float p0[1] = {0.0f};
4452
4453 EXPECT_ABORT_BEGIN
4454 TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f, p0, 0);
4455 VERIFY_FAILS_END
4456 #endif
4457 }
4458
4459 #define TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, actual) { \
4460 startPutcharSpy(); UnityPrintFloat((actual)); endPutcharSpy(); \
4461 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \
4462 }
4463
testFloatPrinting(void)4464 void testFloatPrinting(void)
4465 {
4466 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
4467 TEST_IGNORE();
4468 #else
4469 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f);
4470 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f);
4471 TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f);
4472 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.100469499f);
4473 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999995f); /*Rounding to int place*/
4474 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f);
4475 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f);
4476 TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999", 7.99999f); /*Not rounding*/
4477 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0002", 16.0002f);
4478 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0004", 16.0004f);
4479 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0006", 16.0006f);
4480 TEST_ASSERT_EQUAL_PRINT_FLOATING("999999", 999999.0f); /*Last full print integer*/
4481
4482 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f);
4483 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f);
4484 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f);
4485 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.100469499f);
4486 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999995f); /*Rounding to int place*/
4487 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f);
4488 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f);
4489 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999", -7.99999f); /*Not rounding*/
4490 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0002", -16.0002f);
4491 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0004", -16.0004f);
4492 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0006", -16.0006f);
4493 TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999", -999999.0f); /*Last full print integer*/
4494
4495 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967296.0f);
4496 TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f);
4497 TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f);
4498 TEST_ASSERT_EQUAL_PRINT_FLOATING("8.31e+09", 8309999104.0f);
4499 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f);
4500 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f);
4501 /* Some compilers have trouble with inexact float constants, a float cast works generally */
4502 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00005e+10", (float)1.000054e+10f);
4503 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f);
4504 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.6353e+10", 1.63529943e+10f);
4505 TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282e+38", 3.40282346638e38f);
4506
4507 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f);
4508 TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282e+38", -3.40282346638e38f);
4509 #endif
4510 }
4511
testFloatPrintingInfinityAndNaN(void)4512 void testFloatPrintingInfinityAndNaN(void)
4513 {
4514 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
4515 TEST_IGNORE();
4516 #else
4517 TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero);
4518 TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero);
4519
4520 TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero);
4521 #endif
4522 }
4523
4524 #if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
printFloatValue(float f)4525 static void printFloatValue(float f)
4526 {
4527 char expected[18];
4528 char expected_lower[18];
4529 char expected_higher[18];
4530
4531 startPutcharSpy();
4532
4533 UnityPrintFloat(f);
4534
4535 sprintf(expected, "%.6g", f);
4536
4537 /* We print all NaN's as "nan", not "-nan" */
4538 if(strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
4539
4540 /* Allow for rounding differences in last digit */
4541 double lower = (double)f * 0.9999995;
4542 double higher = (double)f * 1.0000005;
4543
4544 if (isfinite(lower)) sprintf(expected_lower, "%.6g", lower); else strcpy(expected_lower, expected);
4545 if (isfinite(higher)) sprintf(expected_higher, "%.6g", higher); else strcpy(expected_higher, expected);
4546
4547 if (strcmp(expected, getBufferPutcharSpy()) != 0 &&
4548 strcmp(expected_lower, getBufferPutcharSpy()) != 0 &&
4549 strcmp(expected_higher, getBufferPutcharSpy()) != 0)
4550 {
4551 /* Fail with diagnostic printing */
4552 TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
4553 }
4554 }
4555 #endif
4556
testFloatPrintingRandomSamples(void)4557 void testFloatPrintingRandomSamples(void)
4558 {
4559 #if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY)
4560 TEST_IGNORE();
4561 #else
4562 union { float f_value; uint32_t int_value; } u;
4563
4564 /* These values are not covered by the MINSTD generator */
4565 u.int_value = 0x00000000; printFloatValue(u.f_value);
4566 u.int_value = 0x80000000; printFloatValue(u.f_value);
4567 u.int_value = 0x7fffffff; printFloatValue(u.f_value);
4568 u.int_value = 0xffffffff; printFloatValue(u.f_value);
4569
4570 uint32_t a = 1;
4571 for(int num_tested = 0; num_tested < 1000000; num_tested++)
4572 {
4573 /* MINSTD pseudo-random number generator */
4574 a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u);
4575
4576 /* MINSTD does not set the highest bit; test both possibilities */
4577 u.int_value = a; printFloatValue(u.f_value);
4578 u.int_value = a | 0x80000000; printFloatValue(u.f_value);
4579 }
4580 #endif
4581 }
4582
4583 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DOUBLE SUPPORT ==================
4584
testDoublesWithinDelta(void)4585 void testDoublesWithinDelta(void)
4586 {
4587 #ifdef UNITY_EXCLUDE_DOUBLE
4588 TEST_IGNORE();
4589 #else
4590 TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488);
4591 TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0);
4592 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049);
4593 TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424);
4594 #endif
4595 }
4596
testDoublesNotWithinDelta(void)4597 void testDoublesNotWithinDelta(void)
4598 {
4599 #ifdef UNITY_EXCLUDE_DOUBLE
4600 TEST_IGNORE();
4601 #else
4602 EXPECT_ABORT_BEGIN
4603 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049);
4604 VERIFY_FAILS_END
4605 #endif
4606 }
4607
4608
testDoublesEqual(void)4609 void testDoublesEqual(void)
4610 {
4611 #ifdef UNITY_EXCLUDE_DOUBLE
4612 TEST_IGNORE();
4613 #else
4614 TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0);
4615 TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6);
4616 TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699);
4617 TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
4618 #endif
4619 }
4620
testDoublesNotEqual(void)4621 void testDoublesNotEqual(void)
4622 {
4623 #ifdef UNITY_EXCLUDE_DOUBLE
4624 TEST_IGNORE();
4625 #else
4626 EXPECT_ABORT_BEGIN
4627 TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049);
4628 VERIFY_FAILS_END
4629 #endif
4630 }
4631
testDoublesNotEqualNegative1(void)4632 void testDoublesNotEqualNegative1(void)
4633 {
4634 #ifdef UNITY_EXCLUDE_DOUBLE
4635 TEST_IGNORE();
4636 #else
4637 EXPECT_ABORT_BEGIN
4638 TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
4639 VERIFY_FAILS_END
4640 #endif
4641 }
4642
testDoublesNotEqualNegative2(void)4643 void testDoublesNotEqualNegative2(void)
4644 {
4645 #ifdef UNITY_EXCLUDE_DOUBLE
4646 TEST_IGNORE();
4647 #else
4648 EXPECT_ABORT_BEGIN
4649 TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
4650 VERIFY_FAILS_END
4651 #endif
4652 }
4653
testDoublesNotEqualActualNaN(void)4654 void testDoublesNotEqualActualNaN(void)
4655 {
4656 #ifdef UNITY_EXCLUDE_DOUBLE
4657 TEST_IGNORE();
4658 #else
4659 EXPECT_ABORT_BEGIN
4660 TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
4661 VERIFY_FAILS_END
4662 #endif
4663 }
4664
testDoublesNotEqualExpectedNaN(void)4665 void testDoublesNotEqualExpectedNaN(void)
4666 {
4667 #ifdef UNITY_EXCLUDE_DOUBLE
4668 TEST_IGNORE();
4669 #else
4670 EXPECT_ABORT_BEGIN
4671 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
4672 VERIFY_FAILS_END
4673 #endif
4674 }
4675
testDoublesEqualBothNaN(void)4676 void testDoublesEqualBothNaN(void)
4677 {
4678 #ifdef UNITY_EXCLUDE_DOUBLE
4679 TEST_IGNORE();
4680 #else
4681 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
4682 #endif
4683 }
4684
testDoublesNotEqualInfNaN(void)4685 void testDoublesNotEqualInfNaN(void)
4686 {
4687 #ifdef UNITY_EXCLUDE_DOUBLE
4688 TEST_IGNORE();
4689 #else
4690 EXPECT_ABORT_BEGIN
4691 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
4692 VERIFY_FAILS_END
4693 #endif
4694 }
4695
testDoublesNotEqualNaNInf(void)4696 void testDoublesNotEqualNaNInf(void)
4697 {
4698 #ifdef UNITY_EXCLUDE_DOUBLE
4699 TEST_IGNORE();
4700 #else
4701 EXPECT_ABORT_BEGIN
4702 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
4703 VERIFY_FAILS_END
4704 #endif
4705 }
4706
testDoublesNotEqualActualInf(void)4707 void testDoublesNotEqualActualInf(void)
4708 {
4709 #ifdef UNITY_EXCLUDE_DOUBLE
4710 TEST_IGNORE();
4711 #else
4712 EXPECT_ABORT_BEGIN
4713 TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
4714 VERIFY_FAILS_END
4715 #endif
4716 }
4717
testDoublesNotEqualExpectedInf(void)4718 void testDoublesNotEqualExpectedInf(void)
4719 {
4720 #ifdef UNITY_EXCLUDE_DOUBLE
4721 TEST_IGNORE();
4722 #else
4723 EXPECT_ABORT_BEGIN
4724 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
4725 VERIFY_FAILS_END
4726 #endif
4727 }
4728
testDoublesEqualBothInf(void)4729 void testDoublesEqualBothInf(void)
4730 {
4731 #ifdef UNITY_EXCLUDE_DOUBLE
4732 TEST_IGNORE();
4733 #else
4734 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
4735 #endif
4736 }
4737
testDoublesNotEqualPlusMinusInf(void)4738 void testDoublesNotEqualPlusMinusInf(void)
4739 {
4740 #ifdef UNITY_EXCLUDE_DOUBLE
4741 TEST_IGNORE();
4742 #else
4743 EXPECT_ABORT_BEGIN
4744 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
4745 VERIFY_FAILS_END
4746 #endif
4747 }
4748
testDoubleIsPosInf1(void)4749 void testDoubleIsPosInf1(void)
4750 {
4751 #ifdef UNITY_EXCLUDE_DOUBLE
4752 TEST_IGNORE();
4753 #else
4754 TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero);
4755 #endif
4756 }
4757
testDoubleIsPosInf2(void)4758 void testDoubleIsPosInf2(void)
4759 {
4760 #ifdef UNITY_EXCLUDE_DOUBLE
4761 TEST_IGNORE();
4762 #else
4763 EXPECT_ABORT_BEGIN
4764 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero);
4765 VERIFY_FAILS_END
4766 #endif
4767 }
4768
testDoubleIsNegInf1(void)4769 void testDoubleIsNegInf1(void)
4770 {
4771 #ifdef UNITY_EXCLUDE_DOUBLE
4772 TEST_IGNORE();
4773 #else
4774 TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero);
4775 #endif
4776 }
4777
testDoubleIsNegInf2(void)4778 void testDoubleIsNegInf2(void)
4779 {
4780 #ifdef UNITY_EXCLUDE_DOUBLE
4781 TEST_IGNORE();
4782 #else
4783 EXPECT_ABORT_BEGIN
4784 TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero);
4785 VERIFY_FAILS_END
4786 #endif
4787 }
4788
testDoubleIsNotPosInf1(void)4789 void testDoubleIsNotPosInf1(void)
4790 {
4791 #ifdef UNITY_EXCLUDE_DOUBLE
4792 TEST_IGNORE();
4793 #else
4794 EXPECT_ABORT_BEGIN
4795 TEST_ASSERT_DOUBLE_IS_INF(2.0);
4796 VERIFY_FAILS_END
4797 #endif
4798 }
4799
testDoubleIsNotPosInf2(void)4800 void testDoubleIsNotPosInf2(void)
4801 {
4802 #ifdef UNITY_EXCLUDE_DOUBLE
4803 TEST_IGNORE();
4804 #else
4805 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0);
4806 #endif
4807 }
4808
testDoubleIsNotNegInf(void)4809 void testDoubleIsNotNegInf(void)
4810 {
4811 #ifdef UNITY_EXCLUDE_DOUBLE
4812 TEST_IGNORE();
4813 #else
4814 EXPECT_ABORT_BEGIN
4815 TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876);
4816 VERIFY_FAILS_END
4817 #endif
4818 }
4819
testDoubleIsNan1(void)4820 void testDoubleIsNan1(void)
4821 {
4822 #ifdef UNITY_EXCLUDE_DOUBLE
4823 TEST_IGNORE();
4824 #else
4825 TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero);
4826 #endif
4827 }
4828
testDoubleIsNan2(void)4829 void testDoubleIsNan2(void)
4830 {
4831 #ifdef UNITY_EXCLUDE_DOUBLE
4832 TEST_IGNORE();
4833 #else
4834 EXPECT_ABORT_BEGIN
4835 TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero);
4836 VERIFY_FAILS_END
4837 #endif
4838 }
4839
testDoubleIsNotNan1(void)4840 void testDoubleIsNotNan1(void)
4841 {
4842 #ifdef UNITY_EXCLUDE_DOUBLE
4843 TEST_IGNORE();
4844 #else
4845 EXPECT_ABORT_BEGIN
4846 TEST_ASSERT_DOUBLE_IS_NAN(234.9);
4847 VERIFY_FAILS_END
4848 #endif
4849 }
4850
testDoubleIsNotNan2(void)4851 void testDoubleIsNotNan2(void)
4852 {
4853 #ifdef UNITY_EXCLUDE_DOUBLE
4854 TEST_IGNORE();
4855 #else
4856 TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9);
4857 #endif
4858 }
4859
testDoubleInfIsNotNan(void)4860 void testDoubleInfIsNotNan(void)
4861 {
4862 #ifdef UNITY_EXCLUDE_DOUBLE
4863 TEST_IGNORE();
4864 #else
4865 EXPECT_ABORT_BEGIN
4866 TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero);
4867 VERIFY_FAILS_END
4868 #endif
4869 }
4870
testDoubleNanIsNotInf(void)4871 void testDoubleNanIsNotInf(void)
4872 {
4873 #ifdef UNITY_EXCLUDE_DOUBLE
4874 TEST_IGNORE();
4875 #else
4876 EXPECT_ABORT_BEGIN
4877 TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero);
4878 VERIFY_FAILS_END
4879 #endif
4880 }
4881
testDoubleIsDeterminate1(void)4882 void testDoubleIsDeterminate1(void)
4883 {
4884 #ifdef UNITY_EXCLUDE_DOUBLE
4885 TEST_IGNORE();
4886 #else
4887 TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0);
4888 TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3);
4889 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3);
4890 #endif
4891 }
4892
testDoubleIsDeterminate2(void)4893 void testDoubleIsDeterminate2(void)
4894 {
4895 #ifdef UNITY_EXCLUDE_DOUBLE
4896 TEST_IGNORE();
4897 #else
4898 EXPECT_ABORT_BEGIN
4899 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3);
4900 VERIFY_FAILS_END
4901 #endif
4902 }
4903
testDoubleIsNotDeterminate1(void)4904 void testDoubleIsNotDeterminate1(void)
4905 {
4906 #ifdef UNITY_EXCLUDE_DOUBLE
4907 TEST_IGNORE();
4908 #else
4909 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero);
4910 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero);
4911 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero);
4912 #endif
4913 }
4914
testDoubleIsNotDeterminate2(void)4915 void testDoubleIsNotDeterminate2(void)
4916 {
4917 #ifdef UNITY_EXCLUDE_DOUBLE
4918 TEST_IGNORE();
4919 #else
4920 EXPECT_ABORT_BEGIN
4921 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero);
4922 VERIFY_FAILS_END
4923 #endif
4924 }
4925
testDoubleTraitFailsOnInvalidTrait(void)4926 void testDoubleTraitFailsOnInvalidTrait(void)
4927 {
4928 #ifdef UNITY_EXCLUDE_DOUBLE
4929 TEST_IGNORE();
4930 #else
4931 EXPECT_ABORT_BEGIN
4932 UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
4933 VERIFY_FAILS_END
4934 #endif
4935 }
4936
testEqualDoubleArrays(void)4937 void testEqualDoubleArrays(void)
4938 {
4939 #ifdef UNITY_EXCLUDE_DOUBLE
4940 TEST_IGNORE();
4941 #else
4942 double p0[] = {1.0, -8.0, 25.4, -0.123};
4943 double p1[] = {1.0, -8.0, 25.4, -0.123};
4944 double p2[] = {1.0, -8.0, 25.4, -0.2};
4945 double p3[] = {1.0, -23.0, 25.0, -0.26};
4946
4947 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1);
4948 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4);
4949 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
4950 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3);
4951 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1);
4952 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1);
4953 #endif
4954 }
4955
testNotEqualDoubleArraysExpectedNull(void)4956 void testNotEqualDoubleArraysExpectedNull(void)
4957 {
4958 #ifdef UNITY_EXCLUDE_DOUBLE
4959 TEST_IGNORE();
4960 #else
4961 double* p0 = NULL;
4962 double p1[] = {1.0, 8.0, 25.4, 0.252};
4963
4964 EXPECT_ABORT_BEGIN
4965 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
4966 VERIFY_FAILS_END
4967 #endif
4968 }
4969
testNotEqualDoubleArraysActualNull(void)4970 void testNotEqualDoubleArraysActualNull(void)
4971 {
4972 #ifdef UNITY_EXCLUDE_DOUBLE
4973 TEST_IGNORE();
4974 #else
4975 double p0[] = {1.0, 8.0, 25.4, 0.253};
4976 double* p1 = NULL;
4977
4978 EXPECT_ABORT_BEGIN
4979 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
4980 VERIFY_FAILS_END
4981 #endif
4982 }
4983
testNotEqualDoubleArrays1(void)4984 void testNotEqualDoubleArrays1(void)
4985 {
4986 #ifdef UNITY_EXCLUDE_DOUBLE
4987 TEST_IGNORE();
4988 #else
4989 double p0[] = {1.0, 8.0, 25.4, 0.25666666667};
4990 double p1[] = {1.0, 8.0, 25.4, 0.25666666666};
4991
4992 EXPECT_ABORT_BEGIN
4993 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
4994 VERIFY_FAILS_END
4995 #endif
4996 }
4997
testNotEqualDoubleArrays2(void)4998 void testNotEqualDoubleArrays2(void)
4999 {
5000 #ifdef UNITY_EXCLUDE_DOUBLE
5001 TEST_IGNORE();
5002 #else
5003 double p0[] = {1.0, 8.0, 25.4, 0.253};
5004 double p1[] = {2.0, 8.0, 25.4, 0.253};
5005
5006 EXPECT_ABORT_BEGIN
5007 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5008 VERIFY_FAILS_END
5009 #endif
5010 }
5011
testNotEqualDoubleArrays3(void)5012 void testNotEqualDoubleArrays3(void)
5013 {
5014 #ifdef UNITY_EXCLUDE_DOUBLE
5015 TEST_IGNORE();
5016 #else
5017 double p0[] = {1.0, 8.0, 25.4, 0.253};
5018 double p1[] = {1.0, 8.0, 25.5, 0.253};
5019
5020 EXPECT_ABORT_BEGIN
5021 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5022 VERIFY_FAILS_END
5023 #endif
5024 }
5025
testNotEqualDoubleArraysNegative1(void)5026 void testNotEqualDoubleArraysNegative1(void)
5027 {
5028 #ifdef UNITY_EXCLUDE_DOUBLE
5029 TEST_IGNORE();
5030 #else
5031 double p0[] = {-1.0, -8.0, -25.4, -0.2566666667};
5032 double p1[] = {-1.0, -8.0, -25.4, -0.2566666666};
5033
5034 EXPECT_ABORT_BEGIN
5035 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5036 VERIFY_FAILS_END
5037 #endif
5038 }
5039
testNotEqualDoubleArraysNegative2(void)5040 void testNotEqualDoubleArraysNegative2(void)
5041 {
5042 #ifdef UNITY_EXCLUDE_DOUBLE
5043 TEST_IGNORE();
5044 #else
5045 double p0[] = {-1.0, -8.0, -25.4, -0.253};
5046 double p1[] = {-2.0, -8.0, -25.4, -0.253};
5047
5048 EXPECT_ABORT_BEGIN
5049 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5050 VERIFY_FAILS_END
5051 #endif
5052 }
5053
testNotEqualDoubleArraysNegative3(void)5054 void testNotEqualDoubleArraysNegative3(void)
5055 {
5056 #ifdef UNITY_EXCLUDE_DOUBLE
5057 TEST_IGNORE();
5058 #else
5059 double p0[] = {-1.0, -8.0, -25.4, -0.253};
5060 double p1[] = {-1.0, -8.0, -25.5, -0.253};
5061
5062 EXPECT_ABORT_BEGIN
5063 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5064 VERIFY_FAILS_END
5065 #endif
5066 }
5067
testEqualDoubleArraysNaN(void)5068 void testEqualDoubleArraysNaN(void)
5069 {
5070 #ifdef UNITY_EXCLUDE_DOUBLE
5071 TEST_IGNORE();
5072 #else
5073 double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
5074 double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
5075
5076 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5077 #endif
5078 }
5079
testEqualDoubleArraysInf(void)5080 void testEqualDoubleArraysInf(void)
5081 {
5082 #ifdef UNITY_EXCLUDE_DOUBLE
5083 TEST_IGNORE();
5084 #else
5085 double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
5086 double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
5087
5088 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
5089 #endif
5090 }
5091
testNotEqualDoubleArraysLengthZero(void)5092 void testNotEqualDoubleArraysLengthZero(void)
5093 {
5094 #ifdef UNITY_EXCLUDE_DOUBLE
5095 TEST_IGNORE();
5096 #else
5097 double p0[1] = {0.0};
5098 double p1[1] = {0.0};
5099
5100 EXPECT_ABORT_BEGIN
5101 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0);
5102 VERIFY_FAILS_END
5103 #endif
5104 }
5105
testEqualDoubleEachEqual(void)5106 void testEqualDoubleEachEqual(void)
5107 {
5108 #ifdef UNITY_EXCLUDE_DOUBLE
5109 TEST_IGNORE();
5110 #else
5111 double p0[] = {1.0, 1.0, 1.0, 1.0};
5112 double p1[] = {-0.123, -0.123, -0.123, -0.123};
5113 double p2[] = {25.4, 25.4, 25.4, -0.2};
5114 double p3[] = {1.0, -23.0, 25.0, -0.26};
5115
5116 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 1);
5117 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4);
5118 TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.123, p1, 4);
5119 TEST_ASSERT_EACH_EQUAL_DOUBLE(25.4, p2, 3);
5120 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p3, 1);
5121 #endif
5122 }
5123
testNotEqualDoubleEachEqualActualNull(void)5124 void testNotEqualDoubleEachEqualActualNull(void)
5125 {
5126 #ifdef UNITY_EXCLUDE_DOUBLE
5127 TEST_IGNORE();
5128 #else
5129 double* p0 = NULL;
5130
5131 EXPECT_ABORT_BEGIN
5132 TEST_ASSERT_EACH_EQUAL_DOUBLE(5, p0, 4);
5133 VERIFY_FAILS_END
5134 #endif
5135 }
5136
testNotEqualDoubleEachEqual1(void)5137 void testNotEqualDoubleEachEqual1(void)
5138 {
5139 #ifdef UNITY_EXCLUDE_DOUBLE
5140 TEST_IGNORE();
5141 #else
5142 double p0[] = {0.253, 8.0, 0.253, 0.253};
5143
5144 EXPECT_ABORT_BEGIN
5145 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.253, p0, 4);
5146 VERIFY_FAILS_END
5147 #endif
5148 }
5149
testNotEqualDoubleEachEqual2(void)5150 void testNotEqualDoubleEachEqual2(void)
5151 {
5152 #ifdef UNITY_EXCLUDE_DOUBLE
5153 TEST_IGNORE();
5154 #else
5155 double p0[] = {8.0, 8.0, 8.0, 0.253};
5156
5157 EXPECT_ABORT_BEGIN
5158 TEST_ASSERT_EACH_EQUAL_DOUBLE(8.0, p0, 4);
5159 VERIFY_FAILS_END
5160 #endif
5161 }
5162
testNotEqualDoubleEachEqual3(void)5163 void testNotEqualDoubleEachEqual3(void)
5164 {
5165 #ifdef UNITY_EXCLUDE_DOUBLE
5166 TEST_IGNORE();
5167 #else
5168 double p0[] = {1.0, 1.0, 1.0, 0.253};
5169
5170 EXPECT_ABORT_BEGIN
5171 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4);
5172 VERIFY_FAILS_END
5173 #endif
5174 }
5175
testNotEqualDoubleEachEqualNegative1(void)5176 void testNotEqualDoubleEachEqualNegative1(void)
5177 {
5178 #ifdef UNITY_EXCLUDE_DOUBLE
5179 TEST_IGNORE();
5180 #else
5181 double p0[] = {-1.0, -0.253, -0.253, -0.253};
5182
5183 EXPECT_ABORT_BEGIN
5184 TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.253, p0, 4);
5185 VERIFY_FAILS_END
5186 #endif
5187 }
5188
testNotEqualDoubleEachEqualNegative2(void)5189 void testNotEqualDoubleEachEqualNegative2(void)
5190 {
5191 #ifdef UNITY_EXCLUDE_DOUBLE
5192 TEST_IGNORE();
5193 #else
5194 double p0[] = {-25.4, -8.0, -25.4, -25.4};
5195
5196 EXPECT_ABORT_BEGIN
5197 TEST_ASSERT_EACH_EQUAL_DOUBLE(-25.4, p0, 4);
5198 VERIFY_FAILS_END
5199 #endif
5200 }
5201
testNotEqualDoubleEachEqualNegative3(void)5202 void testNotEqualDoubleEachEqualNegative3(void)
5203 {
5204 #ifdef UNITY_EXCLUDE_DOUBLE
5205 TEST_IGNORE();
5206 #else
5207 double p0[] = {-8.0, -8.0, -8.0, -0.253};
5208
5209 EXPECT_ABORT_BEGIN
5210 TEST_ASSERT_EACH_EQUAL_DOUBLE(-8.0, p0, 4);
5211 VERIFY_FAILS_END
5212 #endif
5213 }
5214
testEqualDoubleEachEqualNaN(void)5215 void testEqualDoubleEachEqualNaN(void)
5216 {
5217 #ifdef UNITY_EXCLUDE_DOUBLE
5218 TEST_IGNORE();
5219 #else
5220 double p0[] = {0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero};
5221
5222 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0 / d_zero, p0, 4);
5223 #endif
5224 }
5225
testEqualDoubleEachEqualInf(void)5226 void testEqualDoubleEachEqualInf(void)
5227 {
5228 #ifdef UNITY_EXCLUDE_DOUBLE
5229 TEST_IGNORE();
5230 #else
5231 double p0[] = {1.0 / d_zero, 1.0 / d_zero, 25.4, 0.253};
5232
5233 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0 / d_zero, p0, 2);
5234 #endif
5235 }
5236
testNotEqualDoubleEachEqualLengthZero(void)5237 void testNotEqualDoubleEachEqualLengthZero(void)
5238 {
5239 #ifdef UNITY_EXCLUDE_DOUBLE
5240 TEST_IGNORE();
5241 #else
5242 double p0[1] = {0.0};
5243
5244 EXPECT_ABORT_BEGIN
5245 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0, p0, 0);
5246 VERIFY_FAILS_END
5247 #endif
5248 }
5249
testDoublePrinting(void)5250 void testDoublePrinting(void)
5251 {
5252 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
5253 TEST_IGNORE();
5254 #else
5255 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.10046949999999999);
5256 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.999999);
5257 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.9999995);
5258 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967296.0);
5259 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0);
5260 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.0072e+15", 9007199254740990.0);
5261 TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100);
5262 TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200);
5263 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23457e+300", 9.23456789e+300);
5264
5265 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999);
5266 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.999999);
5267 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.9999995);
5268 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100);
5269 #endif
5270 }
5271
testDoublePrintingInfinityAndNaN(void)5272 void testDoublePrintingInfinityAndNaN(void)
5273 {
5274 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
5275 TEST_IGNORE();
5276 #else
5277 TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero);
5278 TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero);
5279
5280 TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero);
5281 #endif
5282 }
5283
5284 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ==================
5285
testThatDetailsCanBeHandleOneDetail(void)5286 void testThatDetailsCanBeHandleOneDetail(void)
5287 {
5288 #ifdef UNITY_EXCLUDE_DETAILS
5289 TEST_IGNORE();
5290 #else
5291 UNITY_SET_DETAIL("Detail1");
5292
5293 EXPECT_ABORT_BEGIN
5294 TEST_ASSERT_EQUAL_INT_MESSAGE(5, 6, "Should Fail And Say Detail1");
5295 VERIFY_FAILS_END
5296 #endif
5297 }
5298
testThatDetailsCanHandleTestFail(void)5299 void testThatDetailsCanHandleTestFail(void)
5300 {
5301 #ifdef UNITY_EXCLUDE_DETAILS
5302 TEST_IGNORE();
5303 #else
5304 UNITY_SET_DETAILS("Detail1","Detail2");
5305
5306 EXPECT_ABORT_BEGIN
5307 TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2");
5308 VERIFY_FAILS_END
5309 #endif
5310 }
5311
testThatDetailsCanBeHandleTwoDetails(void)5312 void testThatDetailsCanBeHandleTwoDetails(void)
5313 {
5314 #ifdef UNITY_EXCLUDE_DETAILS
5315 TEST_IGNORE();
5316 #else
5317 UNITY_SET_DETAILS("Detail1","Detail2");
5318
5319 EXPECT_ABORT_BEGIN
5320 TEST_ASSERT_EQUAL_HEX8_MESSAGE(7, 8, "Should Fail And Say Detail1 and Detail2");
5321 VERIFY_FAILS_END
5322 #endif
5323 }
5324
testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void)5325 void testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void)
5326 {
5327 #ifdef UNITY_EXCLUDE_DETAILS
5328 TEST_IGNORE();
5329 #else
5330 UNITY_SET_DETAILS("Detail1","Detail2");
5331 UNITY_SET_DETAIL("DetailNew");
5332
5333 EXPECT_ABORT_BEGIN
5334 TEST_ASSERT_EQUAL_STRING_MESSAGE("MEH", "GUH", "Should Fail And Say DetailNew");
5335 VERIFY_FAILS_END
5336 #endif
5337 }
5338