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#define TEST_INSTANCES
9#include "self_assessment_utils.h"
10
11static int SetToOneToFailInTearDown;
12static int SetToOneMeanWeAlreadyCheckedThisGuy;
13
14void setUp(void)
15{
16    SetToOneToFailInTearDown = 0;
17    SetToOneMeanWeAlreadyCheckedThisGuy = 0;
18}
19
20void tearDown(void)
21{
22    endPutcharSpy(); /* Stop suppressing test output */
23    if (SetToOneToFailInTearDown == 1)
24    {
25        /* These will be skipped internally if already failed/ignored */
26        TEST_FAIL_MESSAGE("<= Failed in tearDown");
27        TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
28    }
29    if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
30    {
31        UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
32        UNITY_OUTPUT_CHAR('\n');
33    }
34}
35
36void testInt64ArrayWithinDelta(void)
37{
38#ifndef UNITY_SUPPORT_64
39    TEST_IGNORE();
40#else
41    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
42    UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005};
43    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
44
45    TEST_ASSERT_INT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3);
46    TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3);
47#endif
48}
49
50void testInt64ArrayWithinDeltaAndMessage(void)
51{
52#ifndef UNITY_SUPPORT_64
53    TEST_IGNORE();
54#else
55    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
56    UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005};
57    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
58
59    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message.");
60    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message.");
61#endif
62}
63
64void testInt64ArrayNotWithinDelta(void)
65{
66#ifndef UNITY_SUPPORT_64
67    TEST_IGNORE();
68#else
69    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
70    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
71
72    EXPECT_ABORT_BEGIN
73    TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3);
74    VERIFY_FAILS_END
75#endif
76}
77
78void testInt64ArrayNotWithinDeltaAndMessage(void)
79{
80#ifndef UNITY_SUPPORT_64
81    TEST_IGNORE();
82#else
83    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
84    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
85
86    EXPECT_ABORT_BEGIN
87    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message.");
88    VERIFY_FAILS_END
89#endif
90}
91
92void testInt64ArrayWithinDeltaPointless(void)
93{
94#ifndef UNITY_SUPPORT_64
95    TEST_IGNORE();
96#else
97    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
98    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
99
100    EXPECT_ABORT_BEGIN
101    TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0);
102    VERIFY_FAILS_END
103#endif
104}
105
106void testInt64ArrayWithinDeltaPointlessAndMessage(void)
107{
108#ifndef UNITY_SUPPORT_64
109    TEST_IGNORE();
110#else
111    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
112    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
113
114    EXPECT_ABORT_BEGIN
115    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message.");
116    VERIFY_FAILS_END
117#endif
118}
119
120void testInt64ArrayWithinDeltaExpectedNull(void)
121{
122#ifndef UNITY_SUPPORT_64
123    TEST_IGNORE();
124#else
125    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
126
127    EXPECT_ABORT_BEGIN
128    TEST_ASSERT_INT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3);
129    VERIFY_FAILS_END
130#endif
131}
132
133void testInt64ArrayWithinDeltaExpectedNullAndMessage(void)
134{
135#ifndef UNITY_SUPPORT_64
136    TEST_IGNORE();
137#else
138    UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
139
140    EXPECT_ABORT_BEGIN
141    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message.");
142    VERIFY_FAILS_END
143#endif
144}
145
146void testInt64ArrayWithinDeltaActualNull(void)
147{
148#ifndef UNITY_SUPPORT_64
149    TEST_IGNORE();
150#else
151    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
152
153    EXPECT_ABORT_BEGIN
154    TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, NULL, 3);
155    VERIFY_FAILS_END
156#endif
157}
158
159void testInt64ArrayWithinDeltaActualNullAndMessage(void)
160{
161#ifndef UNITY_SUPPORT_64
162    TEST_IGNORE();
163#else
164    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
165
166    EXPECT_ABORT_BEGIN
167    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message.");
168    VERIFY_FAILS_END
169#endif
170}
171
172void testInt64ArrayWithinDeltaSamePointer(void)
173{
174#ifndef UNITY_SUPPORT_64
175    TEST_IGNORE();
176#else
177    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
178
179    TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3);
180#endif
181}
182
183void testInt64ArrayWithinDeltaSamePointerAndMessage(void)
184{
185#ifndef UNITY_SUPPORT_64
186    TEST_IGNORE();
187#else
188    UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
189
190    TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message.");
191#endif
192}
193
194void testUInt64ArrayWithinDelta(void)
195{
196#ifndef UNITY_SUPPORT_64
197    TEST_IGNORE();
198#else
199    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
200    UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005};
201    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
202
203    TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3);
204    TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3);
205#endif
206}
207
208void testUInt64ArrayWithinDeltaAndMessage(void)
209{
210#ifndef UNITY_SUPPORT_64
211    TEST_IGNORE();
212#else
213    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
214    UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005};
215    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
216
217    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message.");
218    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message.");
219#endif
220}
221
222void testUInt64ArrayNotWithinDelta(void)
223{
224#ifndef UNITY_SUPPORT_64
225    TEST_IGNORE();
226#else
227    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
228    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
229
230    EXPECT_ABORT_BEGIN
231    TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3);
232    VERIFY_FAILS_END
233#endif
234}
235
236void testUInt64ArrayNotWithinDeltaAndMessage(void)
237{
238#ifndef UNITY_SUPPORT_64
239    TEST_IGNORE();
240#else
241    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
242    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
243
244    EXPECT_ABORT_BEGIN
245    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message.");
246    VERIFY_FAILS_END
247#endif
248}
249
250void testUInt64ArrayWithinDeltaPointless(void)
251{
252#ifndef UNITY_SUPPORT_64
253    TEST_IGNORE();
254#else
255    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
256    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
257
258    EXPECT_ABORT_BEGIN
259    TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0);
260    VERIFY_FAILS_END
261#endif
262}
263
264void testUInt64ArrayWithinDeltaPointlessAndMessage(void)
265{
266#ifndef UNITY_SUPPORT_64
267    TEST_IGNORE();
268#else
269    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
270    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
271
272    EXPECT_ABORT_BEGIN
273    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message.");
274    VERIFY_FAILS_END
275#endif
276}
277
278void testUInt64ArrayWithinDeltaExpectedNull(void)
279{
280#ifndef UNITY_SUPPORT_64
281    TEST_IGNORE();
282#else
283    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
284
285    EXPECT_ABORT_BEGIN
286    TEST_ASSERT_UINT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3);
287    VERIFY_FAILS_END
288#endif
289}
290
291void testUInt64ArrayWithinDeltaExpectedNullAndMessage(void)
292{
293#ifndef UNITY_SUPPORT_64
294    TEST_IGNORE();
295#else
296    UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
297
298    EXPECT_ABORT_BEGIN
299    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message.");
300    VERIFY_FAILS_END
301#endif
302}
303
304void testUInt64ArrayWithinDeltaActualNull(void)
305{
306#ifndef UNITY_SUPPORT_64
307    TEST_IGNORE();
308#else
309    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
310
311    EXPECT_ABORT_BEGIN
312    TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, NULL, 3);
313    VERIFY_FAILS_END
314#endif
315}
316
317void testUInt64ArrayWithinDeltaActualNullAndMessage(void)
318{
319#ifndef UNITY_SUPPORT_64
320    TEST_IGNORE();
321#else
322    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
323
324    EXPECT_ABORT_BEGIN
325    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message.");
326    VERIFY_FAILS_END
327#endif
328}
329
330void testUInt64ArrayWithinDeltaSamePointer(void)
331{
332#ifndef UNITY_SUPPORT_64
333    TEST_IGNORE();
334#else
335    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
336
337    TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3);
338#endif
339}
340
341void testUInt64ArrayWithinDeltaSamePointerAndMessage(void)
342{
343#ifndef UNITY_SUPPORT_64
344    TEST_IGNORE();
345#else
346    UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
347
348    TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message.");
349#endif
350}
351
352void testHEX64ArrayWithinDelta(void)
353{
354#ifndef UNITY_SUPPORT_64
355    TEST_IGNORE();
356#else
357    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
358    UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000};
359    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
360
361    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualSmallDelta, 3);
362    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 3);
363#endif
364}
365
366void testHEX64ArrayWithinDeltaAndMessage(void)
367{
368#ifndef UNITY_SUPPORT_64
369    TEST_IGNORE();
370#else
371    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
372    UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000};
373    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
374
375    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualSmallDelta, 3, "Custom Message.");
376    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 3, "Custom Message.");
377#endif
378}
379
380void testHEX64ArrayNotWithinDelta(void)
381{
382#ifndef UNITY_SUPPORT_64
383    TEST_IGNORE();
384#else
385    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
386    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
387
388    EXPECT_ABORT_BEGIN
389    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualBigDelta, 3);
390    VERIFY_FAILS_END
391#endif
392}
393
394void testHEX64ArrayNotWithinDeltaAndMessage(void)
395{
396#ifndef UNITY_SUPPORT_64
397    TEST_IGNORE();
398#else
399    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
400    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
401
402    EXPECT_ABORT_BEGIN
403    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualBigDelta, 3, "Custom Message.");
404    VERIFY_FAILS_END
405#endif
406}
407
408void testHEX64ArrayWithinDeltaPointless(void)
409{
410#ifndef UNITY_SUPPORT_64
411    TEST_IGNORE();
412#else
413    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
414    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
415
416    EXPECT_ABORT_BEGIN
417    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 0);
418    VERIFY_FAILS_END
419#endif
420}
421
422void testHEX64ArrayWithinDeltaPointlessAndMessage(void)
423{
424#ifndef UNITY_SUPPORT_64
425    TEST_IGNORE();
426#else
427    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
428    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
429
430    EXPECT_ABORT_BEGIN
431    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 0, "Custom Message.");
432    VERIFY_FAILS_END
433#endif
434}
435
436void testHEX64ArrayWithinDeltaExpectedNull(void)
437{
438#ifndef UNITY_SUPPORT_64
439    TEST_IGNORE();
440#else
441    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
442
443    EXPECT_ABORT_BEGIN
444    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, NULL, actualBigDelta, 3);
445    VERIFY_FAILS_END
446#endif
447}
448
449void testHEX64ArrayWithinDeltaExpectedNullAndMessage(void)
450{
451#ifndef UNITY_SUPPORT_64
452    TEST_IGNORE();
453#else
454    UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
455
456    EXPECT_ABORT_BEGIN
457    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, NULL, actualBigDelta, 3, "Custom Message.");
458    VERIFY_FAILS_END
459#endif
460}
461
462void testHEX64ArrayWithinDeltaActualNull(void)
463{
464#ifndef UNITY_SUPPORT_64
465    TEST_IGNORE();
466#else
467    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
468
469    EXPECT_ABORT_BEGIN
470    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, NULL, 3);
471    VERIFY_FAILS_END
472#endif
473}
474
475void testHEX64ArrayWithinDeltaActualNullAndMessage(void)
476{
477#ifndef UNITY_SUPPORT_64
478    TEST_IGNORE();
479#else
480    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
481
482    EXPECT_ABORT_BEGIN
483    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, NULL, 3, "Custom Message.");
484    VERIFY_FAILS_END
485#endif
486}
487
488void testHEX64ArrayWithinDeltaSamePointer(void)
489{
490#ifndef UNITY_SUPPORT_64
491    TEST_IGNORE();
492#else
493    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
494
495    TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, expected, 3);
496#endif
497}
498
499void testHEX64ArrayWithinDeltaSamePointerAndMessage(void)
500{
501#ifndef UNITY_SUPPORT_64
502    TEST_IGNORE();
503#else
504    UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
505
506    TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, expected, 3, "Custom Message.");
507#endif
508}
509
510void testEqualHex64s(void)
511{
512#ifndef UNITY_SUPPORT_64
513    TEST_IGNORE();
514#else
515    UNITY_UINT64 v0, v1;
516    UNITY_UINT64 *p0, *p1;
517
518    v0 = 0x9876543201234567;
519    v1 = 0x9876543201234567;
520    p0 = &v0;
521    p1 = &v1;
522
523    TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567);
524    TEST_ASSERT_EQUAL_HEX64(v0, v1);
525    TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1);
526    TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567);
527    TEST_ASSERT_EQUAL_HEX64(*p0, v1);
528    TEST_ASSERT_EQUAL_HEX64(*p0, *p1);
529    TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567);
530#endif
531}
532
533void testEqualUint64s(void)
534{
535#ifndef UNITY_SUPPORT_64
536    TEST_IGNORE();
537#else
538    UNITY_UINT64 v0, v1;
539    UNITY_UINT64 *p0, *p1;
540
541    v0 = 0x9876543201234567;
542    v1 = 0x9876543201234567;
543    p0 = &v0;
544    p1 = &v1;
545
546    TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567);
547    TEST_ASSERT_EQUAL_UINT64(v0, v1);
548    TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1);
549    TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567);
550    TEST_ASSERT_EQUAL_UINT64(*p0, v1);
551    TEST_ASSERT_EQUAL_UINT64(*p0, *p1);
552    TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567);
553#endif
554}
555
556void testEqualInt64s(void)
557{
558#ifndef UNITY_SUPPORT_64
559    TEST_IGNORE();
560#else
561    UNITY_INT64 v0, v1;
562    UNITY_INT64 *p0, *p1;
563
564    v0 = (UNITY_INT64)0x9876543201234567;
565    v1 = (UNITY_INT64)0x9876543201234567;
566    p0 = &v0;
567    p1 = &v1;
568
569    TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567);
570    TEST_ASSERT_EQUAL_INT64(v0, v1);
571    TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1);
572    TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567);
573    TEST_ASSERT_EQUAL_INT64(*p0, v1);
574    TEST_ASSERT_EQUAL_INT64(*p0, *p1);
575    TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567);
576#endif
577}
578
579
580void testNotEqualHex64s(void)
581{
582#ifndef UNITY_SUPPORT_64
583    TEST_IGNORE();
584#else
585    UNITY_UINT64 v0, v1;
586
587    v0 = 9000000000;
588    v1 = 9100000000;
589
590    EXPECT_ABORT_BEGIN
591    TEST_ASSERT_EQUAL_HEX64(v0, v1);
592    VERIFY_FAILS_END
593#endif
594}
595
596void testNotEqualUint64s(void)
597{
598#ifndef UNITY_SUPPORT_64
599    TEST_IGNORE();
600#else
601    UNITY_UINT64 v0, v1;
602
603    v0 = 9000000000;
604    v1 = 9100000000;
605
606    EXPECT_ABORT_BEGIN
607    TEST_ASSERT_EQUAL_UINT64(v0, v1);
608    VERIFY_FAILS_END
609#endif
610}
611
612void testNotEqualInt64s(void)
613{
614#ifndef UNITY_SUPPORT_64
615    TEST_IGNORE();
616#else
617    UNITY_INT64 v0, v1;
618
619    v0 = -9000000000;
620    v1 = 9100000000;
621
622    EXPECT_ABORT_BEGIN
623    TEST_ASSERT_EQUAL_INT64(v0, v1);
624    VERIFY_FAILS_END
625#endif
626}
627
628void testNotEqualHex64sIfSigned(void)
629{
630#ifndef UNITY_SUPPORT_64
631    TEST_IGNORE();
632#else
633    UNITY_INT64 v0, v1;
634
635    v0 = -9000000000;
636    v1 = 9000000000;
637
638    EXPECT_ABORT_BEGIN
639    TEST_ASSERT_EQUAL_HEX64(v0, v1);
640    VERIFY_FAILS_END
641#endif
642}
643
644void testHEX64sWithinDelta(void)
645{
646#ifndef UNITY_SUPPORT_64
647    TEST_IGNORE();
648#else
649    TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
650    TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996);
651    TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005);
652#endif
653}
654
655void testHEX32sWithinDeltaShouldIgnoreSign(void)
656{
657#ifndef UNITY_SUPPORT_64
658    TEST_IGNORE();
659#else
660    TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x8000000000000000);
661#endif
662}
663
664void testHEX64sNotWithinDelta(void)
665{
666#ifndef UNITY_SUPPORT_64
667    TEST_IGNORE();
668#else
669    EXPECT_ABORT_BEGIN
670    TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
671    VERIFY_FAILS_END
672#endif
673}
674
675void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
676{
677#ifndef UNITY_SUPPORT_64
678    TEST_IGNORE();
679#else
680    EXPECT_ABORT_BEGIN
681    TEST_ASSERT_HEX64_WITHIN(5, 1, -1);
682    VERIFY_FAILS_END
683#endif
684}
685
686void testUINT64sWithinDelta(void)
687{
688#ifndef UNITY_SUPPORT_64
689    TEST_IGNORE();
690#else
691    TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
692    TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996);
693    TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005);
694#endif
695}
696
697void testUINT64sNotWithinDelta(void)
698{
699#ifndef UNITY_SUPPORT_64
700    TEST_IGNORE();
701#else
702    EXPECT_ABORT_BEGIN
703    TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
704    VERIFY_FAILS_END
705#endif
706}
707
708void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
709{
710#ifndef UNITY_SUPPORT_64
711    TEST_IGNORE();
712#else
713    EXPECT_ABORT_BEGIN
714    TEST_ASSERT_UINT64_WITHIN(5, 1, -1);
715    VERIFY_FAILS_END
716#endif
717}
718
719void testINT64sWithinDelta(void)
720{
721#ifndef UNITY_SUPPORT_64
722    TEST_IGNORE();
723#else
724    TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
725    TEST_ASSERT_INT64_WITHIN(5, 5000, 4996);
726    TEST_ASSERT_INT64_WITHIN(5, 5000, 5005);
727#endif
728}
729
730void testINT64sNotWithinDelta(void)
731{
732#ifndef UNITY_SUPPORT_64
733    TEST_IGNORE();
734#else
735    EXPECT_ABORT_BEGIN
736    TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
737    VERIFY_FAILS_END
738#endif
739}
740
741void testINT64sNotWithinDeltaAndDifferenceOverflows(void)
742{
743#ifndef UNITY_SUPPORT_64
744    TEST_IGNORE();
745#else
746    EXPECT_ABORT_BEGIN
747    TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF);
748    VERIFY_FAILS_END
749#endif
750}
751
752void testPrintNumbersInt64(void)
753{
754#ifndef UNITY_SUPPORT_64
755    TEST_IGNORE();
756#else
757  #ifndef USING_OUTPUT_SPY
758    TEST_IGNORE();
759  #else
760    TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0);
761    TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000);
762    TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (UNITY_INT)0x8000000000000000);
763    TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT)0xFFFFFFFFFFFFFFFF);
764  #endif
765#endif
766}
767
768void testPrintNumbersUInt64(void)
769{
770#ifndef UNITY_SUPPORT_64
771    TEST_IGNORE();
772#else
773  #ifndef USING_OUTPUT_SPY
774    TEST_IGNORE();
775  #else
776    TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0);
777    TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000);
778    TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808",  (UNITY_UINT)0x8000000000000000);
779    TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (UNITY_UINT)0xFFFFFFFFFFFFFFFF);
780  #endif
781#endif
782}
783