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
11 static int SetToOneToFailInTearDown;
12 static int SetToOneMeanWeAlreadyCheckedThisGuy;
13
setUp(void)14 void setUp(void)
15 {
16 SetToOneToFailInTearDown = 0;
17 SetToOneMeanWeAlreadyCheckedThisGuy = 0;
18 }
19
tearDown(void)20 void 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
testInt64ArrayWithinDelta(void)36 void 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
testInt64ArrayWithinDeltaAndMessage(void)50 void 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
testInt64ArrayNotWithinDelta(void)64 void 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
testInt64ArrayNotWithinDeltaAndMessage(void)78 void 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
testInt64ArrayWithinDeltaPointless(void)92 void 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
testInt64ArrayWithinDeltaPointlessAndMessage(void)106 void 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
testInt64ArrayWithinDeltaExpectedNull(void)120 void 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
testInt64ArrayWithinDeltaExpectedNullAndMessage(void)133 void 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
testInt64ArrayWithinDeltaActualNull(void)146 void 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
testInt64ArrayWithinDeltaActualNullAndMessage(void)159 void 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
testInt64ArrayWithinDeltaSamePointer(void)172 void 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
testInt64ArrayWithinDeltaSamePointerAndMessage(void)183 void 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
testUInt64ArrayWithinDelta(void)194 void 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
testUInt64ArrayWithinDeltaAndMessage(void)208 void 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
testUInt64ArrayNotWithinDelta(void)222 void 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
testUInt64ArrayNotWithinDeltaAndMessage(void)236 void 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
testUInt64ArrayWithinDeltaPointless(void)250 void 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
testUInt64ArrayWithinDeltaPointlessAndMessage(void)264 void 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
testUInt64ArrayWithinDeltaExpectedNull(void)278 void 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
testUInt64ArrayWithinDeltaExpectedNullAndMessage(void)291 void 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
testUInt64ArrayWithinDeltaActualNull(void)304 void 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
testUInt64ArrayWithinDeltaActualNullAndMessage(void)317 void 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
testUInt64ArrayWithinDeltaSamePointer(void)330 void 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
testUInt64ArrayWithinDeltaSamePointerAndMessage(void)341 void 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
testHEX64ArrayWithinDelta(void)352 void 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
testHEX64ArrayWithinDeltaAndMessage(void)366 void 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
testHEX64ArrayNotWithinDelta(void)380 void 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
testHEX64ArrayNotWithinDeltaAndMessage(void)394 void 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
testHEX64ArrayWithinDeltaPointless(void)408 void 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
testHEX64ArrayWithinDeltaPointlessAndMessage(void)422 void 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
testHEX64ArrayWithinDeltaExpectedNull(void)436 void 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
testHEX64ArrayWithinDeltaExpectedNullAndMessage(void)449 void 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
testHEX64ArrayWithinDeltaActualNull(void)462 void 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
testHEX64ArrayWithinDeltaActualNullAndMessage(void)475 void 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
testHEX64ArrayWithinDeltaSamePointer(void)488 void 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
testHEX64ArrayWithinDeltaSamePointerAndMessage(void)499 void 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
testEqualHex64s(void)510 void 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
testEqualUint64s(void)533 void 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
testEqualInt64s(void)556 void 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
testNotEqualHex64s(void)580 void 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
testNotEqualUint64s(void)596 void 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
testNotEqualInt64s(void)612 void 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
testNotEqualHex64sIfSigned(void)628 void 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
testHEX64sWithinDelta(void)644 void 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
testHEX32sWithinDeltaShouldIgnoreSign(void)655 void 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
testHEX64sNotWithinDelta(void)664 void 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
testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)675 void 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
testUINT64sWithinDelta(void)686 void 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
testUINT64sNotWithinDelta(void)697 void 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
testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)708 void 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
testINT64sWithinDelta(void)719 void 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
testINT64sNotWithinDelta(void)730 void 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
testINT64sNotWithinDeltaAndDifferenceOverflows(void)741 void 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
testPrintNumbersInt64(void)752 void 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
testPrintNumbersUInt64(void)768 void 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